@fusion.dev/helix-docs 0.0.0-dev

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fusion Development Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/content/accessibility.mdx

@@ -0,0 +1,117 @@
+---
+description: What the library guarantees, what it cannot, and where the line is.
+section: Foundations
+title: Accessibility
+---
+
+# Accessibility
+
+Some of accessibility is structural, and a component can own it. Some of it is
+about your content, and no component can. Knowing which is which is the
+difference between a page that is accessible and a page built out of accessible
+parts.
+
+## What the library owns
+
+**Roles, states and keyboard interaction.** Every component implements the
+pattern its role implies: arrow keys move within a `Tabs`, a `Listbox` and a
+`Menu`, `Escape` dismisses an overlay, `Home` and `End` go to the ends, typing
+jumps to a match. None of that is yours to write.
+
+**Focus, including trapping and restoring it.** A `Dialog` traps focus while
+open and returns it to whatever opened it. So do `Drawer` and the modal path of
+`Popover`.
+
+**Contrast, by construction rather than by review.** The theme engine measures
+every foreground against the ground it is really painted on and solves for the
+target rather than checking afterwards. Every pairing is then re-measured on a
+laid-out page, including the great majority of rules that set an ink or a ground
+but not both, so a pairing nobody thought of is still checked. See [Surfaces and
+separation](./surfaces-and-separation).
+
+**Reduced motion, per component.** Fifty-nine stylesheets answer
+`prefers-reduced-motion` individually, because they have to: the base layer's
+global rule is `*, *::before, *::after` in the document, and `*` does not cross
+a shadow boundary, so it reaches your prose and none of the components.
+A component that animates without answering fails the build.
+
+**Disabled without disappearing.** `disabled` is mirrored to `aria-disabled`
+rather than removing the control from the accessibility tree, so a screen reader
+can still announce that the control exists and is currently off.
+
+## What you own
+
+**Names.** A component can render a label; it cannot know what to call your
+thing. Every control takes `label`, and an icon-only control has nothing else to
+go on:
+
+```html
+<helix-icon-button
+  label="Close"
+  name="x"
+></helix-icon-button>
+```
+
+**`label` means a label and `aria-label` means a name.** They are not synonyms
+here. `label` renders visible text and names the control through it;
+`aria-label` names the control with nothing on screen. Reach for the second only
+when the page already makes the purpose plain, which is rarer than it feels.
+
+**Heading order.** Components render the heading levels you give them, not
+levels they guess. A `Card` does not emit an `h2` on your behalf, because it
+cannot know what is above it.
+
+**Language and direction.** Set `lang` and `dir` on the document. Components use
+logical properties throughout, so a right-to-left document lays out correctly,
+but nothing infers the direction for you.
+See [Localization and RTL](./localization).
+
+**Live regions for your own updates.** The components announce their own state
+changes. A message from your application needs somewhere to be announced:
+
+```html
+<helix-announcement tone="warning">Your trial ends on Friday.</helix-announcement>
+```
+
+`Announcement` is always a polite live region, never assertive. `role="alert"`
+interrupts whatever is being read, which is right for something that appears
+mid-session and wrong for something that was in the served HTML: an assertive
+announcement would cut across a screen-reader user on every page load, before
+they had read anything. Politeness costs a moment and is never wrong.
+
+Note the distinction from `Callout`, which is a passage that interrupts a
+document and is read where it sits. Neither is a variant of the other.
+
+## Two things the shadow boundary changes
+
+**IDREFs do not cross it.** `aria-labelledby` and `aria-describedby` inside a
+shadow root cannot resolve to an id in your document, and the reference is
+dropped silently rather than erroring. This is why every control renders its own
+label instead of being wrapped by one, and why wiring two components together by
+id does not work. See [Forms and validation](./forms).
+
+**`<label for>` cannot reach in either.** A `<label>` in your markup will not
+name a Helix control. Use the control's own `label`.
+
+Where a relationship genuinely has to cross the boundary, the components use
+`ElementInternals` and element-reference properties rather than ids, which is
+the only mechanism that works. If you need the same for your own composition,
+that is the tool.
+
+## Hiding things correctly
+
+```html
+<span data-hidden-visually>Sorting by</span>
+```
+
+The base layer's `[data-hidden-visually]` clips rather than using
+`display: none` or `visibility: hidden`, both of which take the element out of
+the accessibility tree entirely, which is the opposite of what visually-hidden
+text is for.
+
+## What is not covered
+
+The library is tested in Chromium, by automated specs and by pixel baselines. It
+is not run through a screen reader on every release, and the components'
+patterns follow the ARIA authoring practices rather than being certified against
+them. Where you find a real failure, it is a bug: report it.

