bitboss-ui 3.0.0-beta.61 → 3.0.0-beta.63

package/bin/bitboss-ui-mcp.mjs

@@ -1923,9 +1923,17 @@ let cachedDocIndex = null;
 function docIndex() {
 	if (cachedDocIndex) return cachedDocIndex;
 	const entries = [];
-	const addSections = (source, markdown, read) => {
+	// What a document says before its first `##` (its lead), and then every
+	// section. The lead used to be skipped, and a composable was cut at 4000
+	// chars: useToast's object-form row sat past the cut (2026-10-20).
+	// `check-mcp` walks dist/ai and fails on any doc unit left out of here.
+	const addSections = (source, markdown, read, lead, skip = () => false) => {
+		const intro = stripFrontmatter(markdown).split(/^## /m)[0].trim();
+		if (lead && intro.length >= 40)
+			entries.push({ source, ...lead, text: intro });
 		for (const section of splitSections(markdown)) {
-			if (section.own.length < 40) continue;
+			// `skip` first: it tracks the `##` it is under, even a bare one.
+			if (skip(section) || section.own.length < 40) continue;
 			entries.push({
 				source,
 				section: section.title,
@@ -1936,13 +1944,18 @@ function docIndex() {
 	};
 	const guidesDir = join(AI_ROOT, 'guides');
 	for (const path of collectGuidePaths(guidesDir)) {
+		const markdown = readFileSync(join(guidesDir, path), 'utf-8');
 		addSections(
 			`guide ${path}`,
-			readFileSync(join(guidesDir, path), 'utf-8'),
+			markdown,
 			(title) => ({
 				tool: 'get_guide',
 				args: { name: path, sections: [title] },
-			})
+			}),
+			{
+				section: frontmatter(markdown).title ?? path,
+				read: { tool: 'get_guide', args: { name: path } },
+			}
 		);
 	}
 	const composablesDir = join(AI_ROOT, 'composables');
@@ -1952,16 +1965,22 @@ function docIndex() {
 		)) {
 			const markdown = readFileSync(join(composablesDir, file), 'utf-8');
 			const name = file.slice(0, -3);
-			entries.push({
-				source: `composable ${name}`,
-				section: frontmatter(markdown).summary ?? name,
-				text: stripFrontmatter(markdown).slice(0, 4000),
-				read: { tool: 'get_composable', args: { name } },
-			});
+			addSections(
+				`composable ${name}`,
+				markdown,
+				(title) => ({
+					tool: 'get_composable',
+					args: { name, sections: [title] },
+				}),
+				{
+					section: frontmatter(markdown).summary ?? name,
+					read: { tool: 'get_composable', args: { name } },
+				}
+			);
 		}
 	}
 	const manifest = loadComponentsManifest();
-	for (const component of manifest.components.filter((c) => !c.referenceOnly)) {
+	for (const component of manifest.components) {
 		const path = join(PACKAGE_ROOT, 'dist', component.contract ?? '');
 		if (component.contract && existsSync(path)) {
 			for (const section of contractGuideSections(
@@ -1979,6 +1998,11 @@ function docIndex() {
 				});
 			}
 		}
+		// BbToast and BbConfirm are reference-only (a composable drives them)
+		// but their guides are the docs: § Variant icons never ranked
+		// (progetto-32, 2026-10-20). Internals have no guide, so nothing else
+		// comes in; their props stay out.
+		if (component.referenceOnly) continue;
 		for (const prop of component.props) {
 			if (prop.name.startsWith('pt')) continue;
 			entries.push({
@@ -2003,6 +2027,45 @@ function docIndex() {
 				},
 			});
 		}
+		// Slots, v-models and pt parts / states: `members` serves each row, and
+		// "BbSelect option slot" had nothing to find.
+		const member = (section, text, name) =>
+			entries.push({
+				source: `component ${component.name}`,
+				section,
+				text,
+				read: {
+					tool: 'get_component',
+					args: { name: component.name, members: [name] },
+				},
+			});
+		for (const slot of component.slots ?? [])
+			member(
+				`slot #${slot.name}`,
+				`#${slot.name} slot. ${slot.description ?? ''}`,
+				`#${slot.name}`
+			);
+		for (const model of component.models ?? []) {
+			const name =
+				model.name === 'modelValue' ? 'v-model' : `v-model:${model.name}`;
+			member(
+				name,
+				`${name}: ${model.type ?? ''}. ${model.description ?? ''}`,
+				name
+			);
+		}
+		for (const part of component.pt?.parts ?? [])
+			member(
+				`pt part ${part.name}`,
+				`pt:${part.name} part. ${part.description ?? ''}`,
+				`pt:${part.name}`
+			);
+		for (const state of component.pt?.states ?? [])
+			member(
+				`pt state ${state.name}`,
+				`pt state ${state.name}. ${state.description ?? ''}`,
+				`pt:${state.name}`
+			);
 		/*
 		 * The rename registry: an agent upgrading an app searches the OLD name
 		 * (`enabled-while-loading`, `pt:input`, `#no-data`), which no current
@@ -2053,6 +2116,22 @@ function docIndex() {
 				text: frontmatter(markdown).summary ?? name,
 				read: { tool: 'get_recipe', args: { platform, name } },
 			});
+			// The prose sections; the code files under "The code" are `files`.
+			let inCode = false;
+			addSections(
+				`recipe ${platform}/${name}`,
+				markdown,
+				(title) => ({
+					tool: 'get_recipe',
+					args: { platform, name, sections: [title] },
+				}),
+				null,
+				(section) => {
+					if (section.level === 2)
+						inCode = /^the (code|files)\b/i.test(section.title);
+					return inCode;
+				}
+			);
 		}
 	}
 	// Class renames (the sweep map rows of changelog.json): an app's
@@ -2151,10 +2230,18 @@ function docIndex() {
 	if (existsSync(readme)) {
 		// Served by get_guide under the name 'README' (it used to point at a
 		// "read file" call, which is not a tool).
-		addSections('README', readFileSync(readme, 'utf-8'), (title) => ({
-			tool: 'get_guide',
-			args: { name: 'README', sections: [title] },
-		}));
+		addSections(
+			'README',
+			readFileSync(readme, 'utf-8'),
+			(title) => ({
+				tool: 'get_guide',
+				args: { name: 'README', sections: [title] },
+			}),
+			{
+				section: 'README',
+				read: { tool: 'get_guide', args: { name: 'README' } },
+			}
+		);
 	}
 	cachedDocIndex = entries;
 	return entries;
@@ -3341,6 +3428,7 @@ export {
 	SERVER_INSTRUCTIONS,
 	searchComponents,
 	searchDocs,
+	docIndex,
 	getComposable,
 	getComponent,
 	listTokens,

package/bin/bitboss-ui.mjs

@@ -1735,7 +1735,9 @@ Commands:
                       \`warnings[]\` (never fail the run) use the same shape with
                       \`severity: "warning"\`: \`likely-squashed-slot\` (a slot
                       name that looks like a camelCase key squashed, e.g.
-                      \`#createdat\`), \`local-bb-component\` (your own
+                      \`#createdat\`), \`computed-slot-key\` (a computed slot
+                      name over keys \`check\` cannot see, not spelled
+                      through \`slotKey(…)\`), \`local-bb-component\` (your own
                       component uses the \`Bb\` prefix; rename it),
                       \`single-reason\` (an \`items\` provider that tests
                       \`reason\` against one cause other than \`'search'\`;

package/dist/ai/BbAlert.md

@@ -107,6 +107,9 @@ distinct success tone.
 
 #### Variant icons
 
+A default icon per variant, set once for the whole app: the object form of
+the plugin's `alertVariants` option.
+
 ```ts
 // vite.config.ts (Nuxt: the `bitboss` key)
 bitbossUi({

package/dist/ai/BbConfirm.md

@@ -72,23 +72,21 @@ first — this is that gate.
 Mount `<BbHost />` **exactly once, at the app root** (`App.vue` under Vue,
 `app.vue` under Nuxt, the `createInertiaApp` render root under Inertia) — a
 single instance serves the whole app, and `confirm()` can then be called from
-anywhere, components and stores alike. **Calls do not queue — a new
-`confirm()` supersedes the open one**, and the superseded promise settles
-`false` (an implicit dismiss; no callback runs). So two `confirm()` calls in a
-row show only the second, and the first silently answers "no". If you need both
-questions asked, `await` the first before opening the second.
+anywhere, components and stores alike. **Every call opens its own dialog**,
+and a new one covers the open one, which stays pending and comes back when
+the newer one closes (see [Several confirms at once](#several-confirms-at-once)).
 A second host renders nothing (a dev-mode console warning says so). With no
 host, `await confirm(...)` resolves `false` after one second, with a dev
 warning. A host that unmounts while its dialog is open (a layout the user
 navigated out of) gets the same second to come back; after that the open
 confirm resolves `false` without running a callback, so it never hangs.
 
-**Areas with their own look.** The dialog takes the passthrough scope and the
-tokens of the place its HOST is mounted. When the app is split into areas that
-each wrap their pages in `<BbPtScope>` ([passthrough guide](./guides/passthrough.md) § Named scopes),
-mount one `<BbHost />` inside each area's layout, within its scope, and none
-at the app root — which holds only if **every** page renders inside exactly one
-of those layouts, so there is still one host at a time.
+**Areas with their own look.** A confirm takes the passthrough scope and the
+tokens of the component that called `useConfirm()`, wherever the host is
+mounted: a page inside a `<BbPtScope>` ([passthrough guide](./guides/passthrough.md) § Named scopes)
+gets confirms in its area's look with nothing to set up. A component portal
+injects from that component's tree too. A `useConfirm()` called outside a
+component (a store, module level) takes the host's.
 
 ```vue
 <template>
@@ -105,10 +103,9 @@ import { BbHost } from 'bitboss-ui';
 standalone example has no app root to mount it in.** In a real app the host is
 already mounted at the root; a page that calls `confirm()` mounts nothing.
 
-The component itself takes almost no props: everything — content, buttons,
-behavior — travels in the message you pass to `confirm()`. The one exception is
-`size`, a host-wide default width every confirm inherits unless its message
-sets its own (see [Size, fullscreen and focus](#size-fullscreen-and-focus)).
+Everything — content, buttons, behavior — travels in the message you pass to
+`confirm()`; the width every confirm defaults to is the plugin's
+`confirm.defaultSize` (see [Size, fullscreen and focus](#size-fullscreen-and-focus)).
 At least one of `title`, `text`, `portal` should be set (dev warning
 otherwise).
 
@@ -402,7 +399,7 @@ the promise `false`, so your `if (ok)` branch is never reached accidentally.
 decline-only behavior in `no.onClick`, not in the `if (!ok)` branch. The rule
 that decides whether `no.onClick` runs: **user-initiated** dismissals
 (backdrop, `Escape`, the X) honor `dismissAsNo`; **system-initiated** ones
-(`duration` timeout, owner unmount, a superseding `confirm()`, `dismissAll()`)
+(`duration` timeout, owner unmount, `dismissAll()`)
 always resolve quietly, never running any callback. The knobs:
 
 - `dismissAsNo` (default `true`) — user-initiated implicit dismissals also run
@@ -435,7 +432,7 @@ the peek closes. For app-lifetime confirms that survive any unmount, call
 `useConfirm()` outside a component scope (app setup, a store, module level).
 
 `useConfirm()` also returns `dismissAll()` — an imperative escape hatch that
-quietly dismisses the open dialog regardless of owner, for
+quietly dismisses every open confirm regardless of owner, for
 app-level events like logout or a global error boundary.
 
 The classic case for `persistent` is the unsaved-changes prompt: an accidental
@@ -511,6 +508,8 @@ By default the dialog closes as soon as the promise settles. Set
 - `close()` only hides the dialog; **it never resolves anything**. Calling it
   on a dialog whose buttons haven't run yet leaves that `confirm()` promise
   pending forever — it is a flow terminator, not a substitute for the buttons.
+- `close()` hides the newest open confirm opened through the **same**
+  `useConfirm()`, never another component's.
 
 **Keep the dialog open across steps**
 
@@ -585,6 +584,31 @@ const exportWorkspace = async () => {
 </script>
 ```
 
+### Several confirms at once
+
+Confirms stack. A `confirm()` while another is open (from a button's
+`onClick`, or two calls without an `await` between them) covers the open one
+in place; the one beneath stays pending, and comes back, still waiting for
+its answer, when the newer one closes. Escape and the backdrop answer only
+the one on top. Two un-awaited calls are therefore both asked, newest first:
+`await` each one when the order matters.
+
+`stack` picks the `BbDialog` stack a confirm joins (every confirm joins the
+confirms' own by default). Name a dialog's `stack` and the confirm replaces
+that dialog's view while it is open, as a drill-in step would ([BbDialog](./BbDialog.md)
+§ Stacked dialogs); a name no other dialog uses shows it on top of the other
+confirms, each dimming the one beneath.
+
+```ts
+// An unsaved-changes question that takes the editor's place, not a layer on it.
+const discard = await confirm({
+	title: 'Discard your changes?',
+	stack: 'editor', // the editor's <BbDialog stack="editor">
+	variant: 'destructive',
+	yes: 'Discard',
+});
+```
+
 ### Rich content with portals
 
 When plain `text` isn't enough, render custom content in the dialog body via a
@@ -740,9 +764,9 @@ The map is typed where you write it by `definePt`, never with an imported
 
 - **Don't hand-build a yes/no dialog** out of `BbDialog` + buttons — busy
   states, dismissal semantics, ownership and focus handling already live here.
-- **Don't fire two `confirm()` calls without awaiting the first.** The second
-  supersedes the first, which settles `false` — so a "delete these two things"
-  flow written as two un-awaited confirms deletes nothing and asks once.
+- **Two `confirm()` calls without an `await` between them ask both, newest
+  first** — the second covers the first. `await` each one when the questions
+  must come in order.
 - **Don't forget the `await`** — `confirm(...)` without it never gates
   anything.
 - **Don't call `close()` to "cancel"** a dialog whose buttons haven't run —
@@ -753,8 +777,8 @@ The map is typed where you write it by `definePt`, never with an imported
 - With `returning: true`, an implicit dismiss under the default
   `dismissAsNo: true` resolves with `no.onClick`'s return value — give No a
   callback that returns a sensible "declined" value.
-  System dismissals (`duration`, `dismissAll()`, a superseding `confirm()`,
-  owner unmount) still resolve `false`, so handle `false` too.
+  System dismissals (`duration`, `dismissAll()`, owner unmount) still resolve
+  `false`, so handle `false` too.
 - `confirm()` rejects keys `BbConfirmMessage` doesn't declare, also on a
   message built in a variable first: build it from `BbConfirmMessage` fields
   only (spread a wider object and the extra keys fail to type-check).

package/dist/ai/BbForm.md

@@ -1076,7 +1076,11 @@ const bodyRules = computed(() => (publishing.value ? 'required' : ''));
 ```
 
 Both switch live: the next validation uses the new schema or rules, and
-switching back lets a submit through that was blocked a moment ago.
+switching back lets a submit through that was blocked a moment ago. A message
+already on screen is not taken down by the switch: it stays until the field
+validates again (an edit, a blur, the next submit). If the condition lives in
+another field and the stale message would mislead, show it through
+[`field-errors`](#a-message-of-your-own-that-comes-and-goes) instead.
 
 ### While it saves
 
@@ -1353,6 +1357,54 @@ async function save(values: Record<string, unknown>) {
 }
 ```
 
+##### A message of your own that comes and goes
+
+The object does not have to come from a server. A check that spans fields is
+a `computed`: its message shows exactly while the check fails, with no code to
+clear it. Gate it on a submit attempt so it does not greet an empty form:
+
+```vue
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+import { BbButton, BbDatePickerInput, BbForm, BbSelect } from 'bitboss-ui';
+
+const patients = [
+	{ label: 'Anna Rossi', value: 1 },
+	{ label: 'Luca Bianchi', value: 2 },
+];
+const visit = ref<{ patient: number | null; date: string | null }>({
+	patient: null,
+	date: null,
+});
+const tried = ref(false);
+const missingDate = computed(() => !visit.value.patient && !visit.value.date);
+
+const ownErrors = computed(() => ({
+	date:
+		tried.value && missingDate.value
+			? 'Pick a date when no patient is selected.'
+			: undefined,
+}));
+
+const save = (values: Record<string, unknown>) => {
+	tried.value = true;
+	if (missingDate.value) return; // field-errors never block a submit
+	console.log('book', values);
+};
+</script>
+
+<template>
+	<BbForm :model="visit" :field-errors="ownErrors" @submit="save">
+		<BbSelect label="Patient" name="patient" :items="patients" clearable />
+		<BbDatePickerInput label="Date" name="date" />
+		<BbButton type="submit">Book</BbButton>
+	</BbForm>
+</template>
+```
+
+Picking a patient takes the message down at once. When the page also holds
+server errors, pass both: `:field-errors="{ ...form.errors, ...ownErrors }"`.
+
 - **The page owns them.** Editing the field does not hide its message; the
   next object does (Inertia replaces `form.errors` on every answer and clears
   it on success). Want it gone as the user types? Clear it yourself
@@ -1449,9 +1501,19 @@ const save = async (values: Record<string, unknown>) => {
 - A request-level message (Laravel's `message`, a 403) has no path: give it a
   key no field uses IN THE SAME CALL, `form.setErrors({ ...body.errors, _request: [body.message] })`, and it
   shows in the same summary.
-- **Each `setErrors` call replaces the last one's errors** (it is one server
-  answer). Two calls in a row keep only the second: merge everything into one
-  map first.
+- **`setErrors` hands over one server answer; it never takes a message
+  back.** A field's message stays until the user edits the field or it is
+  validated again. A submit validates every field, so a submit → 422 →
+  `setErrors` round always starts clean. A second call without a submit
+  between them replaces `unmatchedErrors` only: the first call's field
+  messages stay, and `null` or a missing key clears nothing. So put
+  everything one answer says into one map.
+- **Don't use `setErrors` for a message you will take back yourself**, like
+  your own cross-field check ("a date is required when no patient is
+  selected"). Compute it into [`field-errors`](#a-message-of-your-own-that-comes-and-goes)
+  instead: it shows while its key holds a message and goes the moment it
+  does not. Calling `validate()` to wipe a `setErrors` message runs every
+  rule on every field, so it puts messages on fields the user never touched.
 - `setErrors` does not emit `invalid`. It does move focus to the first failing
   field on screen, like a failed submit (`{ focus: false }` opts out; see
   [A failed submit focuses the first invalid field](#a-failed-submit-focuses-the-first-invalid-field)).
@@ -1617,7 +1679,8 @@ The `id` is also the `<form>`'s own (it follows a BbForm; a plain `<form>`
 submits but has no save state to follow), so a `<BbButton form="id" type="submit">`
 outside it submits it too, through the same validation, and spins while the
 save runs exactly like a submit button inside (`disable-auto-loading` opts
-out): no `:loading` to bind.
+out): no `:loading` to bind. Server errors (`setErrors`, `field-errors`) then
+focus the first failing field, as they do after a submit from inside.
 
 ```vue
 <script setup lang="ts">

package/dist/ai/BbHost.md

@@ -87,12 +87,13 @@ The same keys go in the build plugin (`bitbossUi({ confirm, toastPosition })`).
 
 ### Areas with their own look
 
-The host paints confirms and toasts where it is mounted, so they take the
-passthrough scope and tokens of the place the HOST sits. When the app is split
-into areas that each wrap their pages in `<BbPtScope>`
-([passthrough guide](./guides/passthrough.md) § Named scopes), mount one
-`<BbHost />` inside each area's layout, within its scope, and none at the app
-root. That holds only if **every** page renders inside exactly one of those
+A confirm takes the passthrough scope and tokens of the component that called
+`useConfirm()`, wherever the host sits: nothing to set up. Toasts take the
+scope and tokens of the place the HOST sits. When the app is split into areas
+that each wrap their pages in `<BbPtScope>`
+([passthrough guide](./guides/passthrough.md) § Named scopes) and toasts need
+each area's look, mount one `<BbHost />` inside each area's layout, within its
+scope, and none at the app root. That holds only if **every** page renders inside exactly one of those
 layouts, so there is still one host at a time. See
 [Agent Contract § Global Host Rule](./guides/agent-contract.md).
 
@@ -142,14 +143,11 @@ without a mismatch.
 - Listed nodes are the ones `BbHost`'s API reaches or that declare a documented CSS variable; the rest fold into "also mounts". The complete tree, repeats and undocumented locals included, is `manifest/components/BbHost.tree.json`.
 
 - `BbHost` _(this component)_
-  - `BbConfirm` _(internal — not importable, reach it through `BbConfirm`)_ — its own pt parts (`BbConfirm`): `text` → `div.bb-confirm__text`, `action` → `BbButton`; hands `BbDialog` the pt map `passthrough.forward(DIALOG_PARTS, BB_DIALOG_PT.states)` (ours → theirs)
-    - `BbDialog` _(public — [contract](./BbDialog.md))_ — its own pt parts (`BbDialog`): `header` → `div.bb-dialog__header`, `title` → `span.bb-dialog__title`, `description` → `p.bb-dialog__description`, `close` → `CloseButton`, `content` → `div.bb-dialog__content`, `footer` → `div.bb-dialog__footer`; hands `BbOffCanvas` the pt map `{ root: 'root', header: 'header', title: 'title', description: 'description', content: 'content', footer: 'footer', close: 'close', sheet: 'root', }` (ours → theirs); documented CSS variables: `--px`, `--close-size`
-      - `CloseButton` _(internal — not importable, reach it through `BbDialog`)_ — documented CSS variables: `--size`, `--p`
-      - `BbOffCanvas` _(public — [contract](./BbOffCanvas.md))_ — its own pt parts (`BbOffCanvas`): `header` → `div.bb-offcanvas__header`, `title` → `span.bb-offcanvas__title`, `description` → `p.bb-offcanvas__description`, `close` → `CloseButton`, `content` → `div.bb-offcanvas__content`, `footer` → `div.bb-offcanvas__footer`; documented CSS variables: `--stack-x`, `--snap-y`, `--stack-fill`, `--stack-transition-duration`, `--px`, `--handle-w`, `--handle-h`, `--handle-bg`, `--safe-top`, `--close-size`; also mounts `CloseButton`
-    - `BbButton` _(public — [contract](./BbButton.md))_ — its own pt parts (`BbButton`): `root` → `BbBaseButton`, `spinner` → `BbSpinner`, `icon` → `BbIcon`, `text` → `span.bb-button__text`; documented CSS variables: `--h-xs`, `--h`, `--icon-size`, `--px`, `--fs`, `--r`, `--gap`, `--bg`, `--bg-hover`, `--bg-pressed`, `--fg`, `--border-color`, `--ring-color`, `--ring-size`, `--bw`, `--fg-hover`, `--border-hover`, `--fg-pressed`, `--border-pressed`, `--bg-disabled`, `--fg-disabled`, `--border-disabled`, `--opacity-disabled`, `--elev-tier`, `--elev`; also mounts `BbIcon`, `BbSpinner`
-      - `BbBaseButton` _(public — [contract](./BbBaseButton.md))_ — its own pt parts (`BbBaseButton`): `root` → `RouterComponent`, `root` → `a`, `root` → `component`; also mounts `RouterComponent`
   - `BbToast` _(internal — not importable, reach it through `BbToast`)_ — documented CSS variables: `--gap`, `--offset`, `--width`, `--lift`, `--stack-y`, `--stack-scale`, `--enter-y`, `--swipe-amount`, `--z`, `--r`, `--ring-size`, `--bg`, `--border-color`, `--fg`, `--icon-color`
-    - `BbToastRegion` _(internal — not importable, reach it through `BbToast`)_ — its own pt parts (`BbToast`): `root` → `ol.bb-toast`; also mounts `BbToastMessage`
+    - `BbToastRegion` _(internal — not importable, reach it through `BbToast`)_ — its own pt parts (`BbToast`): `root` → `ol.bb-toast`
+      - `BbToastMessage` _(internal — not importable, reach it through `BbToast`)_ — also mounts `BbIcon`, `BbSpinner`
+        - `BbButton` _(public — [contract](./BbButton.md))_ — its own pt parts (`BbButton`): `root` → `BbBaseButton`, `spinner` → `BbSpinner`, `icon` → `BbIcon`, `text` → `span.bb-button__text`; documented CSS variables: `--h-xs`, `--h`, `--icon-size`, `--px`, `--fs`, `--r`, `--gap`, `--bg`, `--bg-hover`, `--bg-pressed`, `--fg`, `--border-color`, `--ring-color`, `--ring-size`, `--bw`, `--fg-hover`, `--border-hover`, `--fg-pressed`, `--border-pressed`, `--bg-disabled`, `--fg-disabled`, `--border-disabled`, `--opacity-disabled`, `--elev-tier`, `--elev`; also mounts `BbIcon`, `BbSpinner`
+          - `BbBaseButton` _(public — [contract](./BbBaseButton.md))_ — its own pt parts (`BbBaseButton`): `root` → `RouterComponent`, `root` → `a`, `root` → `component`; also mounts `RouterComponent`
 
 ## See Also
 

package/dist/ai/BbPtScope.md

@@ -96,9 +96,10 @@ The scope follows the **component tree**, not the DOM:
   in. A directive written directly in `<BbPtScope>`'s slot, in the same
   template as the scope, sees the scope above it instead — keep the scope in a
   layout or a parent component.
-- `<BbHost />` renders every toast and confirm where it is mounted. For toasts
-  and confirms in the area's look, mount one `<BbHost />` inside
-  each area's layout, within its scope, and none at the app root — valid only
+- A `confirm()` takes the scope of the component that called `useConfirm()`,
+  wherever `<BbHost />` is mounted. Toasts take the scope where the host is
+  mounted: for toasts in the area's look, mount one `<BbHost />` inside each
+  area's layout, within its scope, and none at the app root — valid only
   when every page renders inside exactly one of those layouts (see
   [Agent Contract § Global Host Rule](./guides/agent-contract.md)).
 
@@ -112,7 +113,8 @@ The scope follows the **component tree**, not the DOM:
 
 ### Works well with
 
-- `BbHost` — mount one inside each scoped area layout.
+- `BbHost` — mount one inside each scoped area layout when toasts need the
+  area's look.
 - The [passthrough guide](./guides/passthrough.md) — grammar, merging and the
   full parts table.