bitboss-ui 3.0.0-beta.21 → 3.0.0-beta.23

package/dist/composables/useConfirm.js

@@ -9,8 +9,12 @@ var { t: s } = n(), c = e(), l = [], u = {
 	yesBusy: !1,
 	noBusy: !1,
 	actionBusy: null
-}, d = o({ ...u }), f = d, p = a(/* @__PURE__ */ new Map()), m = (e, t) => (p.set(e, t), () => p.delete(e)), h = t.medium, g, _, v = 0, y = !1, b = !1, x = () => {
-	v++, y = !0;
+}, d = o({ ...u }), f = d, p = a(/* @__PURE__ */ new Map()), m = (e, t) => (p.set(e, t), () => p.delete(e)), h = t.medium, g, _, v = 0, y = !1, b, x = 1e3, S = (e) => {
+	process.env.NODE_ENV === "production" || y || (clearTimeout(b), b = setTimeout(() => {
+		y || v > 0 || e() || (y = !0, c.warn("Confirm: confirm() was called but no <BbConfirm> host is mounted — the returned promise will never settle because no dialog can render. Mount exactly one <BbConfirm /> at the app root."));
+	}, x));
+}, C = () => {
+	v++, clearTimeout(b);
 	let e = !1;
 	return {
 		count: v,
@@ -18,36 +22,36 @@ var { t: s } = n(), c = e(), l = [], u = {
 			e || (e = !0, v--);
 		}
 	};
-}, S = () => {
+}, w = () => {
 	clearTimeout(_), clearTimeout(g), d.value = { ...u };
-}, C = () => {
+}, T = () => {
 	let e = l.shift();
 	if (!e) return;
 	let t = d.value.current;
-	t && !t.settled && t.resolve(!1), S(), d.value.current = e, d.value.processing = !0, process.env.NODE_ENV !== "production" && !e.title && !e.text && !e.portal && console.warn("[BbConfirm] A confirm was opened with no title, text, or portal — the dialog will appear empty."), process.env.NODE_ENV !== "production" && e.text && e.portal && c.warn("Confirm: a message carries both `text` and `portal` — `text` takes priority and the portal is ignored. Remove one of the two."), e.duration && (d.value.current.autoClose = !0, g = setTimeout(() => {
+	t && !t.settled && t.resolve(!1), w(), d.value.current = e, d.value.processing = !0, process.env.NODE_ENV !== "production" && !e.title && !e.text && !e.portal && console.warn("[BbConfirm] A confirm was opened with no title, text, or portal — the dialog will appear empty."), process.env.NODE_ENV !== "production" && e.text && e.portal && c.warn("Confirm: a message carries both `text` and `portal` — `text` takes priority and the portal is ignored. Remove one of the two."), e.duration && (d.value.current.autoClose = !0, g = setTimeout(() => {
 		let { current: e } = d.value;
-		e && (w(e), l.length ? C() : D());
+		e && (E(e), l.length ? T() : k());
 	}, e.duration));
-}, w = (e) => {
+}, E = (e) => {
 	e.settled || e.resolve(!1);
-}, T = (e) => {
-	for (let t = l.length - 1; t >= 0; t--) l[t].owner === e && (w(l[t]), l.splice(t, 1));
+}, D = (e) => {
+	for (let t = l.length - 1; t >= 0; t--) l[t].owner === e && (E(l[t]), l.splice(t, 1));
 	let { current: t } = d.value;
-	t?.owner === e && (w(t), l.length ? C() : D());
-}, E = () => {
-	for (; l.length;) w(l.pop());
+	t?.owner === e && (E(t), l.length ? T() : k());
+}, O = () => {
+	for (; l.length;) E(l.pop());
 	let { current: e } = d.value;
-	e && (w(e), D());
-}, D = () => {
-	process.env.NODE_ENV !== "production" && d.value.current && !d.value.current.settled && c.warn("Confirm: close() was called while the current confirm() promise is still pending. The dialog is hidden, but the promise will never settle — resolve it first via the Yes/No buttons or the portal yes()/no() helpers."), clearTimeout(g), d.value.yesBusy = !1, d.value.noBusy = !1, d.value.actionBusy = null, d.value.processing = !1, clearTimeout(_), _ = setTimeout(S, h);
-}, O = (e, t) => {
+	e && (E(e), k());
+}, k = () => {
+	process.env.NODE_ENV !== "production" && d.value.current && !d.value.current.settled && c.warn("Confirm: close() was called while the current confirm() promise is still pending. The dialog is hidden, but the promise will never settle — resolve it first via the Yes/No buttons or the portal yes()/no() helpers."), clearTimeout(g), d.value.yesBusy = !1, d.value.noBusy = !1, d.value.actionBusy = null, d.value.processing = !1, clearTimeout(_), _ = setTimeout(w, h);
+}, A = (e, t) => {
 	typeof e == "number" ? d.value.actionBusy = t ? e : null : e === "yes" ? d.value.yesBusy = t : d.value.noBusy = t;
-}, k = async (e, t = !1) => {
+}, j = async (e, t = !1) => {
 	let { current: n } = d.value;
-	n && (clearTimeout(g), e ? n.yes ? await n.yes.onClick() : A(n, !0) : (t || n.dismissAsNo) && n.no ? await n.no.onClick() : A(n, !1));
-}, A = (e, t) => {
-	e.resolve(t), l.length ? C() : e.autoClose && D();
-}, j = (e, t) => {
+	n && (clearTimeout(g), e ? n.yes ? await n.yes.onClick() : M(n, !0) : (t || n.dismissAsNo) && n.no ? await n.no.onClick() : M(n, !1));
+}, M = (e, t) => {
+	e.resolve(t), l.length ? T() : e.autoClose && k();
+}, N = (e, t) => {
 	if (t === !1) return;
 	if (t === void 0) return e;
 	let n = typeof t == "string" ? { text: t } : t;
@@ -58,12 +62,11 @@ var { t: s } = n(), c = e(), l = [], u = {
 		variant: n.variant ?? e.variant,
 		size: n.size ?? e.size
 	};
-}, M = (e, t) => new Promise((n, r) => {
+}, P = (e, t) => new Promise((n, r) => {
 	if (typeof window > "u") {
 		process.env.NODE_ENV !== "production" && console.warn("[BbConfirm] confirm() was called during server-side rendering — resolved `false`. Trigger confirms from client-side code (event handlers)."), n(!1);
 		return;
 	}
-	process.env.NODE_ENV !== "production" && !y && !b && (b = !0, c.warn("Confirm: confirm() was called but no <BbConfirm> host has ever mounted — the returned promise will never settle because no dialog can render. Mount exactly one <BbConfirm /> at the app root."));
 	let i = (e) => {
 		m.settled = !0, n(e);
 	}, a = (e) => {
@@ -74,18 +77,18 @@ var { t: s } = n(), c = e(), l = [], u = {
 		return {
 			...e,
 			onClick: async () => {
-				O(t, !0);
+				A(t, !0);
 				let e = n;
 				try {
 					if (r) {
 						let t = await r();
 						d && (e = t);
 					}
-					i(e), l.length ? C() : u && D();
+					i(e), l.length ? T() : u && k();
 				} catch (e) {
-					a(e), D();
+					a(e), k();
 				} finally {
-					O(t, !1);
+					A(t, !1);
 				}
 			}
 		};
@@ -95,16 +98,16 @@ var { t: s } = n(), c = e(), l = [], u = {
 		dismissAsNo: !0,
 		autoClose: !0,
 		...e,
-		actions: p ? p.map((e, t) => f(j({
+		actions: p ? p.map((e, t) => f(N({
 			size: "md",
 			variant: "outline"
 		}, e), t, !0)) : e.actions,
-		yes: p ? void 0 : f(j({
+		yes: p ? void 0 : f(N({
 			text: s("confirm.ok").value,
 			size: "md",
 			variant: o
 		}, e.yes), "yes", !0),
-		no: p ? void 0 : f(j({
+		no: p ? void 0 : f(N({
 			text: s("confirm.cancel").value,
 			size: "md",
 			variant: "outline"
@@ -114,19 +117,19 @@ var { t: s } = n(), c = e(), l = [], u = {
 		settled: !1,
 		owner: t
 	};
-	l.push(m), C();
-}), N = () => {
+	l.push(m), v === 0 && S(() => m.settled), T();
+}), F = () => {
 	if (!r()) return {
-		confirm: M,
-		close: D,
-		dismissAll: E
+		confirm: P,
+		close: k,
+		dismissAll: O
 	};
 	let e = Symbol("bb-confirm-owner");
-	return i(() => T(e)), {
-		confirm: (t) => M(t, e),
-		close: D,
-		dismissAll: E
+	return i(() => D(e)), {
+		confirm: (t) => P(t, e),
+		close: k,
+		dismissAll: O
 	};
 };
 //#endregion
-export { h as TRANSITION_DURATION, x as __registerConfirmHost, f as confirmState, p as namedPortalRegistry, k as processMessage, m as registerNamedPortal, N as useConfirm };
+export { x as NO_HOST_WARNING_DELAY, h as TRANSITION_DURATION, C as __registerConfirmHost, f as confirmState, p as namedPortalRegistry, j as processMessage, m as registerNamedPortal, F as useConfirm };

package/dist/composables/useSafeAreaInternal.js

@@ -1,5 +1,5 @@
 import { useMobile as e } from "./useMobile.js";
-import { viewportHeight as t, viewportWidth as n } from "./useViewportWidth.js";
+import { viewportClientHeight as t, viewportClientWidth as n } from "./useViewportWidth.js";
 import { useOffCanvasStack as r } from "../components/BbOffCanvas/useOffCanvasStack.js";
 import { computed as i, ref as a } from "vue";
 //#region src/composables/useSafeAreaInternal.ts

package/dist/composables/useToast.d.ts

@@ -3,6 +3,22 @@ import { BbToast, BbToastDismissReason, BbToastOptions, BbToastPortalContext, Bb
 export declare const toastState: {
     toasts: BbToast[];
 };
+/**
+ * Grace period before the zero-host warning fires. See the twin in
+ * `useConfirm.ts` for the full rationale — the short version: a host mounted
+ * in a layout rather than the app root unmounts and remounts across a route
+ * change, and a `toast()` landing in that gap is NOT lost. A late-mounting
+ * host renders the queued message (verified), so "no host right now" does not
+ * mean "no host is coming".
+ *
+ * At fire time we re-read the count, so the delay only has to outlast a slow
+ * async layout chunk; a generous value is strictly safer than a tight one.
+ *
+ * Supersedes the 2026-07-30 `hostEverMounted` latch, which went quiet for the
+ * whole process once ANY host had ever mounted — silencing exactly the case a
+ * non-root host produces.
+ */
+export declare const NO_HOST_WARNING_DELAY = 1000;
 /**
  * Called by `<BbToast>` on mount. Internal — not re-exported from
  * `src/index.ts`. Returns the host count including this one (for the

package/dist/composables/useToast.js

@@ -7,8 +7,12 @@ var r = 300, i = /* @__PURE__ */ new Set([
 	"info",
 	"warning",
 	"destructive"
-]), a = t({ toasts: [] }), o = 0, s = !1, c = !1, l = () => {
-	o++, s = !0;
+]), a = t({ toasts: [] }), o = 0, s = !1, c, l = 1e3, u = () => {
+	process.env.NODE_ENV === "production" || s || (clearTimeout(c), c = setTimeout(() => {
+		s || o > 0 || (s = !0, console.warn("[BbToast] toast() was called but no <BbToast> host is mounted — the toast is queued but nothing will render or expire it. Mount exactly one <BbToast /> at the app root."));
+	}, l));
+}, d = () => {
+	o++, clearTimeout(c);
 	let e = !1;
 	return {
 		count: o,
@@ -16,9 +20,9 @@ var r = 300, i = /* @__PURE__ */ new Set([
 			e || (e = !0, o--);
 		}
 	};
-}, u = t(/* @__PURE__ */ new Map()), d = (e, t) => (u.set(e, t), () => u.delete(e)), f = 0, p = (e) => {
+}, f = t(/* @__PURE__ */ new Map()), p = (e, t) => (f.set(e, t), () => f.delete(e)), m = 0, h = (e) => {
 	if (e.duration !== void 0 && e.duration <= 0) throw Error("Toast duration must be a positive number of milliseconds.");
-	let t = e.id ?? `bb-toast-${++f}`, n = Date.now(), r = a.toasts.find((e) => e.id === t), i = e.loading ?? r?.loading ?? !1, o = e.persistent ?? i, s, c;
+	let t = e.id ?? `bb-toast-${++m}`, n = Date.now(), r = a.toasts.find((e) => e.id === t), i = e.loading ?? r?.loading ?? !1, o = e.persistent ?? i, s, c;
 	o ? (s = Infinity, c = Number.isFinite(r?.duration) ? r?.duration : r?.preLoadingDuration) : e.duration === void 0 ? r && Number.isFinite(r.duration) ? s = r.duration : r && Number.isFinite(r.preLoadingDuration) && (s = r.preLoadingDuration) : s = e.duration;
 	let l = (t) => t in e ? e[t] : r?.[t], u = {
 		id: t,
@@ -39,24 +43,24 @@ var r = 300, i = /* @__PURE__ */ new Set([
 		preLoadingDuration: c
 	};
 	return r ? Object.assign(r, u) : a.toasts.push(u), t;
-}, m = (t, n) => {
+}, g = (t, n) => {
 	t.removed || (t.removed = !0, e(r).then(() => {
 		a.toasts = a.toasts.filter((e) => e.id !== t.id);
 	}));
-}, h = (e, t = "manual") => {
-	if (e === void 0) return a.toasts.forEach((e) => m(e, t)), e;
+}, _ = (e, t = "manual") => {
+	if (e === void 0) return a.toasts.forEach((e) => g(e, t)), e;
 	let n = a.toasts.find((t) => t.id === e);
-	return n && m(n, t), e;
-}, g = (e, t) => a.toasts.some((t) => t.id === e) ? p({
+	return n && g(n, t), e;
+}, v = (e, t) => a.toasts.some((t) => t.id === e) ? h({
 	...t,
 	id: e
-}) : e, _ = (e) => {
+}) : e, y = (e) => {
 	let t = typeof e == "string" ? { title: e } : e;
-	return typeof window > "u" ? (process.env.NODE_ENV !== "production" && console.warn("[BbToast] toast() was called during server-side rendering — ignored. Trigger toasts from client-side code (onMounted, event handlers)."), t.id ?? "") : (process.env.NODE_ENV !== "production" && !s && !c && (c = !0, console.warn("[BbToast] toast() was called but no <BbToast> host has ever mounted — the toast is queued but nothing will render or expire it. Mount exactly one <BbToast /> at the app root.")), process.env.NODE_ENV !== "production" && !t.title && !t.text && !t.portal && console.warn("[BbToast] A toast was created with no title, text, or portal — it will render empty."), process.env.NODE_ENV !== "production" && t.portal && t.actions && console.warn("[BbToast] A toast carries both `portal` and `actions` — portal content owns the body, so the actions are not rendered. Render the buttons inside the portal instead."), process.env.NODE_ENV !== "production" && t.variant && t.variant !== "default" && i.has(t.variant) && !t.icon && !t.loading && !t.portal && console.warn(`[BbToast] A "${t.variant}" toast was created with no \`icon\` — the variant tints the icon and sets announcement priority, nothing else, so this renders identically to a default toast. Pass a matching \`icon\` (e.g. lucide:circle-check / lucide:circle-x) when the tone should be visible.`), p(t));
-}, v = (e, t) => e.position ?? t ?? n.toastPosition ?? "bottom-right", y = () => ({
-	toast: _,
-	dismiss: h,
-	update: g
+	return typeof window > "u" ? (process.env.NODE_ENV !== "production" && console.warn("[BbToast] toast() was called during server-side rendering — ignored. Trigger toasts from client-side code (onMounted, event handlers)."), t.id ?? "") : (o === 0 && u(), process.env.NODE_ENV !== "production" && !t.title && !t.text && !t.portal && console.warn("[BbToast] A toast was created with no title, text, or portal — it will render empty."), process.env.NODE_ENV !== "production" && t.portal && t.actions && console.warn("[BbToast] A toast carries both `portal` and `actions` — portal content owns the body, so the actions are not rendered. Render the buttons inside the portal instead."), process.env.NODE_ENV !== "production" && t.variant && t.variant !== "default" && i.has(t.variant) && !t.icon && !t.loading && !t.portal && console.warn(`[BbToast] A "${t.variant}" toast was created with no \`icon\` — the variant tints the icon and sets announcement priority, nothing else, so this renders identically to a default toast. Pass a matching \`icon\` (e.g. lucide:circle-check / lucide:circle-x) when the tone should be visible.`), h(t));
+}, b = (e, t) => e.position ?? t ?? n.toastPosition ?? "bottom-right", x = () => ({
+	toast: y,
+	dismiss: _,
+	update: v
 });
 //#endregion
-export { l as __registerToastHost, _ as createToast, h as dismissToast, u as namedToastPortalRegistry, d as registerToastPortal, v as resolveToastPosition, a as toastState, g as updateToast, y as useToast };
+export { l as NO_HOST_WARNING_DELAY, d as __registerToastHost, y as createToast, _ as dismissToast, f as namedToastPortalRegistry, p as registerToastPortal, b as resolveToastPosition, a as toastState, v as updateToast, x as useToast };

package/dist/composables/useViewportWidth.d.ts

@@ -16,13 +16,27 @@
  */
 export declare const viewportWidth: import('vue').ShallowRef<number>, viewportHeight: import('vue').ShallowRef<number>;
 /**
- * The scrollbar-excluded flavor of the same singleton (documentElement client
- * box rather than `innerWidth`/`innerHeight`). `useSafeArea` measures element
- * claims against this basis — counting the scrollbar would inflate every
- * measured claim by its width. Module-level for the same reason as above: one
- * shared `resize` listener per flavor instead of one per component instance.
+ * The scrollbar-excluded flavor of the same singleton — the LAYOUT viewport,
+ * the box fixed-positioned elements actually reach the edges of. `useSafeArea`
+ * measures element claims against this basis: counting the scrollbar would
+ * inflate every measured claim by its width. Module-level for the same reason
+ * as above: one shared `resize` listener per flavor instead of one per
+ * component instance.
+ *
+ * Width is `documentElement.getBoundingClientRect().width`, NOT
+ * `documentElement.clientWidth` (which `useWindowSize({ includeScrollbar:
+ * false })` reads). They differ under `scrollbar-gutter: stable` — which the
+ * shipped reset sets on `<html>`: Chromium keeps reporting the full width in
+ * `clientWidth` while the reserved gutter shrinks the box every fixed element
+ * lays out in. Measured 2026-09-09 in a 414px test viewport: `innerWidth` and
+ * `clientWidth` 414, a `position: fixed; right: 0` box ending at 399, and
+ * every safe-area claim over by exactly those 15px. The root element's own
+ * border box is the one measure that tracks the real edge, and unlike
+ * `visualViewport` it does not shrink under pinch-zoom. Height stays
+ * `clientHeight`: the gutter reserves the inline axis only.
  */
-export declare const viewportClientWidth: import('vue').ShallowRef<number>, viewportClientHeight: import('vue').ShallowRef<number>;
+export declare const viewportClientWidth: import('vue').Ref<number, number>;
+export declare const viewportClientHeight: import('vue').Ref<number, number>;
 /**
  * Re-seed every flavor from the live window, so a spec that wrote
  * `viewportWidth.value` directly cannot leak its width into later specs.

package/dist/composables/useViewportWidth.js

@@ -1,9 +1,10 @@
-import { config as e } from "virtual:bitboss-ui/config";
-import { useWindowSize as t } from "@vueuse/core";
+import { ref as e } from "vue";
+import { config as t } from "virtual:bitboss-ui/config";
+import { useEventListener as n, useWindowSize as r } from "@vueuse/core";
 //#region src/composables/useViewportWidth.ts
-var { width: n, height: r } = t({ initialWidth: e.ssrViewportWidth }), { width: i, height: a } = t({
-	initialWidth: e.ssrViewportWidth,
-	includeScrollbar: !1
-});
+var { width: i, height: a } = r({ initialWidth: t.ssrViewportWidth }), o = e(t.ssrViewportWidth), s = e(Infinity), c = () => {
+	typeof document > "u" || (o.value = document.documentElement.getBoundingClientRect().width, s.value = document.documentElement.clientHeight);
+};
+typeof window < "u" && (c(), n(window, "resize", c, { passive: !0 }));
 //#endregion
-export { a as viewportClientHeight, i as viewportClientWidth, r as viewportHeight, n as viewportWidth };
+export { s as viewportClientHeight, o as viewportClientWidth, a as viewportHeight, i as viewportWidth };

package/dist/icon-scan.d.ts

@@ -0,0 +1,276 @@
+/** Directories never descended into, matched as whole path segments. */
+export declare const ALWAYS_SKIPPED_DIRS: ReadonlySet<string>;
+/**
+ * 256 MiB. The cap exists only to keep database dumps and similar out of
+ * memory — a real source file is never this large, so it is never skipped.
+ */
+export declare const DEFAULT_MAX_FILE_SIZE: number;
+/**
+ * From this many files up, the per-file work is spread over worker threads.
+ * Each worker brings its own libuv thread pool, so reads, hashes and regex
+ * passes run in true parallel — the difference between a cold scan that is
+ * felt and one that is not, on a laptop with a slow disk and few cores.
+ */
+export declare const DEFAULT_WORKER_THRESHOLD = 1500;
+export declare const SCAN_CACHE_VERSION = 4;
+export interface IconsScannerOptions {
+    /**
+     * Extra paths or globs scanned IN ADDITION to the project root: a vendor
+     * package that ships icon names, a directory outside the root. Relative
+     * entries resolve against the root. Additive — the root is always scanned.
+     *
+     * An entry is explicit, so the always-skip rules (`vendor`, hidden
+     * segments, `.gitignore` files ABOVE it) do not apply to the entry itself;
+     * they still apply to what lies beneath it.
+     */
+    include?: string[];
+    /**
+     * Globs removed from the scan, on top of the built-in skips. Gitignore
+     * syntax, matched against the path relative to the root (or to the
+     * `include` entry that brought the file in).
+     */
+    exclude?: string[];
+    /**
+     * Skip files larger than this many bytes. Only here to keep database
+     * dumps out of memory — the default is far above any source file.
+     *
+     * @defaultValue 268435456 (256 MiB)
+     */
+    maxFileSize?: number;
+}
+export interface IconScannerConfig {
+    /** Absolute Vite root. */
+    root: string;
+    /** Absolute `build.outDir`; always skipped. */
+    outDir: string;
+    scanner: IconsScannerOptions;
+    /** Installed set prefixes — the only `<prefix>:` sequences looked for. */
+    prefixes: readonly string[];
+    /** Whether `prefix:name` resolves in an installed set (icons + aliases). */
+    resolves: (prefix: string, name: string) => boolean;
+    /** Where the per-file cache lives. */
+    cacheFile: string;
+    /** Everything the cached results depend on besides file content. */
+    cacheKey: string;
+    /**
+     * File count from which worker threads are used (`Infinity` = never,
+     * `0` = always). Internal knob — tests force both paths.
+     */
+    workerThreshold?: number;
+}
+export interface ScanStats {
+    /** Files that passed every skip rule and were considered. */
+    files: number;
+    /** Files whose bytes were actually read. */
+    read: number;
+    /** Files whose bytes were run through the extractor (hash changed or new). */
+    extracted: number;
+    /** Files dropped for being binary or over `maxFileSize`. */
+    skipped: number;
+    /** Milliseconds, wall clock. */
+    elapsed: number;
+    /** No usable cache existed (first run, or the cache key changed). */
+    cold: boolean;
+    /** Worker threads the per-file work ran on (0 = main thread). */
+    workers: number;
+}
+/**
+ * The `<prefix>:<name>` matcher for a prefix list. Longest prefix first so
+ * `mdi-light:` never loses to `mdi:`; a name is `[a-z0-9][a-z0-9-]*`, and the
+ * prefix must not be the tail of a longer word (`xlucide:eye`).
+ */
+export declare function iconLiteralRegExp(prefixes: readonly string[]): RegExp;
+/**
+ * Every `prefix:name` candidate in `bytes`, deduplicated, in order of first
+ * appearance. One pass over the raw bytes (decoded 1:1 as latin1 — no UTF-8
+ * work, no parsing). A trailing dash is dropped so the static fragment of a
+ * template literal (`lucide:arrow-${dir}` → `arrow`) is still a candidate:
+ * a fragment that resolves costs one small chunk, which is acceptable.
+ */
+export declare function extractIconCandidates(bytes: Buffer, regex: RegExp): string[];
+/** True when a null byte sits in the first block — the file is not text. */
+export declare function looksBinary(bytes: Buffer): boolean;
+/** Whether a string carries glob syntax at all. */
+export declare const hasGlobMagic: (pattern: string) => boolean;
+/**
+ * A small glob → RegExp for the two places the plugin matches globs against
+ * NAMES rather than gitignore paths: `iconWhitelist` entries
+ * (`tabler:calendar-*`) and the pattern half of an `include` entry. Supports
+ * `*` (no slash), `**` (anything), `?`, `[…]` classes and `{a,b}` alternation.
+ */
+export declare function globToRegExp(pattern: string): RegExp;
+/** What a file scan needs to know. Plain data — it crosses the thread boundary. */
+export interface FileScanOptions {
+    /** Set prefixes, each with its trailing colon (`lucide:`). */
+    needles: string[];
+    /** `iconLiteralRegExp(prefixes).source`. */
+    regexSource: string;
+    maxFileSize: number;
+    probeBytes: number;
+}
+export interface FileJob {
+    path: string;
+    /** The cached entry for this path, if any. */
+    prev: {
+        size: number;
+        mtime: number;
+        hash: string;
+    } | null;
+}
+export type FileScanResult = 
+/** Not a regular file, unreadable, over the cap, or binary. */
+{
+    path: string;
+    outcome: 'skip';
+    read: boolean;
+}
+/** Size and mtime match the cache: bytes not read. */
+ | {
+    path: string;
+    outcome: 'fresh';
+    size: number;
+    mtime: number;
+}
+/** Read and hashed; the hash matches the cache, extraction skipped. */
+ | {
+    path: string;
+    outcome: 'same';
+    size: number;
+    mtime: number;
+    hash: string;
+}
+/** Read, hashed, extracted: raw candidates, not yet validated. */
+ | {
+    path: string;
+    outcome: 'new';
+    size: number;
+    mtime: number;
+    hash: string;
+    candidates: string[];
+};
+type FileInfo = {
+    isFile(): boolean;
+    size: number;
+    mtimeMs: number;
+};
+type FsLike = {
+    statSync: (p: string) => FileInfo;
+    fstatSync: (fd: number) => FileInfo;
+    openSync: (p: string, flags: string) => number;
+    readSync: (fd: number, buf: Buffer, offset: number, length: number, position: number) => number;
+    closeSync: (fd: number) => void;
+};
+type CryptoLike = {
+    hash?: (algorithm: string, data: Buffer, encoding: 'hex') => string;
+    createHash: (algorithm: string) => {
+        update: (data: Buffer) => {
+            digest: (encoding: 'hex') => string;
+        };
+    };
+};
+/**
+ * SYNCHRONOUS on purpose. Measured on a 10k-file project: the promise-based
+ * `readFile` costs four thread-pool round trips per file and ran at ~480 ms
+ * for the set, `openSync`+`readSync`+`closeSync` at ~190 ms. The blocking is
+ * harmless where this runs — inside a worker thread for any project large
+ * enough to notice, and for a few hundred files (or one changed file) on the
+ * main thread, where it is over before anything else could have run anyway.
+ */
+export declare function createFileScanner(fs: FsLike, crypto: CryptoLike, options: FileScanOptions): (job: FileJob) => FileScanResult;
+/**
+ * How many workers a machine gets: every core but one, at least two (a
+ * dual-core laptop still gains from two threads issuing reads at once — the
+ * cold scan is disk-bound, not CPU-bound), at most four.
+ */
+export declare function workerCountFor(cores: number): number;
+export declare class IconScanner {
+    private readonly cfg;
+    /** null when no set is installed — nothing can resolve, nothing is read. */
+    private readonly fileOptions;
+    private readonly scanOne;
+    private readonly workerThreshold;
+    private readonly excludes;
+    private readonly bases;
+    private readonly resolveMemo;
+    private readonly gitignoreMemo;
+    /** Absolute file path → cached result (the live cache). */
+    private entries;
+    private cold;
+    private dirty;
+    private lastWorkers;
+    constructor(cfg: IconScannerConfig);
+    /** Directories the dev server should watch besides the root. */
+    get includeDirs(): string[];
+    /** Every provider icon referenced somewhere in the scanned files. */
+    get icons(): Set<string>;
+    private includeBase;
+    private gitignoreFor;
+    /** Forget every parsed `.gitignore` — call when one changes on disk. */
+    resetGitignores(): void;
+    /**
+     * Git semantics across levels: the deepest file with a matching rule wins,
+     * a negation re-includes, and an ignored DIRECTORY is final for everything
+     * beneath it (handled by the walk pruning it).
+     */
+    private isGitignored;
+    private isExcluded;
+    /**
+     * Whether a directory entry beneath `base` may be entered/read. `chain` is
+     * the `.gitignore` chain that applies at the entry's parent.
+     */
+    private admits;
+    /**
+     * Whether `abs` would be picked up by a full walk — the dev watcher asks
+     * this for every changed path. Applies the same rules, segment by segment,
+     * from the base that owns the path.
+     */
+    isCandidate(abs: string): boolean;
+    private walk;
+    /** Every file a full scan would read, absolute, deduplicated. */
+    collectFiles(): Promise<string[]>;
+    private resolvesMemo;
+    /**
+     * Fold one per-file result into a cache entry, validating fresh
+     * candidates against the installed sets. `null` entry = no file to keep.
+     */
+    private fold;
+    /** A cache entry for a path when no set is installed: stat only. */
+    private statOnly;
+    /**
+     * Bring one file's cache entry up to date (the dev watcher path). Returns
+     * what happened so stats (and tests) can tell a skipped read from a
+     * skipped extraction.
+     */
+    private scanFile;
+    /**
+     * Whether a scan of about `expectedFiles` files should use the worker pool.
+     */
+    private useWorkers;
+    /**
+     * Every file's result — on the pool when there is one and the project is
+     * large enough to make its start-up worth it, else on the main thread. A
+     * worker failure of any kind degrades to the main-thread path.
+     */
+    private scanAll;
+    private loadCache;
+    /** Full walk + scan. Reuses the on-disk cache, then persists it. */
+    scan(): Promise<ScanStats>;
+    /**
+     * Re-scan ONE file after the watcher saw it change or appear. Returns true
+     * when the union of used icons changed — the caller then invalidates the
+     * virtual module. A path the rules reject is ignored (and a stale entry for
+     * it dropped).
+     */
+    updateFile(abs: string): Promise<boolean>;
+    /** Drop a deleted file. Returns true when the union of used icons changed. */
+    removeFile(abs: string): boolean;
+    /** Write the cache when something changed since the last write. */
+    persist(): Promise<void>;
+}
+/**
+ * The cache file: `node_modules/.cache/bitboss-ui/icon-scan.json` under the
+ * nearest `node_modules` at or above the root (Nuxt roots at `app/`, which has
+ * none of its own), falling back to the root's.
+ */
+export declare function iconScanCacheFile(root: string): string;
+export {};