@imfusion/web-ui 0.6.1-dev.1.g23386714 → 0.6.1-dev.14.g8fac1dfb

package/README.md

@@ -1,209 +1,160 @@
-# Web UI
+# @imfusion/web-ui
 
-`@imfusion/web-ui` — the official shared Web UI library for ImFusion web apps, built on Base UI.
+The shared React UI library for ImFusion web apps. It provides accessible primitives, ImFusion tokens, and one public import
+surface. Base UI supplies behavior for the primitives that need it; consumers do not depend on Base UI directly.
 
-- [Usage](#usage) — install, wire up, and keep the version current
-- [Documentation](#documentation) — Storybook and the developer docs
-- [Development](#development) — working on the library itself, including the Agent Skills
-- [Releasing](#releasing) — how versions are derived and how to cut one
+- [Use the library](#use-the-library)
+- [Read the docs](#read-the-docs)
+- [Work on the library](#work-on-the-library)
+- [Release it](#release-it)
 
-## Usage
+## Use the library
 
-The packages are private on npmjs.com.
+The package is private. Get the Web SDK npm token from the
+[Test Licenses page](https://imfusion.atlassian.net/wiki/spaces/DEV/pages/255590402/Test+Licenses), then save it in your
+user-level npm config:
 
-To install them, get the Web SDK npm token from the
-[Test Licenses](https://imfusion.atlassian.net/wiki/spaces/DEV/pages/255590402/Test+Licenses) page on Confluence and add it
-to your user-level `.npmrc`:
-
-```bash
+```sh
 npm config set //registry.npmjs.org/:_authToken=<token> --location=user
 ```
 
-Then:
+Install the latest release:
 
-```bash
+```sh
 npm install @imfusion/web-ui
 ```
 
-Or if you want to install the latest CI build from master:
+To follow builds from `master`, use the `dev` dist-tag:
 
-```bash
+```sh
 npm install @imfusion/web-ui@dev
 ```
 
-Import the stylesheet and wrap your app root once:
+Import the stylesheet and mount the provider once at your app root:
 
 ```tsx
 import "@imfusion/web-ui/styles.css";
 import { WebUIProvider } from "@imfusion/web-ui";
-```
 
-### LLM integration
+export function App() {
+  return <WebUIProvider>{/* app */}</WebUIProvider>;
+}
+```
 
-The `web-ui` package does offer first-class support for LLMs, but it's not wired up by default.
+### Agent skills
 
-To install the skills, run this command after the package is installed:
+The package can install optional skills for agents working in a consumer project:
 
-```bash
+```sh
 npx web-ui-install
 ```
 
-The binary asks which LLM client you use and installs everything it needs. Run it again after a version bump and it refreshes
-the directories it already installed into, without asking again — `--reconfigure` re-opens that choice.
-
-The optional `--hooks` flag also installs the agent lifecycle hooks and registers them for both hosts, in
-`.claude/settings.json` (Claude Code) and `.codex/hooks.json` (Codex). Three hooks inject one fixed line each: `SessionStart`
-and `SubagentStart` point the agent at the `imf-web-ui` skills router, and `UserPromptSubmit` names the companion skills to
-consult per task. A fourth, the `Stop` gate, blocks a turn that edited source files once, until the agent has addressed the
-project's verification. Re-running the installer refreshes the scripts and prunes retired ones along with their
-registrations. Without `--hooks`, the skills are still available but no lifecycle hook runs. The full flow is documented in
-the shipped [`agent-tooling` topic](./src/llms/skills/imf-web-ui-conventions/topics/agent-tooling.md) of the conventions
-skill.
-
-**Available consumer skills - `/imf-web-ui-*`**
-
-| Skill                     | What it does                                                                   |
-| ------------------------- | ------------------------------------------------------------------------------ |
-| `/imf-web-ui`             | The router: decides whether guidance is needed, then which companion to open.  |
-| `/imf-web-ui-setup`       | Plan and, after approval, bootstrap a consumer project by topic.               |
-| `/imf-web-ui-components`  | Component and icon reference — what exists and how it's meant to be used.      |
-| `/imf-web-ui-ux`          | UX guidance for building interfaces with the library.                          |
-| `/imf-web-ui-conventions` | The frontend conventions baseline, including the sanctioned styling seams.     |
-| `/imf-web-ui-audit`       | Read-only health check for a consumer project, ending in a plan you approve.   |
-| `/imf-web-ui-update`      | Update the library, skills, and optional hooks, then verify before committing. |
-
-Start at `/imf-web-ui` — it routes to the rest. Storybook's **User Guide → AI Agents** page covers the whole family.
-
-### Versions and updates
-
-Every merge to master publishes a new build under the `dev` dist-tag. Which spec you install decides how you pick those up:
-
-| Spec in `package.json`             | Gets                       | Update with                    |
-| ---------------------------------- | -------------------------- | ------------------------------ |
-| `"@imfusion/web-ui": "^0.5.0"`     | matching releases          | `npm update @imfusion/web-ui`  |
-| `"@imfusion/web-ui": "latest"`     | the newest release         | `npm update @imfusion/web-ui`  |
-| `"@imfusion/web-ui": "dev"`        | the newest build of master | `npm update @imfusion/web-ui`  |
-| `"@imfusion/web-ui": "file:….tgz"` | a packed tarball, frozen   | re-pack and re-install by hand |
-
-- **Two dist-tags.** `latest` moves when a release is tagged, `dev` on every build of master (and onto the release when one
-  is cut).
-- **A range like `^0.5.0` is the usual choice.** It tracks releases and states which major you expect; bare `latest` follows
-  releases across majors, breaking changes included.
-- **Dist-tag specs stay literal.** npm keeps `dev` or `latest` as-is in `package.json` and re-resolves on every `npm update`.
-  The concrete version lands in `package-lock.json`, so builds stay reproducible until you update.
-- **Track `dev` while building against the library**, to get new components as they land. Use a release spec for anything you
-  cut a production release from, since `dev` moves whenever someone merges.
-- **A `file:` tarball never updates.** npm copies the archive into `node_modules` and re-copies the same one on every
-  install. Switch to `dev` or a version range to get updates.
-
-## Documentation
-
-**[Storybook](https://storybook.js.org/)** is the documentation platform — the component catalog, every prop, and the setup
-guides. It isn't hosted yet, so run it locally:
-
-```bash
-npm run dev   # builds the library, then Storybook + a rebuild watcher
-```
+Run the command again after updating the package. It refreshes the skills already installed in the project. Use
+`--reconfigure` to choose a different target. Add `--hooks` to install the lifecycle hooks for Claude Code and Codex.
 
-See the [Developer Docs](./docs/README.md).
+Start with `/imf-web-ui`. It routes a task to the companion skills it needs, or tells the agent to work without extra
+guidance.
 
-## Development
+| Skill                     | Use it for                                                   |
+| ------------------------- | ------------------------------------------------------------ |
+| `/imf-web-ui`             | Route UI work to the right companion.                        |
+| `/imf-web-ui-setup`       | Plan library wiring, project setup, or tooling changes.      |
+| `/imf-web-ui-components`  | Look up component and icon APIs.                             |
+| `/imf-web-ui-ux`          | Choose components and shape screens and flows.               |
+| `/imf-web-ui-conventions` | Follow the frontend conventions and token seams.             |
+| `/imf-web-ui-audit`       | Inspect an existing frontend without changing it.            |
+| `/imf-web-ui-update`      | Update the package, skills, and hooks in a consumer project. |
 
-Install the deps and configure git:
+The shipped [`agent-tooling` topic](./src/llms/skills/imf-web-ui-conventions/topics/agent-tooling.md) explains the hook
+installation and Codex trust step.
 
-```bash
-npm install
-npm run git:config   # hooks path + rebase-only pull/merge
-```
+### Versions
 
-**Try out **`/web-ui-dev-getting-started`** for an ai assisted start.**
+Use a release version or range for production and `dev` while building against the library:
 
-### LLM integration
+| Dependency spec | Resolves to                      | Update with                   |
+| --------------- | -------------------------------- | ----------------------------- |
+| `^0.6.0`        | compatible releases              | `npm update @imfusion/web-ui` |
+| `latest`        | newest release                   | `npm update @imfusion/web-ui` |
+| `dev`           | newest build of `master`         | `npm update @imfusion/web-ui` |
+| `file:…tgz`     | the packed archive you installed | pack and install again        |
 
-Web UI development skills use a `/web-ui-dev-*` prefix. `documentation-writer` comes from `npx skills`; it is not a native
-Web UI skill.
+`latest` and `dev` are dist-tags. npm records the resolved version in `package-lock.json`; the tag stays in `package.json`
+until you update it. A bare `latest` can cross major versions, while a range keeps the expected major. A file tarball is a
+copy, so it never updates by itself.
 
-| Skill                                     | What it does                                                                                                            |
-| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| `/documentation-writer`                   | External `npx skills` workflow for Diátaxis documentation.                                                              |
-| `/web-ui-dev-getting-started`             | Interactive intro — gauges your experience, works out your goal, routes you.                                            |
-| `/web-ui-dev-start`                       | Starting ritual for any task: Jira context, `master` vs. a worktree, context summary.                                   |
-| `/web-ui-dev-new-component`               | Scaffolds an architecture-compliant primitive (adapted or absorbed).                                                    |
-| `/web-ui-dev-update-component`            | Pointers to every file a prop, variant, or sub-component change touches.                                                |
-| `/web-ui-dev-design-component`            | Brand design pass for a component that works but isn't styled yet.                                                      |
-| `/web-ui-dev-story`                       | Author or update a Storybook story.                                                                                     |
-| `/web-ui-dev-commit`                      | Commit workflow: changelog skill, staged docs audit, CI-parity checks, house commit format.                             |
-| `/web-ui-dev-release`                     | Prepare release notes, commit them, and ship the approved release.                                                      |
-| `/web-ui-dev-changelog`                   | Generate and validate the required one-line CHANGELOG.md entry for a web-ui change, including direct commits to master. |
-| `/web-ui-dev-audit-docs`                  | Audit docs against staged or recent changes for staleness, gaps, and drift.                                             |
-| `/web-ui-dev-audit-pass-through-defaults` | Check `@default` annotations on pass-through props against Base UI upstream.                                            |
-| `/web-ui-dev-teardown-worktree`           | Tear down a worktree, wherever it lives — merging its branch first or dropping it.                                      |
-| `/web-ui-dev-refresh-design-reference`    | Refresh the committed brand snapshots in `design/` from the Figma styleguide.                                           |
-| `/web-ui-dev-mcp`                         | Set up or recover Storybook, DevTools, Atlassian, or Figma MCP access.                                                  |
+## Read the docs
 
-## Releasing
+[Storybook](https://storybook.js.org/) is the public documentation site. It contains the setup guide, usage patterns, token
+reference, and component examples. It is not hosted yet; run it locally from this repository:
+
+```sh
+npm run dev
+```
 
-Release-facing changes are recorded as one-line entries in [`CHANGELOG.md`](./CHANGELOG.md) under `## [Unreleased]`. The
-commit workflow requires an entry for pull-request commits and direct commits to `master`, with only narrow mechanical
-exceptions. Each entry ends with its author as ` — Name <email>`, taken from the committer's git config.
+The source for the contributor docs is [`docs/README.md`](./docs/README.md). Start there if you are changing the library.
 
-The published version is derived from git tags, not from `package.json`.
+## Work on the library
 
-The `version` field stays at `0.0.0` in the repository and he CI computes the real number with
-[`scripts/version.ts`](./scripts/version.ts) and writes it into `package.json` on the build agent just before publishing.
+```sh
+npm install
+npm run git:config
+```
 
-That working copy is thrown away, so nothing is committed back.
+`git:config` sets the tracked hooks path, enables rebase pulls, and requires fast-forward merges. The
+[`web-ui-dev-getting-started`](./.agents/skills/web-ui-dev-getting-started/SKILL.md) skill can route a first task.
 
-`scripts/version.ts` reads `git describe` and applies two rules:
+The main development skills are:
 
-Given the tag `web-ui/v0.5.0`:
+| Skill                                     | Use it for                                       |
+| ----------------------------------------- | ------------------------------------------------ |
+| `/web-ui-dev-getting-started`             | Route a first task based on experience and goal. |
+| `/web-ui-dev-start`                       | Establish task context and working location.     |
+| `/web-ui-dev-new-component`               | Add a primitive.                                 |
+| `/web-ui-dev-update-component`            | Change an existing primitive.                    |
+| `/web-ui-dev-design-component`            | Apply the ImFusion brand to a component.         |
+| `/web-ui-dev-story`                       | Author a Storybook story.                        |
+| `/web-ui-dev-commit`                      | Verify and commit a change.                      |
+| `/web-ui-dev-release`                     | Prepare and ship a release.                      |
+| `/web-ui-dev-audit-docs`                  | Check docs for drift before a commit.            |
+| `/web-ui-dev-audit-pass-through-defaults` | Check adapted prop defaults against Base UI.     |
+| `/web-ui-dev-refresh-design-reference`    | Refresh the committed brand snapshots.           |
+| `/web-ui-dev-teardown-worktree`           | Remove a finished worktree.                      |
+| `/web-ui-dev-mcp`                         | Recover one optional MCP capability.             |
 
-| Where HEAD sits            | Published version       | dist-tag |
-| -------------------------- | ----------------------- | -------- |
-| Exactly on `web-ui/v0.5.0` | `0.5.0`                 | `latest` |
-| 5 commits after that tag   | `0.5.1-dev.5.gb4de52d7` | `dev`    |
+## Release it
 
-The off-tag string breaks down as:
+The published version comes from git tags. The repository keeps `package.json` at `0.0.0`; CI writes the real version into
+the build copy.
 
-```
-0.5.1-dev.5.gb4de52d7
-└─┬─┘ └┬┘ │ └───┬────┘
-  │    │  │     └── commit hash, abbreviated; the leading g means "git"
-  │    │  └──────── commits since the tag
-  │    └─────────── pre-release marker, which is what puts it on the dev tag
-  └──────────────── the tag's version, patch bumped
-```
+For a tag such as `web-ui/v0.6.0`:
 
-Bumping the patch is what makes a dev build sort above the release it follows and below the next one.
+| HEAD is               | Published version     | Tag      |
+| --------------------- | --------------------- | -------- |
+| `web-ui/v0.6.0`       | `0.6.0`               | `latest` |
+| five commits after it | `0.6.1-dev.5.g<hash>` | `dev`    |
 
-Every build of `master` publishes a `dev` version automatically. To check what the current checkout would publish:
+Check the version for the current checkout without changing files:
 
-```bash
-npx tsx scripts/version.ts        # prints, changes nothing
+```sh
+npx tsx scripts/version.ts
 ```
 
-### Cutting a release
+Use `/web-ui-dev-release <version>` to prepare release notes and get the release commit approved. The final command is:
 
-The release skill prepares the dated release section from detailed Unreleased entries and commits it through the normal
-approval gate. Then ship that prepared commit:
-
-```bash
+```sh
 npm run release
 ```
 
-The command reads the prepared version from `CHANGELOG.md`, requires a clean working tree, runs full verification, creates
-`web-ui/v0.5.1`, and pushes the tag. TeamCity builds that tag, publishes `0.5.1` as `latest`, and points `dev` at the same
-version.
-
-The tag name must match `web-ui/vX.Y.Z` exactly. Both the version script's `--match` and the TeamCity branch filter in
-[`.teamcity/settings.kts`](./.teamcity/settings.kts) key off that shape; a tag in any other form publishes nothing.
+It requires a clean tree, runs the full verification, creates `web-ui/v<version>`, and pushes the tag. TeamCity builds that
+tag and publishes npm. The tag must match that shape exactly.
 
-### Building locally with a real version
+To build a local tarball with a real version:
 
-A local `npm run build` stamps `dist` with `0.0.0`. When you need the true version in a local artifact:
-
-```bash
-npx tsx scripts/version.ts --write   # writes it into package.json
+```sh
+npx tsx scripts/version.ts --write
 npm run build
-git checkout package.json            # discard the write
+git checkout package.json
 ```
+
+The release skill covers the optional TeamCity CLI checks and the publication verification.

package/dist/{code-Blo48PGr.js → code-C_56u-Vk.js}

@@ -1,6 +1,6 @@
 import { t as e } from "./chunk-DmhlhrBa.js";
 import { t } from "./meta-CySnRuVp.js";
-import { Ma as n, Qt as r, Xo as i, hn as a, r as o } from "./icons-wBmF0U2x.js";
+import { Ma as n, Qt as r, Xo as i, hn as a, r as o } from "./icons-Cy1HAosO.js";
 import { cx as s } from "class-variance-authority";
 import { jsx as c, jsxs as l } from "react/jsx-runtime";
 import { useCallback as u, useEffect as d, useRef as f, useState as p } from "react";
@@ -129,7 +129,7 @@ var b = {
 	category: t.display,
 	status: "stable",
 	namespace: !0,
-	description: "Displays source code — Code.Inline for a fragment in running text, Code.Block for a fenced block with an optional language label and copy button. Also called a code snippet or code block.",
+	description: "Displays source code inline or in a block, with optional language labels and copying. Also called a code snippet or code block.",
 	origin: "native"
 };
 //#endregion

package/dist/components/toast/index.d.ts

@@ -0,0 +1,2 @@
+export * as Toast from './toast';
+export { toastMeta } from './toast.meta';

package/dist/components/toast/toast.d.ts

@@ -0,0 +1,197 @@
+import { Toast as ToastPrimitive } from '@base-ui/react/toast';
+import { VariantProps } from 'class-variance-authority';
+type UpstreamProvider = React.ComponentProps<typeof ToastPrimitive.Provider>;
+type UpstreamPortal = React.ComponentProps<typeof ToastPrimitive.Portal>;
+type UpstreamViewport = React.ComponentProps<typeof ToastPrimitive.Viewport>;
+type UpstreamRoot = React.ComponentProps<typeof ToastPrimitive.Root>;
+type UpstreamContent = React.ComponentProps<typeof ToastPrimitive.Content>;
+type UpstreamTitle = React.ComponentProps<typeof ToastPrimitive.Title>;
+type UpstreamDescription = React.ComponentProps<typeof ToastPrimitive.Description>;
+type UpstreamClose = React.ComponentProps<typeof ToastPrimitive.Close>;
+type UpstreamAction = React.ComponentProps<typeof ToastPrimitive.Action>;
+type UpstreamPositioner = React.ComponentProps<typeof ToastPrimitive.Positioner>;
+type UpstreamArrow = React.ComponentProps<typeof ToastPrimitive.Arrow>;
+declare const toastViewport: (props?: ({
+    position?: "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const toastRoot: (props?: ({
+    variant?: "warning" | "info" | "neutral" | "success" | "error" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+/**
+ * Toast.useToastManager — reads the queue and the add/close/update/promise
+ * methods from the surrounding provider. Must run inside a provider; the one
+ * `WebUIProvider` mounts satisfies that for the standard setup.
+ */
+export declare const useToastManager: typeof ToastPrimitive.useToastManager;
+/**
+ * Toast.createToastManager — creates a manager that lives outside React so
+ * non-component code can add toasts. Pass it to a `Toast.Provider` via
+ * `toastManager`.
+ */
+export declare const createToastManager: typeof ToastPrimitive.createToastManager;
+type ProviderProps = {
+    timeout?: UpstreamProvider["timeout"];
+    limit?: UpstreamProvider["limit"];
+    toastManager?: UpstreamProvider["toastManager"];
+    children?: UpstreamProvider["children"];
+};
+/**
+ * Toast.Provider — owns the toast queue for its subtree. Renders no DOM element.
+ *
+ * `WebUIProvider` already mounts one, so most applications never write this
+ * part. Use it for a scoped queue or to attach an external manager.
+ *
+ * @see https://base-ui.com/react/components/toast
+ * @llm https://base-ui.com/react/components/toast.md
+ */
+export declare function Provider({ timeout, limit, ...props }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Provider {
+    var displayName: string;
+}
+type PortalProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    container?: UpstreamPortal["container"];
+    className?: UpstreamPortal["className"];
+    render?: UpstreamPortal["render"];
+    children?: UpstreamPortal["children"];
+};
+/** Toast.Portal — moves the viewport out of the page flow so toasts float above the app. */
+export declare function Portal({ className, ...props }: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Portal {
+    var displayName: string;
+}
+type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** Which edge or corner of the screen the stack anchors to. */
+    position?: VariantProps<typeof toastViewport>["position"];
+    className?: UpstreamViewport["className"];
+    render?: UpstreamViewport["render"];
+};
+/**
+ * Toast.Viewport — the fixed layer that holds the stack. Hovering or focusing it
+ * expands the collapsed toasts; it ignores pointer events except on the toasts
+ * themselves so the app underneath stays clickable.
+ */
+export declare function Viewport({ className, position, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Viewport {
+    var displayName: string;
+}
+type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** Semantic treatment for the toast surface. */
+    variant?: VariantProps<typeof toastRoot>["variant"];
+    /** The toast object from the manager's `toasts` array. */
+    toast: UpstreamRoot["toast"];
+    /** @default ['down', 'right'] */
+    swipeDirection?: UpstreamRoot["swipeDirection"];
+    className?: UpstreamRoot["className"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * Toast.Root — one toast surface. Carries the upstream state as data attributes
+ * (`data-starting-style`, `data-ending-style`, `data-expanded`, `data-limited`,
+ * `data-swiping`) which the stylesheet uses for stack and exit motion.
+ */
+export declare function Root({ className, variant, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type ContentProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamContent["className"];
+    render?: UpstreamContent["render"];
+};
+/**
+ * Toast.Content — lays out title, description, action, and close. Fades out on
+ * the toasts stacked behind the frontmost one via `data-behind`.
+ */
+export declare function Content({ className, ...props }: ContentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Content {
+    var displayName: string;
+}
+type TitleProps = Omit<React.HTMLAttributes<HTMLHeadingElement>, "className"> & {
+    className?: UpstreamTitle["className"];
+    render?: UpstreamTitle["render"];
+};
+/** Toast.Title — the message heading. Falls back to the toast object's `title` when given no children. */
+export declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Title {
+    var displayName: string;
+}
+type DescriptionProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className"> & {
+    className?: UpstreamDescription["className"];
+    render?: UpstreamDescription["render"];
+};
+/** Toast.Description — supporting copy. Falls back to the toast object's `description` when given no children. */
+export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Description {
+    var displayName: string;
+}
+type CloseProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /** @default true */
+    nativeButton?: UpstreamClose["nativeButton"];
+    className?: UpstreamClose["className"];
+    render?: UpstreamClose["render"];
+};
+/** Toast.Close — dismisses the toast it sits in. */
+export declare function Close({ className, ...props }: CloseProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Close {
+    var displayName: string;
+}
+type ActionProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /** @default true */
+    nativeButton?: UpstreamAction["nativeButton"];
+    className?: UpstreamAction["className"];
+    render?: UpstreamAction["render"];
+};
+/**
+ * Toast.Action — the toast's single affordance, typically an undo. Its behavior
+ * comes from `actionProps` on the toast object passed to the manager.
+ */
+export declare function Action({ className, ...props }: ActionProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Action {
+    var displayName: string;
+}
+type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** The toast object from the manager's `toasts` array. */
+    toast: UpstreamPositioner["toast"];
+    /** @default 'top' */
+    side?: UpstreamPositioner["side"];
+    /** @default 'center' */
+    align?: UpstreamPositioner["align"];
+    /** @default 0 */
+    sideOffset?: UpstreamPositioner["sideOffset"];
+    /** @default 0 */
+    alignOffset?: UpstreamPositioner["alignOffset"];
+    /** @default 5 */
+    arrowPadding?: UpstreamPositioner["arrowPadding"];
+    anchor?: UpstreamPositioner["anchor"];
+    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
+    /** @default 'clipping-ancestors' */
+    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
+    /** @default 5 */
+    collisionPadding?: UpstreamPositioner["collisionPadding"];
+    /** @default 'absolute' */
+    positionMethod?: UpstreamPositioner["positionMethod"];
+    /** @default false */
+    sticky?: UpstreamPositioner["sticky"];
+    /** @default false */
+    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
+    className?: UpstreamPositioner["className"];
+    render?: UpstreamPositioner["render"];
+};
+/**
+ * Toast.Positioner — anchors a toast to an element instead of the stack, for
+ * feedback that belongs next to the control that caused it. Wrap a `Root` in it
+ * and the root switches to the compact content-sized surface.
+ */
+export declare function Positioner({ className, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Positioner {
+    var displayName: string;
+}
+type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamArrow["className"];
+    render?: UpstreamArrow["render"];
+};
+/** Toast.Arrow — pointer joining an anchored toast to its anchor. Receives `data-side` for orientation. */
+export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Arrow {
+    var displayName: string;
+}
+export {};

package/dist/components/toast/toast.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const toastMeta: ComponentMeta;

package/dist/icons/icon-config.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode, SVGProps } from 'react';
+type IconConfig = Omit<SVGProps<SVGSVGElement>, "children" | "ref">;
+interface ProviderProps {
+    children: ReactNode;
+    value?: IconConfig;
+}
+/** IconConfig.Provider — sets SVG defaults (color, size, stroke width) for icons in its subtree. Providers shallow-merge with the closest parent's config. */
+export declare function Provider({ children, value }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Provider {
+    var displayName: string;
+}
+export {};

package/dist/{icons-wBmF0U2x.js → icons-Cy1HAosO.js}

@@ -71,7 +71,7 @@ var a5 = {
 	name: "Icon",
 	category: e.display,
 	status: "stable",
-	description: "Semantic color wrapper for an icon imported from the Web UI icons entry. Use it when an icon needs a named foreground role instead of the inherited currentColor.",
+	description: "Renders a Web UI icon with an optional semantic foreground color. The default inherits the surrounding currentColor.",
 	origin: "native"
 };
 //#endregion