package/content/angular.mdx

@@ -0,0 +1,60 @@
+---
+description: The schema Angular needs before it will compile an unknown tag.
+parent: installation
+section: Getting started
+title: Angular
+---
+
+# Angular
+
+Angular refuses to compile a template containing a tag it does not recognize.
+That is a good default and it is the one thing standing between you and working
+Helix components.
+
+```ts
+import { CUSTOM_ELEMENTS_SCHEMA, Component } from '@angular/core'
+
+@Component({
+  schemas: [CUSTOM_ELEMENTS_SCHEMA],
+  standalone: true,
+  template: `<helix-button>Save</helix-button>`,
+})
+export class SaveButton {}
+```
+
+Declare it on the components that use Helix rather than globally if you can.
+`CUSTOM_ELEMENTS_SCHEMA` switches off unknown-element checking for the whole
+template it is on, so scoping it keeps the check for your own typos.
+
+## Binding
+
+```html
+<helix-input
+  (change)="name = $event.target.value"
+  [value]="name"
+/>
+```
+
+`[prop]` sets a property, which is what a non-string value needs, and `(event)`
+binds with `addEventListener`, so the event name is its own.
+
+**Do not use `attr.` for a stateful property.** `[attr.value]="name"` writes
+the attribute, which seeds the control and is then out of date the moment a
+reader types; the property is the live channel.
+
+## No typings ship for Angular
+
+There is no `angular.d.ts` in the package. `CUSTOM_ELEMENTS_SCHEMA` turns off
+the checking that typings would feed, so a generated file would describe types
+Angular has already agreed not to enforce. The manifest is published as
+`@fusion.dev/helix/custom-elements.json` if you want to generate something for your
+own codebase from it.
+
+The practical consequence is that a misspelled property fails silently here
+where it is a compile error in React, Vue and Svelte. Worth a note in review.
+
+## Taking a decision
+
+`value`, `open`, `checked` and `active` are seeds: the element applies its own
+changes from there. To take one decision, listen for the `helix-before-*` event
+and call `preventDefault()`. See [State and control](./state-and-control).

package/content/browser-support.mdx

