@fusion.dev/helix 0.7.2 → 0.8.1

package/custom-elements.json

@@ -39490,6 +39490,14 @@
             "module": "src/option/index.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/orb/index.js"
+          }
+        },
         {
           "kind": "js",
           "name": "*",
@@ -54582,6 +54590,920 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/orb/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/orb/root/orb-root.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/orb/root/orb-shapes.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/orb/root/orb-root.css.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "styles"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "styles",
+          "declaration": {
+            "name": "styles",
+            "module": "src/orb/root/orb-root.css.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/orb/root/orb-root.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "A cloud of dots on a sphere, drawn to a canvas, with one shape per state:\n`thinking` is a narrow sash with a wave running through it, `fetching` spreads\ninto a globe with a highlight sweeping pole to pole, `working` flattens and\ntilts with its bands shearing past each other, and `done` settles into an even\nball.\n\n**None of them is a separate drawing.** Each is the same banded sphere given\ndifferent numbers, so changing state interpolates the numbers and every frame\nin between is a whole shape. A loader that cuts between pictures says the\nwork restarted; one that carries a shape into the next says it moved on.\n\n**Nothing spins.** All the movement is inside the shape, which is what makes\nit read as thought rather than as a thing being rotated.\n\n**The palette is read from the tokens**, not given as colors: a dot's ink is\nmixed toward the ground by how far away it is, and both ends come from\n`--orb-color` and `--orb-ground`. That is what makes depth survive a theme\nchange without the consumer restating anything.\n\n**It stops when nobody is looking**, off screen and in a background tab, and\n`prefers-reduced-motion` gets one still frame rather than an empty box.",
+          "name": "HelixOrb",
+          "cssProperties": [
+            {
+              "description": "Ink of the nearest dots. Defaults to `currentColor`.",
+              "name": "--orb-color"
+            },
+            {
+              "description": "What the far dots are mixed toward. Defaults to the page's background.",
+              "name": "--orb-ground"
+            },
+            {
+              "description": "Diameter. Overrides `size`.",
+              "name": "--orb-size"
+            }
+          ],
+          "cssParts": [
+            {
+              "description": "The surface the cloud is drawn into.",
+              "name": "canvas"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Accessible name, where the state's own word is not the right one.\n\nEmpty is the state's word, which is what most callers want and none of them\nshould have to write. A caller with something better to say says it here:\nthe name of the tool being run, or the file being read.",
+              "attribute": "label"
+            },
+            {
+              "kind": "field",
+              "name": "size",
+              "type": {
+                "text": "'lg' | 'sm' | undefined"
+              },
+              "description": "Diameter relative to the surrounding text.\n\nReflected because the stylesheet selects on it. The mesh is chosen from the\nrendered box rather than from this, so `--orb-size` and a consumer's own\n`inline-size` get the same treatment as the three named steps.",
+              "attribute": "size",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "state",
+              "type": {
+                "text": "OrbState"
+              },
+              "default": "'thinking'",
+              "description": "What the agent is doing.\n\n**A name we do not draw is drawn as `thinking` rather than as nothing.**\nThe set of things an agent can be doing grows faster than this list, and a\nverb we have not made a shape for should cost a reader a less specific\nindicator, not an empty box where the indicator was.\n\nNot reflected: no rule selects on it, because the state is drawn rather than\nstyled. A consumer writing the attribute can still select on their own\nmarkup.",
+              "attribute": "state"
+            },
+            {
+              "kind": "field",
+              "name": "canvas",
+              "type": {
+                "text": "HTMLCanvasElement | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "context",
+              "type": {
+                "text": "CanvasRenderingContext2D | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "motion",
+              "type": {
+                "text": "MediaQueryList | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "visible",
+              "type": {
+                "text": "IntersectionObserver | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "sized",
+              "type": {
+                "text": "ResizeObserver | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "frame",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0"
+            },
+            {
+              "kind": "field",
+              "name": "running",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false"
+            },
+            {
+              "kind": "field",
+              "name": "onScreen",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false"
+            },
+            {
+              "kind": "field",
+              "name": "box",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "The box the canvas was last measured at, in CSS pixels."
+            },
+            {
+              "kind": "field",
+              "name": "from",
+              "type": {
+                "text": "OrbParams"
+              },
+              "privacy": "private",
+              "description": "Where the cloud is now, and where it is heading.\n\n**`from` holds numbers rather than the name of a state**, which is what\nmakes an interruption free: changing state mid-transition snapshots the\nblend that is on the screen at that instant and departs from it. Holding a\nname forces a choice between the shape being left and the shape being\napproached, and either one is a jump the reader sees."
+            },
+            {
+              "kind": "field",
+              "name": "morphAt",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0"
+            },
+            {
+              "kind": "field",
+              "name": "phase",
+              "privacy": "private",
+              "default": "1.4",
+              "description": "The state's clock, accumulated rather than derived.\n\n**`elapsed * rate` looks equivalent and is not.** `rate` is one of the\nnumbers a transition interpolates, and multiplying a running clock by a\nchanging rate throws the phase forward by the elapsed time times the\nchange. A minute in, a rate moving from 2.1 to 2.4 skips the wave thirty\nseconds ahead, and the orb lurches on every state change. Integrating the\nrate has no such term.",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "last",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0"
+            },
+            {
+              "kind": "method",
+              "name": "start",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "measure",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Matches the drawing buffer to the box, and reports whether it changed.\n\nCapped at two device pixels: past that the dot count is unchanged and the\nfill cost doubles again for a mesh already drawn sub-pixel."
+            },
+            {
+              "kind": "method",
+              "name": "turn",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Begins a transition from whatever is on the screen right now."
+            },
+            {
+              "kind": "field",
+              "name": "progress",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "description": "How far through a transition, `1` when there is not one.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "paramsNow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "OrbParams"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "play",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "stop",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "tick",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "handleVisibility",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "handleMotion",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "paint",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "dt",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "One frame.\n\nPainter's algorithm: every dot is sorted by depth and drawn back to front,\nbecause a near dot has to cover a far one for the cloud to read as a solid\nrather than as a smear."
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\n`unsafeStatic` is safe by construction: the name is a literal in our own\nsource and the prefix is one of two strings this class defines. Called per\nrender and not cached, which costs nothing, because `static-html` keys its\ntemplate cache on the joined string rather than on the object.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang race it\nagainst a timeout; `readyToMove` does exactly that.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "attributes": [
+            {
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Accessible name, where the state's own word is not the right one.\n\nEmpty is the state's word, which is what most callers want and none of them\nshould have to write. A caller with something better to say says it here:\nthe name of the tool being run, or the file being read.",
+              "fieldName": "label"
+            },
+            {
+              "name": "size",
+              "type": {
+                "text": "'lg' | 'sm' | undefined"
+              },
+              "description": "Diameter relative to the surrounding text.\n\nReflected because the stylesheet selects on it. The mesh is chosen from the\nrendered box rather than from this, so `--orb-size` and a consumer's own\n`inline-size` get the same treatment as the three named steps.",
+              "fieldName": "size"
+            },
+            {
+              "name": "state",
+              "type": {
+                "text": "OrbState"
+              },
+              "default": "'thinking'",
+              "description": "What the agent is doing.\n\n**A name we do not draw is drawn as `thinking` rather than as nothing.**\nThe set of things an agent can be doing grows faster than this list, and a\nverb we have not made a shape for should cost a reader a less specific\nindicator, not an empty box where the indicator was.\n\nNot reflected: no rule selects on it, because the state is drawn rather than\nstyled. A consumer writing the attribute can still select on their own\nmarkup.",
+              "fieldName": "state"
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "package": "@fusion.dev/helix-core"
+          },
+          "summary": "Says what an agent is doing, as a shape rather than a word.",
+          "helix": {
+            "category": "feedback",
+            "since": "0.8.0",
+            "status": "experimental",
+            "documentation": "https://helix.fusion.dev/components/orb",
+            "aliases": [
+              "Thinking",
+              "Activity",
+              "Agent",
+              "Status"
+            ],
+            "tier": "styled",
+            "group": "Orb",
+            "part": "Root",
+            "examples": [
+              {
+                "description": "An agent at work, drawn as a shape rather than said in a word.",
+                "slug": "preview"
+              },
+              {
+                "description": "An orb sized to the line of text it sits beside.",
+                "slug": "on-the-line"
+              },
+              {
+                "description": "The orb at each size it comes in.",
+                "slug": "sizes"
+              },
+              {
+                "description": "The four shapes, side by side.",
+                "slug": "states"
+              }
+            ],
+            "source": "helix/styled/src/orb"
+          },
+          "tagName": "helix-orb",
+          "customElement": true,
+          "modulePath": "src/orb/root/orb-root.ts",
+          "definitionPath": "src/orb/root/orb-root.ts"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixOrb",
+          "declaration": {
+            "name": "HelixOrb",
+            "module": "src/orb/root/orb-root.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "helix-orb",
+          "declaration": {
+            "name": "HelixOrb",
+            "module": "src/orb/root/orb-root.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/orb/root/orb-shapes.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "ORB_STATES",
+          "type": {
+            "text": "['thinking', 'fetching', 'working', 'done']"
+          },
+          "default": "['thinking', 'fetching', 'working', 'done']",
+          "description": "The states an orb can be in, in the order a task tends to pass through them.\n\nExported so the component can validate an attribute against the same list the\ngenerator reads, rather than keeping a second copy that drifts."
+        },
+        {
+          "kind": "variable",
+          "name": "ORB_PARAMS",
+          "type": {
+            "text": "Record<OrbState, OrbParams>"
+          },
+          "default": "{ /* Settled: an even ball, breathing, with nothing traveling through it. */ done: { belt: 1, edge: 0, jitter: 1, rate: 1.1, rot: 0, scan: 0, shear: 0, squash: 1, waveA: 0, waveB: 0, }, /* The sash opened out into a globe, with a highlight sweeping pole to pole: the shape of looking through something. */ fetching: { belt: 1, edge: 0, jitter: 0, rate: 2.4, rot: 0, scan: 1, shear: 0, squash: 1, waveA: 0, waveB: 0, }, /* A narrow sash with a wave running through it, tipped so the band crosses the face rather than sitting level. */ thinking: { belt: 0.47, edge: 1, jitter: 0, rate: 2.1, rot: 1.52, scan: 0, shear: 0, squash: 1, waveA: 0.16, waveB: 0.07, }, /* Flattened and tilted, bands shearing past each other. **The squash is what makes this state legible at 20px**: `fetching` and `working` are both full spheres, and at that size a difference in motion alone is not a difference a reader can see. A silhouette is. */ working: { belt: 1, edge: 0, jitter: 0, rate: 2.4, rot: 0.5, scan: 0, shear: 1.3, squash: 0.72, waveA: 0, waveB: 0, }, }",
+          "description": "Each state, as numbers.\n\nThey are deliberately close together. Two states that differ in every number\ntake a long, busy route between them; these differ in the two or three that\ncarry the meaning, so a transition reads as one thing becoming another rather\nthan as a shuffle."
+        },
+        {
+          "kind": "function",
+          "name": "blendParams",
+          "return": {
+            "type": {
+              "text": "OrbParams"
+            }
+          },
+          "parameters": [
+            {
+              "name": "a",
+              "type": {
+                "text": "OrbParams"
+              }
+            },
+            {
+              "name": "b",
+              "type": {
+                "text": "OrbParams"
+              }
+            },
+            {
+              "name": "k",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "Halfway between two states, key by key."
+        },
+        {
+          "kind": "function",
+          "name": "paramsFor",
+          "return": {
+            "type": {
+              "text": "OrbParams"
+            }
+          },
+          "parameters": [
+            {
+              "name": "state",
+              "type": {
+                "text": "string | undefined"
+              }
+            }
+          ],
+          "description": "The state's numbers, or `thinking`'s where the name is not one we draw."
+        },
+        {
+          "kind": "function",
+          "name": "smoother",
+          "return": {
+            "type": {
+              "text": "number"
+            }
+          },
+          "parameters": [
+            {
+              "name": "t",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "Smootherstep: zero slope and zero acceleration at both ends."
+        },
+        {
+          "kind": "function",
+          "name": "fibonacci",
+          "return": {
+            "type": {
+              "text": "[number, number, number]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "i",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "n",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "A point of the Fibonacci sphere, which is the evenest cheap one."
+        },
+        {
+          "kind": "function",
+          "name": "evenSphere",
+          "return": {
+            "type": {
+              "text": "[number, number, number][]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "lanes",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "segs",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The even sphere `done` settles into, ordered so the band grid can address it.\n\n**The azimuth is measured from the same origin and in the same direction as\nthe generator's longitude**, and that is not a detail. With `atan2`'s own\nrange the two orderings sit half a turn apart: every dot is handed a\ndestination across the ball, and the blend carries the whole cloud through its\nown axis. It showed as a near-empty frame midway through every transition\ninto `done`, and nowhere else, because no single state reads this ordering."
+        },
+        {
+          "kind": "function",
+          "name": "orbPoint",
+          "return": {
+            "type": {
+              "text": "[number, number, number]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "u",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "v",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "phase",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "p",
+              "type": {
+                "text": "OrbParams"
+              }
+            },
+            {
+              "name": "index",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "even",
+              "type": {
+                "text": "[number, number, number][]"
+              }
+            }
+          ],
+          "description": "One dot, from its place in the grid and the state's numbers.\n\n`u` runs across the bands and `v` around them, both `0` to `1`, and `phase`\nis the state's own accumulated clock."
+        },
+        {
+          "kind": "function",
+          "name": "meshFor",
+          "return": {
+            "type": {
+              "text": "OrbMesh"
+            }
+          },
+          "parameters": [
+            {
+              "name": "size",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The mesh for a given diameter.\n\n**The dot budget falls as `size^1.37`** and the two axes of the grid each take\nits square root, which is the relationship the reference libraries land on\nacross their own three tunings. Dots are drawn sub-pixel and their radius\nscales as `size^0.6`; small orbs get relatively fatter dots, or the mesh\ndisappears into the pixel grid.\n\n**The tonal range is compressed as the orb shrinks.** Depth drawn as a\n0.6-wide gray ramp is legible at 64px and invisible at 20, where the far side\nof the sphere is three pixels across: below 64 the ramp narrows and the alpha\nfloor lifts, trading depth for a mark that is actually on the screen."
+        },
+        {
+          "kind": "function",
+          "name": "project",
+          "return": {
+            "type": {
+              "text": "[number, number, number]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "size",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "x",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "y",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "z",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "Projects a point on the unit sphere to canvas pixels, with its depth."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "ORB_STATES",
+          "declaration": {
+            "name": "ORB_STATES",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ORB_PARAMS",
+          "declaration": {
+            "name": "ORB_PARAMS",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "blendParams",
+          "declaration": {
+            "name": "blendParams",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "paramsFor",
+          "declaration": {
+            "name": "paramsFor",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "smoother",
+          "declaration": {
+            "name": "smoother",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "fibonacci",
+          "declaration": {
+            "name": "fibonacci",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "evenSphere",
+          "declaration": {
+            "name": "evenSphere",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "orbPoint",
+          "declaration": {
+            "name": "orbPoint",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "meshFor",
+          "declaration": {
+            "name": "meshFor",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "project",
+          "declaration": {
+            "name": "project",
+            "module": "src/orb/root/orb-shapes.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/outline/index.ts",