@@ -0,0 +1,83 @@
+---
+description: The platform features this is built on, and what is actually tested.
+order: 5
+section: Getting started
+title: Browser support
+---
+
+# Browser support
+
+Helix is built on the platform rather than on a compatibility layer. There is no
+polyfill story, no transpiled fallback, and no configuration that trades
+features for reach: what the library needs is what your browser has to have.
+
+## What is tested
+
+**Chromium, through Playwright.** The DOM specs run in it, and 83 pixel
+baselines are captured in it, on Linux, with the network blocked.
+
+That is the honest extent of it. Everything below is a statement about which
+platform features the library uses, not a claim that we run the suite in Firefox
+and Safari. If you ship Helix to those and find something broken, that is a bug
+report we want, and it is not one we would have caught.
+
+## What the library uses
+
+| Feature | Where |
+|---|---|
+| Custom elements and shadow DOM | Everything |
+| `ElementInternals` | Form participation, and ARIA that has to cross a shadow boundary |
+| Popover API | Every overlay: menu, tooltip, select, combobox, dialog |
+| `light-dark()` | 761 declarations, 135 of them in the token layer |
+| `oklch()` | Every color in the system |
+| `:has()` | 11 rules, mostly relational styling of slotted content |
+| `@starting-style` | Entry transitions on overlays |
+| `:state()` | Every boolean state the library publishes: `open`, `checked`, `selected`, `invalid`, `read`, `has-label`, `settled`, `empty` |
+| `CSS.highlights` | Filter-match highlighting, in `Command` and `Combobox` |
+
+Positioning is `@floating-ui/dom` rather than CSS anchor positioning, which is a
+deliberate choice and the one place the library takes a dependency instead of
+the platform: anchor positioning is not yet available everywhere the rest of
+this list is.
+
+## What decides your floor
+
+**`light-dark()` and the Popover API.** Everything else on that list has been
+available longer. If you need to know whether a browser can run Helix, those are
+the two to check, because they are the newest things the library assumes and
+they are load-bearing: the first is how every token expresses both color modes
+in one declaration, and the second is how every overlay is drawn in the top
+layer.
+
+`:state()` is the third and is deliberately not with them, because it does
+degrade: a component that cannot record a state keeps whatever its resting rule
+draws, so a checkbox is drawn unchecked rather than drawn wrong or not at all.
+It is feature-tested at the one place that records any of them.
+
+Neither degrades usefully. A browser without `light-dark()` gets no color at
+all rather than one mode; a browser without popover gets overlays that render in
+flow. This is why there is no support table with a fallback column: there is no
+partial mode to be in.
+
+## `CSS.highlights` is the one exception
+
+`Command` and `Combobox` highlight the matched substring in their filtered
+results using the CSS Custom Highlight API. It is the least widely available
+thing here, and it is the only one that degrades gracefully: without it the
+results still filter, sort and select correctly, and the match is simply not
+highlighted.
+
+Nothing else in the library reads it.
+
+## No IE, no polyfills, no build flag
+
+There is no `browserslist` and no transpilation target, which is a decision
+rather than an oversight. A design system whose components are
+custom elements cannot be shipped to a browser without custom elements, and
+everything else on the list above arrived in the same generation of browsers
+that shipped those.
+
+If you need to support something older, the honest answer is the base layer:
+`@fusion.dev/helix-styles` is plain CSS with no JavaScript, and a page built from its
+recipes works considerably further back than the components do.
+See [Without a bundler](./without-a-bundler).

package/content/building-on-the-headless-tier.mdx

@@ -0,0 +1,143 @@
+---
+description: Using the headless tier as the foundation for a design system of your own.
+section: Essentials
+title: Building on the headless tier
+---
+
+# Building on the headless tier
+
+The headless tier is a set of components with no stylesheet: structure, ARIA,
+keyboard behavior, state and form participation, and nothing about how any of it
+looks. That makes it usable as a foundation rather than as a library you consume
+whole. Your tags, your stylesheets, our accessibility.
+
+This is a different thing from theming Helix. Theming keeps our components and
+changes their tokens. This keeps our behavior and replaces the presentation
+layer outright, under names of your own.
+
+## One line does it
+
+Every headless component renders its children by interpolating a tag rather than
+naming one, and the prefix comes from a static on the class:
+
+```ts
+import { HelixHeadlessCombobox } from '@fusion.dev/helix-headless/combobox'
+
+export class AcmeCombobox extends HelixHeadlessCombobox {
+  static override tier = 'acme-'
+}
+
+customElements.define('acme-combobox', AcmeCombobox)
+```
+
+That is the whole mechanism, and it is the same one the styled tier uses: it
+writes `static override tier = 'helix-'` and nothing else. The static appears 116
+times in the headless manifest, so it is discoverable rather than folklore.
+
+## The render graph is the part that will catch you
+
+**A component that renders another gives you two things to register, and only
+one of them is obvious.** Twenty-two of the 88 headless families interpolate
+another family's tag, across 89 call sites and seventeen distinct children.
+
+Register `acme-combobox` without also registering `acme-listbox` and the panel
+renders a tag nobody defined. That is not an error and not a warning: an
+unregistered custom element is an inert, unstyled inline box, so what you see is
+a combobox that appears not to open.
+
+| Family | Renders |
+|---|---|
+| `bar-chart`, `donut-chart`, `heatmap`, `line-chart` | `tooltip` |
+| `code-block` | `copy-button` |
+| `color-input` | `color-picker` |
+| `color-picker` | `button`, `button-group`, `slider` |
+| `combobox` | `listbox`, `tag` |
+| `command` | `dialog`, `listbox` |
+| `copy-button` | `tooltip` |
+| `data-table` | `pagination` |
+| `date-input` | `date-picker`, `tag` |
+| `file-input` | `tag` |
+| `notifications` | `format-date` |
+| `pagination` | `option`, `select` |
+| `select` | `listbox` |
+| `steps`, `tour` | `button` |
+| `time-input` | `tag`, `time-picker` |
+| `time-picker` | `listbox`, `option` |
+| `video`, `video-playlist` | `menu`, `menu-item` |
+
+The safe rule is to subclass and register a family together with everything it
+renders, transitively: `command` reaches `dialog` and `listbox`, and `listbox`
+reaches `option`.
+
+**This table is maintained by hand today and should not be.** The graph is
+already computed inside this repository, by the check that stops us shipping the
+same fault, and it is thrown away afterward rather than written to the manifest.
+Until it is published, treat the table above as the version that can go stale.
+
+## What you have to supply yourself
+
+**A `:not(:defined)` guard.** `@fusion.dev/helix` ships an `elements.css` that
+hides each of its tags until the definition lands, so a page does not show a run
+of unstyled text and then snap. The headless package ships no such file, and
+nothing can generate one for tags you have not named yet. Write the rule for
+your own elements:
+
+```css
+acme-combobox:not(:defined),
+acme-listbox:not(:defined) {
+  visibility: hidden;
+}
+```
+
+Visibility rather than `display`, so the page does not reflow when the
+definitions arrive.
+
+**Your own typings.** The generated `jsx.d.ts`, `vue.d.ts` and `svelte.d.ts`
+carry our tag names. For yours, merge each element into the tag map:
+
+```ts
+declare global {
+  interface HTMLElementTagNameMap {
+    'acme-combobox': AcmeCombobox
+  }
+}
+```
+
+Per element, by hand. There is no generated version of this for consumer names.
+
+## What you get without asking
+
+**Tree-shaking is honest.** `@fusion.dev/helix-headless` declares
+`sideEffects: ["./dist/**/*.js"]`, which is true rather than convenient: the
+modules register elements on import, so a bundler that believed otherwise would
+drop a registration and leave you debugging a tag that does not upgrade.
+
+**A styling surface that is documented.** Every part carries an `@csspart`, so
+`::part()` is a published door rather than a shadow tree you have to guess at.
+That is what makes replacing the presentation layer tractable: you are writing
+against named parts, not against our internals.
+
+**Composition stays ours.** Focus management, typeahead, the roving tab stop,
+form participation and validity all live below the tier you are replacing, so
+they keep working under your names.
+
+## What is not promised yet
+
+`tier` is an implementation detail that happens to be visible in the manifest.
+Using it the way this page describes turns it into API with a stability contract
+attached, and that contract is not written. Treat this as a supported pattern
+that is not yet a versioned promise, and pin your Helix version.
+
+## How this differs from white-labeling
+
+Two different customers get confused for each other here. This page is for the
+one building a design system on top of ours and content for our tags to sit
+beside theirs. The other wants Helix shipped under their name with ours absent,
+which is a different and more expensive mechanism: rewriting the tag literals at
+build time, a second distribution to publish, and an artifact per customer.
+Nothing on this page needs any of that.
+
+The sovereignty question answers itself in this direction. You hold the
+presentation layer, the tags and the build. If Fusion stopped tomorrow you would
+keep a working design system and lose upstream fixes to the behavior underneath
+it.

package/content/charting.mdx

@@ -0,0 +1,93 @@
+---
+description: The data channel nobody expects, and why it is a real table.
+section: Essentials
+title: Charting
+---
+
+# Charting
+
+Six chart families: `Bar Chart`, `Line Chart`, `Donut Chart`, `Sparkline`,
+`Trend` and the shared `Legend`. Each has its own API page. Here is how the data
+gets in, which is the same for all of them.
+
+## The data is a table in the document
+
+```html
+<table id="revenue">
+  <caption>Revenue by quarter</caption>
+  <thead>
+    <tr><th>Quarter</th><th>Direct</th><th>Partner</th></tr>
+  </thead>
+  <tbody>
+    <tr><th>Q1</th><td>120</td><td>80</td></tr>
+    <tr><th>Q2</th><td>150</td><td>95</td></tr>
+  </tbody>
+</table>
+
+<helix-bar-chart for="revenue"></helix-bar-chart>
+```
+
+`for` points at a real `<table>` by id, and the chart reads its series from it.
+That is unlike every other component in the library, and it is not a
+convenience.
+
+**A property cannot survive hydration.** A framework's server render emits
+markup, and a property is not markup: an array assigned to `items` exists only
+after JavaScript has run, so the server has nothing to send and the first paint
+has nothing to draw. Text in the document is the one channel that both a server
+and a client can see.
+
+**And the table is not a workaround, it is the accessible version.** A chart is
+a picture of numbers, and a screen reader cannot read a picture. The table is
+the numbers, in the document, navigable, and the chart is the drawing of them.
+Hide the table visually if it should not be seen, and the data is still there:
+
+```html
+<table
+  data-hidden-visually
+  id="revenue"
+>…</table>
+```
+
+The caption becomes the chart's accessible name unless you set `label`, which is
+usually the right words and is already written.
+
+## Series colours
+
+Twenty-four `--helix-color-series-*` tokens, in order. A chart with three series
+uses the first three. They are ordered to stay distinguishable in that order
+rather than to look good as a full set of twenty-four.
+
+The palette wraps, and where it wraps is one number in one place. It used to be
+four: four families held the same `const PALETTE = 24` and the legend held a
+fifth, so when the palette went from eight to twenty-four one of them was missed
+and drew every ninth series in the first color while the legend beside it named
+the ninth correctly. A number two files have to agree on is a number that will
+stop agreeing.
+
+**A chart's mark carries its own series color as a custom property**, because a
+chart knows which series a bar belongs to and CSS cannot count it. That is what
+lets you restyle a series from outside without knowing the drawing order.
+
+## Legends
+
+```html
+<helix-legend for="revenue"></helix-legend>
+<helix-bar-chart for="revenue"></helix-bar-chart>
+```
+
+The legend reads the same table, so the names and the colours cannot disagree
+with the chart's. Pointing them at two different tables is the only way to make
+them disagree, and it is not something to do by accident.
+
+## Reduced motion
+
+Charts animate on entry and on data change, and every one of them answers
+`prefers-reduced-motion`. See [Motion](./motion).
+
+## What these are not
+
+**Not a charting library.** There is no axis configuration language, no plugin
+system, and no chart type you build by composing scales. Six drawings that read
+a table, styled by the token system, with an accessible representation by
+construction. When you need a grammar of graphics, use one.

package/content/coding-agents.mdx

@@ -0,0 +1,139 @@
+---
+description: Every surface here is readable by a machine, and where each one is.
+order: 4
+section: Getting started
+title: Coding agents
+---
+
+# Coding agents
+
+An agent writing Helix code should not have to read a rendered website. Three
+surfaces give it the library as text, all generated from the sources this site
+renders from.
+
+## The manifest
+
+```
+https://fusion.dev/helix/custom-elements.json
+@fusion.dev/helix/custom-elements.json
+```
+
+A URL and a package path, the same file either way. **The URL exists because this
+page's own argument required it**: an agent that found the library through
+`llms.txt` has this site and no checkout, and a specifier is reachable from a
+`node_modules` and from nowhere else. It was only the specifier until 24 Aug 2026,
+and the specifier did not resolve either: `exports` carried a `./*` pattern
+pointing at `./dist/*/index.js`, so the path two pages recommended was one
+`require.resolve` refused.
+
+Every element, every property with its literal type union, every event with its
+class, every slot, every part, every custom property. It is what the framework
+typings, the reference documentation and the site's component pages are all
+generated from, so it cannot disagree with them.
+
+**A generated manifest is what makes hallucinating a component impossible to
+sustain.** The vocabulary is the file: a tag that is not in it does not exist,
+and a prop value outside a declared union is a value the component will reject.
+
+Literal unions rather than named types are enforced at analysis time for exactly
+this reason: `'ghost' | 'outlined' | 'solid' | 'subtle'` tells a reader what to
+write, where `ButtonEmphasis` tells them to go and look somewhere else.
+
+## Markdown for every family
+
+```
+/components/<family>.md
+/components/<family>.json
+```
+
+Static files. The `.md` carries the family's metadata, every element's
+description and API tables, and **the examples**, which the HTML page
+deliberately does not: that page answers what a component can do and the sandbox
+beside it answers what it looks like, and a reference that started collecting
+pictures would stop being the one place you can trust to be complete. An agent
+has no sandbox to be sent to, and to it an example is text rather than a
+picture.
+
+The `.json` is the same family as structured data.
+
+## What is enforced
+
+These are the difference between code that looks right and code that passes:
+
+| Rule | Check |
+|---|---|
+| A dispatched event must be declared | `check:events` |
+| A documented part must be rendered | `check:parts` |
+| A documented CSS hook must be read | `check:hooks` |
+| A visual property draws from its axis | `check:axes` |
+| A form control styles with `:disabled` | `check:disabled` |
+| A component that animates answers reduced motion | `check:motion` |
+| No component reads a primitive token | `check:tokens` |
+
+If you are generating Helix code, the first two are the ones that produce
+working-looking output that is wrong.
+
+## The index
+
+```
+/llms.txt
+```
+
+Every page on the site, grouped, each one linked at its `.md` and annotated with
+a sentence. Generated from the same route registry the sitemap comes from, so a
+page cannot exist without appearing here and cannot appear here without
+existing.
+
+Start there rather than crawling: one request, and it names every page on the
+site plus the two machine-readable surfaces above. No count here, because a
+number typed into prose is a number that goes stale, which the read of these pages
+on 24 Aug 2026 found five of.
+
+## From a component's page
+
+Every family page carries a menu beside its title with **View Markdown**, **Copy
+Markdown**, and links that hand the document's URL to Claude or to Cursor. The
+URL rather than the contents, because the URL stays current and a pasted copy
+starts going stale the moment it is pasted.
+
+## The one thing a document cannot answer
+
+```sh
+helix mcp
+```
+
+The three surfaces above are closed sets: every tag, every token, every example,
+all published and all fetchable. What none of them holds is what *your* brand
+color derives to, because the input is a color and the domain is infinite, so the
+answer has to be computed when it is asked.
+
+`helix mcp` serves that over stdio as an MCP server, with two tools:
+`helix_audit_theme`, which measures every foreground against the ground it is
+really painted on and reports each pair with its ratio and target, and
+`helix_derive_theme`, which returns the CSS. Both take the same JSON a
+`helix.theme.json` holds.
+
+**It refuses to hand back a palette that fails its own targets**, the way
+`helix theme build` does. Pasting one into a stylesheet is worse than reading a
+warning above it, and an agent does not read warnings.
+
+**You run it and nobody hosts it.** A server we operated would be a dependency
+you cannot exit, which the Sovereignty Constraint refuses; this is a subcommand
+of a binary you installed, talking to a client you chose, with no network in it.
+
+## What is not here
+
+**`llms-full.txt`, or any other whole-library download.** Concatenating every
+page into one file is out of date the moment anything changes, where the links
+in `llms.txt` are individually cacheable and individually current.
+
+This page used to offer one anyway, a repository path to a generated document
+holding every family at once, which contradicted the paragraph above it and was
+not a thing a consumer could open: an agent reading the published package has
+this site and no checkout. What it was for is covered better by the two surfaces
+already here. `llms.txt` is the index, one request, and each family's `.md` is
+the document. Fetch the families you are using.
+
+**A search index.** The site has one for humans; there is nothing an agent can
+query yet, and `llms.txt` plus the documents it names is a smaller thing to read
+than most search APIs are to learn.