@yahoo/uds-v5-wip 1.60.0 → 1.62.0

package/dist/config/dist/captureCallerPath.js

@@ -0,0 +1,95 @@
+//#region ../config/dist/captureCallerPath.js
+/**
+* Inspect the current call stack and return the first frame whose file
+* path sits outside the `@uds/config` package itself — i.e. the
+* user's authoring site.
+*
+* Stashing the path at definition time gives every config object its
+* origin for free. Consumers (codegen, CSS scanner, AI prompt builder)
+* read `__sourcePath` off the config map directly instead of walking
+* the AST to re-derive where each registration was authored.
+*
+* The skip predicate matches `/packages/config/` (workspace
+* layout) and `/@uds/config/` (consumer node_modules layout) so
+* internal frames never leak through. Returns `undefined` when no
+* eligible frame is found.
+*
+* Stack format coverage:
+*  - Bun / V8 in-process: `    at fn (/abs/path.ts:L:C)` or bare
+*    `    at /abs/path.ts:L:C` (no parens).
+*  - Node native stacks: `file:///abs/path.ts:L:C` URL form.
+*  - Source-mapped frames downleveled through tsdown: `.js` files.
+*
+* The regex picks the first `(...).ext:line:col` token; the
+* surrounding `at fn` / paren wrapping is ignored.
+*/
+const INTERNAL_FRAME_MARKERS = ["/packages/config/", "/@uds/config/"];
+const FRAME_PATH_RE = /\(?(?:file:\/\/)?(\/[^):\s]+?\.[cm]?[jt]sx?):\d+(?::\d+)?\)?/;
+const TEST_FILE_RE = /\.test\.[jt]sx?$/;
+function isInternalFrame(path) {
+	if (TEST_FILE_RE.test(path)) return false;
+	return INTERNAL_FRAME_MARKERS.some((marker) => path.includes(marker));
+}
+/**
+* `@uds/codegen`'s `loadConfig` bundles `uds.config.ts` with
+* `Bun.build` and runs the bundle from `<cwd>/.uds/config-bundle/`.
+* The bundle's inline sourcemap maps frames back to paths *relative
+* to the bundle output dir* — e.g.
+* `apps/docs/.uds/config-bundle/src/uds/components/button.tsx`,
+* not the original `apps/docs/src/uds/components/button.tsx`.
+* Strip the segment so `Component.sourceFilePath` resolves to a
+* readable on-disk path. Matches `/.uds/config-bundle/` so it's
+* agnostic to which app the bundle was emitted under.
+*/
+const CONFIG_BUNDLE_PATH_SEGMENT = "/.uds/config-bundle/";
+function normalizeBundlePath(path) {
+	const idx = path.indexOf(CONFIG_BUNDLE_PATH_SEGMENT);
+	if (idx === -1) return path;
+	return path.slice(0, idx + 1) + path.slice(idx + 20);
+}
+function captureCallerPath() {
+	const stack = (/* @__PURE__ */ new Error()).stack;
+	if (!stack) return void 0;
+	for (const line of stack.split("\n")) {
+		const match = line.match(FRAME_PATH_RE);
+		if (!match) continue;
+		const path = normalizeBundlePath(match[1]);
+		if (isInternalFrame(path)) continue;
+		return path;
+	}
+}
+/**
+* Non-enumerable `__sourcePath` slot key. Centralized so codegen
+* consumers and authoring helpers agree on one spelling.
+*/
+const SOURCE_PATH_KEY = "__sourcePath";
+/**
+* Attach `__sourcePath` to a config object non-enumerably.
+* `JSON.stringify` ignores non-enumerable properties so the wire format
+* stays clean.
+*
+* No-op when `path` is `undefined` — keeps the config shape stable
+* when the stack-walk yields no eligible frame.
+*/
+function attachSourcePath(target, path) {
+	if (!path) return target;
+	Object.defineProperty(target, SOURCE_PATH_KEY, {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value: path
+	});
+	return target;
+}
+/**
+* Read `__sourcePath` off a config object. Returns `undefined` when
+* the slot was never set (e.g. configs produced outside the `define*`
+* helpers).
+*/
+function readSourcePath(target) {
+	if (target === null || typeof target !== "object" && typeof target !== "function") return;
+	const value = target[SOURCE_PATH_KEY];
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+export { SOURCE_PATH_KEY, attachSourcePath, captureCallerPath, readSourcePath };

package/dist/config/dist/colorExpressions.d.ts

@@ -0,0 +1,132 @@
+import { TokenRef } from "./refs.js";
+import { CssAngle, CssColor, CssLength, CssPercentage } from "./types/css-values.js";
+
+//#region ../config/dist/colorExpressions.d.ts
+//#region src/colorExpressions.d.ts
+/** Position used for gradient stops + radial center — a CSS length or percentage. */
+type LengthOrPercent = CssLength | CssPercentage;
+/** Line direction keyword for `linear-gradient(to <dir>, …)`. */
+type LineDirection = 'top' | 'right' | 'bottom' | 'left' | 'top right' | 'top left' | 'bottom right' | 'bottom left';
+/** Color space accepted by `color-mix()` and gradient `<color-interpolation-method>`. */
+type ColorSpace = 'srgb' | 'srgb-linear' | 'oklab' | 'oklch' | 'lab' | 'lch' | 'hsl' | 'hwb';
+/** Radial gradient extent keyword. */
+type RadialSize = 'closest-side' | 'closest-corner' | 'farthest-side' | 'farthest-corner';
+interface MixExpr {
+  readonly __kind: 'mix';
+  readonly from: ColorValue;
+  readonly to: ColorValue;
+  readonly amount: CssPercentage;
+  readonly colorSpace?: ColorSpace;
+}
+/**
+ * `darken(color, N)` / `lighten(color, N)` — one-arg shade shorthands that
+ * blend a color toward black (darken) or white (lighten) by `amount`%, using
+ * `light-dark(...)` so the blend direction flips per color scheme. A focused
+ * pair alongside the general `mix`; resolves through the same pipeline.
+ */
+interface ShadeExpr {
+  readonly __kind: 'darken' | 'lighten';
+  readonly color: ColorValue;
+  /** Mix percentage toward black/white — `10` → `10%`. */
+  readonly amount: number;
+}
+interface GradientStop {
+  readonly color: ColorValue;
+  readonly at?: LengthOrPercent;
+}
+interface LinearGradientExpr {
+  readonly __kind: 'linear-gradient';
+  readonly angle?: CssAngle | `to ${LineDirection}`;
+  readonly stops: readonly GradientStop[];
+  readonly interpolation?: ColorSpace;
+  readonly repeating?: boolean;
+}
+interface RadialGradientExpr {
+  readonly __kind: 'radial-gradient';
+  readonly shape?: 'circle' | 'ellipse';
+  readonly size?: RadialSize;
+  readonly position?: LengthOrPercent | 'center' | 'top' | 'right' | 'bottom' | 'left';
+  readonly stops: readonly GradientStop[];
+  readonly interpolation?: ColorSpace;
+  readonly repeating?: boolean;
+}
+/**
+ * Any expression / marker that resolves to a CSS color value.
+ *
+ * `TokenRef` here is intentionally un-narrowed by token type. When
+ * the `Registered*` augmentations grow a `__type` slot, this can
+ * narrow to color-typed tokens — until then runtime + patch
+ * validation catches type mismatches.
+ */
+type ColorValue = CssColor | TokenRef | MixExpr;
+/** Anything that resolves to a CSS `background-image`-eligible value. */
+type GradientValue = TokenRef | LinearGradientExpr | RadialGradientExpr;
+/** Union of every structured expression authored via these helpers. */
+type ColorExpression = MixExpr | ShadeExpr | LinearGradientExpr | RadialGradientExpr;
+declare function isMixExpr(value: unknown): value is MixExpr;
+declare function isLinearGradientExpr(value: unknown): value is LinearGradientExpr;
+declare function isRadialGradientExpr(value: unknown): value is RadialGradientExpr;
+declare function isColorExpression(value: unknown): value is ColorExpression;
+/**
+ * `color-mix(in <space>, <from> <amount>, <to>)` — blend `from` and
+ * `to` at the given percentage. Inputs can be CSS color literals,
+ * `token('ns/name')` markers, or other `mix()` outputs.
+ *
+ *     mix(token('bg/primary'), 'transparent', '20%')
+ *     mix('#000', token('bg/accent'), '40%', 'oklab')
+ */
+declare function mix(from: ColorValue, to: ColorValue, amount: CssPercentage, colorSpace?: ColorSpace): MixExpr;
+/**
+ * Opacity sugar — `alpha(color, 0.2)` resolves to
+ * `color-mix(in srgb, color 20%, transparent)`, which renders as
+ * `color` at 20% opacity. The numeric API matches `rgba()` and the
+ * CSS `opacity` property (both 0..1).
+ *
+ * Out-of-range values clamp to `[0, 1]`. The mix amount is the
+ * color's share of the blend (`color-mix(in srgb, A X%, B)` defines
+ * `X%` as A's proportion), so `opacity * 100` is exactly what goes on
+ * the wire.
+ */
+declare function alpha(color: ColorValue, opacity: number): MixExpr;
+/**
+ * `darken(color, 10)` → `color-mix(in oklch, color, light-dark(black, white) 10%)`
+ * — blends `color` toward black in light mode, white in dark mode. Pairs with
+ * `lighten`. `color` is usually a `token('bg/brand')` ref but accepts any
+ * `ColorValue`.
+ */
+declare function darken(color: ColorValue, amount: number): ShadeExpr;
+/** Mirror of `darken()`; blends toward white in light mode, black in dark. */
+declare function lighten(color: ColorValue, amount: number): ShadeExpr;
+/**
+ * `linear-gradient(<angle>, <stop1>, <stop2>, …)` — directional
+ * gradient. `angle` accepts a CSS angle (`'135deg'`) or a `to <dir>`
+ * keyword. Stops carry a `color` and optional `at` position — bare
+ * stops let the engine space evenly.
+ */
+declare function linearGradient(spec: {
+  angle?: CssAngle | `to ${LineDirection}`;
+  stops: readonly GradientStop[];
+  interpolation?: ColorSpace;
+  repeating?: boolean;
+}): LinearGradientExpr;
+/**
+ * `radial-gradient(<shape> <size> at <position>, <stop1>, …)` —
+ * gradient radiating outward from `position`. Defaults match CSS
+ * (ellipse at center).
+ */
+declare function radialGradient(spec: {
+  shape?: 'circle' | 'ellipse';
+  size?: RadialSize;
+  position?: LengthOrPercent | 'center' | 'top' | 'right' | 'bottom' | 'left';
+  stops: readonly GradientStop[];
+  interpolation?: ColorSpace;
+  repeating?: boolean;
+}): RadialGradientExpr;
+type TokenRefToCss = (ref: string) => string;
+/**
+ * Resolve any structured color expression to its CSS string. The
+ * single entry point codegen calls after `isColorExpression` fires.
+ */
+declare function resolveColorExpression(expr: ColorExpression, tokenRefToCss: TokenRefToCss): string; //#endregion
+//#endregion
+export { ColorExpression, ColorSpace, ColorValue, GradientStop, GradientValue, LengthOrPercent, LineDirection, LinearGradientExpr, MixExpr, RadialGradientExpr, RadialSize, TokenRefToCss, alpha, darken, isColorExpression, isLinearGradientExpr, isMixExpr, isRadialGradientExpr, lighten, linearGradient, mix, radialGradient, resolveColorExpression };

package/dist/config/dist/colorExpressions.js

@@ -0,0 +1,148 @@
+import { isTokenRef } from "./refs.js";
+//#region ../config/dist/colorExpressions.js
+function hasKind(value, kind) {
+	return typeof value === "object" && value !== null && value.__kind === kind;
+}
+function isMixExpr(value) {
+	return hasKind(value, "mix");
+}
+function isShadeExpr(value) {
+	return hasKind(value, "darken") || hasKind(value, "lighten");
+}
+function isLinearGradientExpr(value) {
+	return hasKind(value, "linear-gradient");
+}
+function isRadialGradientExpr(value) {
+	return hasKind(value, "radial-gradient");
+}
+function isColorExpression(value) {
+	return isMixExpr(value) || isShadeExpr(value) || isLinearGradientExpr(value) || isRadialGradientExpr(value);
+}
+/**
+* `color-mix(in <space>, <from> <amount>, <to>)` — blend `from` and
+* `to` at the given percentage. Inputs can be CSS color literals,
+* `token('ns/name')` markers, or other `mix()` outputs.
+*
+*     mix(token('bg/primary'), 'transparent', '20%')
+*     mix('#000', token('bg/accent'), '40%', 'oklab')
+*/
+function mix(from, to, amount, colorSpace) {
+	return {
+		__kind: "mix",
+		from,
+		to,
+		amount,
+		colorSpace
+	};
+}
+/**
+* Opacity sugar — `alpha(color, 0.2)` resolves to
+* `color-mix(in srgb, color 20%, transparent)`, which renders as
+* `color` at 20% opacity. The numeric API matches `rgba()` and the
+* CSS `opacity` property (both 0..1).
+*
+* Out-of-range values clamp to `[0, 1]`. The mix amount is the
+* color's share of the blend (`color-mix(in srgb, A X%, B)` defines
+* `X%` as A's proportion), so `opacity * 100` is exactly what goes on
+* the wire.
+*/
+function alpha(color, opacity) {
+	return {
+		__kind: "mix",
+		from: color,
+		to: "transparent",
+		amount: `${Math.round(Math.max(0, Math.min(1, opacity)) * 100)}%`,
+		colorSpace: "srgb"
+	};
+}
+/**
+* `darken(color, 10)` → `color-mix(in oklch, color, light-dark(black, white) 10%)`
+* — blends `color` toward black in light mode, white in dark mode. Pairs with
+* `lighten`. `color` is usually a `token('bg/brand')` ref but accepts any
+* `ColorValue`.
+*/
+function darken(color, amount) {
+	return {
+		__kind: "darken",
+		color,
+		amount
+	};
+}
+/** Mirror of `darken()`; blends toward white in light mode, black in dark. */
+function lighten(color, amount) {
+	return {
+		__kind: "lighten",
+		color,
+		amount
+	};
+}
+/**
+* `linear-gradient(<angle>, <stop1>, <stop2>, …)` — directional
+* gradient. `angle` accepts a CSS angle (`'135deg'`) or a `to <dir>`
+* keyword. Stops carry a `color` and optional `at` position — bare
+* stops let the engine space evenly.
+*/
+function linearGradient(spec) {
+	return {
+		__kind: "linear-gradient",
+		...spec
+	};
+}
+/**
+* `radial-gradient(<shape> <size> at <position>, <stop1>, …)` —
+* gradient radiating outward from `position`. Defaults match CSS
+* (ellipse at center).
+*/
+function radialGradient(spec) {
+	return {
+		__kind: "radial-gradient",
+		...spec
+	};
+}
+function resolveColorValue(value, tokenRefToCss) {
+	if (typeof value === "string") return value;
+	if (isMixExpr(value)) return resolveMixExpr(value, tokenRefToCss);
+	if (isTokenRef(value)) return tokenRefToCss(value.ref);
+	return "";
+}
+function resolveMixExpr(expr, tokenRefToCss) {
+	const space = expr.colorSpace ?? "srgb";
+	const from = resolveColorValue(expr.from, tokenRefToCss);
+	const to = resolveColorValue(expr.to, tokenRefToCss);
+	return `color-mix(in ${space}, ${from} ${expr.amount}, ${to})`;
+}
+function resolveShadeExpr(expr, tokenRefToCss) {
+	return `color-mix(in oklch, ${resolveColorValue(expr.color, tokenRefToCss)}, ${expr.__kind === "darken" ? "light-dark(black, white)" : "light-dark(white, black)"} ${expr.amount}%)`;
+}
+function renderStops(stops, tokenRefToCss) {
+	const parts = [];
+	for (const stop of stops) {
+		const color = resolveColorValue(stop.color, tokenRefToCss);
+		parts.push(stop.at !== void 0 ? `${color} ${stop.at}` : color);
+	}
+	return parts.join(", ");
+}
+function resolveLinearGradientExpr(expr, tokenRefToCss) {
+	const fn = expr.repeating ? "repeating-linear-gradient" : "linear-gradient";
+	const prefix = expr.angle !== void 0 ? `${expr.angle}, ` : "";
+	return `${fn}(${expr.interpolation ? `in ${expr.interpolation}, ` : ""}${prefix}${renderStops(expr.stops, tokenRefToCss)})`;
+}
+function resolveRadialGradientExpr(expr, tokenRefToCss) {
+	const fn = expr.repeating ? "repeating-radial-gradient" : "radial-gradient";
+	const shapeAndSize = [expr.shape ?? "", expr.size ?? ""].filter(Boolean).join(" ");
+	const positionPart = expr.position ? ` at ${expr.position}` : "";
+	const head = shapeAndSize || positionPart ? `${shapeAndSize}${positionPart}, ` : "";
+	return `${fn}(${expr.interpolation ? `in ${expr.interpolation}, ` : ""}${head}${renderStops(expr.stops, tokenRefToCss)})`;
+}
+/**
+* Resolve any structured color expression to its CSS string. The
+* single entry point codegen calls after `isColorExpression` fires.
+*/
+function resolveColorExpression(expr, tokenRefToCss) {
+	if (isMixExpr(expr)) return resolveMixExpr(expr, tokenRefToCss);
+	if (isShadeExpr(expr)) return resolveShadeExpr(expr, tokenRefToCss);
+	if (isLinearGradientExpr(expr)) return resolveLinearGradientExpr(expr, tokenRefToCss);
+	return resolveRadialGradientExpr(expr, tokenRefToCss);
+}
+//#endregion
+export { alpha, darken, isColorExpression, isLinearGradientExpr, isMixExpr, isRadialGradientExpr, lighten, linearGradient, mix, radialGradient, resolveColorExpression };

package/dist/config/dist/defineAssetGroup.d.ts

@@ -0,0 +1,158 @@
+import { ComponentRef } from "./refs.js";
+import { FontAssetMember } from "./types.js";
+
+//#region ../config/dist/defineAssetGroup.d.ts
+//#region src/defineAssetGroup.d.ts
+/**
+ * Static metadata an icon-class member may carry (the UDS v3 generated
+ * icons stamp this shape). All fields optional — metadata-less
+ * libraries (Phosphor) fall back to the documented harvest convention
+ * (PascalCase export key + component-shaped value).
+ */
+interface IconAssetMetadata {
+  readonly name?: string;
+  readonly isSvgIcon?: boolean;
+  readonly variants?: readonly string[];
+  readonly category?: string;
+  readonly tags?: readonly string[];
+}
+/**
+ * One icon-class member — a React component (plain function or a
+ * forwardRef/memo exotic) optionally carrying static `.metadata`.
+ * Typed structurally so `@uds/config` doesn't depend on React types
+ * here; the renderer casts at the registry boundary.
+ */
+type IconAssetMember = ((props: never) => unknown) & {
+  readonly metadata?: IconAssetMetadata;
+};
+/**
+ * Icon branch — `type` is optional so icon authors never declare the
+ * class. `sizes` is required unless `props` is used (which normalizes
+ * into the flat fields). It's load-bearing render data (the `<svg>`
+ * shell reads px from it) and the picker's size-option list is derived
+ * from its keys.
+ */
+interface IconAssetGroupConfig<P = Record<string, unknown>> {
+  type?: 'icon';
+  /** Named size → px (`{ sm: 16, md: 24 }`). Picker options = keys. */
+  sizes?: Readonly<Record<string, number>>;
+  /**
+   * Group-level variant superset the picker starts from. Omitted ⇒
+   * harvested union of members' `.metadata.variants` (first-seen
+   * order), which by construction can't drift behind the library.
+   * Required (in practice) for metadata-less libraries.
+   */
+  variants?: readonly string[];
+  /** Display label. Defaults to the title-cased registration key. */
+  label?: string;
+  description?: string;
+  /**
+   * Filter harvested members by their export key — return `false` to skip one.
+   * A large third-party package often ships more than its canonical glyph set
+   * (Phosphor exports both `HouseIcon` and a deprecated bare `House` alias, plus
+   * non-glyph `IconBase`/`IconContext`). Passing the package wildcard is required
+   * for codegen to bundle live members, so this predicate is how you narrow that
+   * wildcard to the real icons (e.g. `(n) => n.endsWith('Icon')`). Applied before
+   * the PascalCase / component-shape checks; runs over every export key.
+   */
+  include?: (name: string) => boolean;
+  /**
+   * Authoring sugar mirroring the member component's own prop axes. Each entry
+   * is a picker value-set, NOT a style map: keys are the member's
+   * prop names, values are the allowed choices. Exactly ONE entry must be a
+   * named→px MAP (the size axis); at most one entry may be an ARRAY (the variant
+   * axis). Normalized at config-eval into the flat `sizes`/`variants` fields.
+   * Cannot be combined with those flat fields. Type the members via
+   * `defineAssetGroup<IconProps>(...)` to constrain keys to the component's
+   * props (e.g. `variant` → its enum).
+   */
+  props?: { [K in keyof P]?: Readonly<Record<string, number>> | readonly NonNullable<P[K]>[] };
+  /**
+   * The component that authors this group's members in exported code —
+   * e.g. `'Icon'` so a placed asset node `yahoo-os:asset:icons/Trophy`
+   * round-trips through code views as `<Icon name="Trophy" … />`. There
+   * is no implicit link between a group and a component (a group's members
+   * and a component's `name` enum are decoupled even when built from the
+   * same package), so the authoring component is declared explicitly.
+   * It is also the component a placed member *renders through* on the canvas:
+   * the resolved `Icon` owns the set-specific size/variant→glyph mapping. Omit
+   * it for a component-less system: members render bare and exporters fall back
+   * to the bare member tag. Accepts a typed `ComponentRef` (from
+   * `component()`) or a bare string.
+   */
+  component?: string | ComponentRef;
+}
+/**
+ * Font branch — `type: 'font'` declares the class. The `never` fields
+ * make icon-class props a compile error inside a `{ type: 'font' }`
+ * literal regardless of property order (the union is ordering-free,
+ * unlike the chained-methods spelling it replaced).
+ */
+interface FontAssetGroupConfig {
+  type: 'font';
+  label?: string;
+  description?: string;
+  /** Icon-class prop — excluded on the font branch at the type level. */
+  sizes?: never;
+  /** Icon-class prop — excluded on the font branch at the type level. */
+  variants?: never;
+  /** Icon-class prop — excluded on the font branch at the type level. */
+  props?: never;
+  /** Icon-class prop — excluded on the font branch at the type level. */
+  component?: never;
+}
+type AssetGroupConfig = IconAssetGroupConfig<Record<string, unknown>> | FontAssetGroupConfig;
+interface AssetGroupDefinitionBase {
+  /** Invariant ref tag — identical for every asset class. */
+  readonly __kind: 'assetGroup';
+  /**
+   * The group's slug — late-bound from the `registerAssetGroups`
+   * record key. Reading before registration throws.
+   */
+  readonly ref: string;
+  readonly label?: string;
+  readonly description?: string;
+}
+interface IconAssetGroupDefinition extends AssetGroupDefinitionBase {
+  readonly assetKind: 'icon';
+  /** Harvested members, keyed by asset name (the `${assetName}` id segment). */
+  readonly members: Readonly<Record<string, IconAssetMember>>;
+  /** Per-member harvested `.metadata` (name/variants/category/tags). */
+  readonly memberMetadata: Readonly<Record<string, IconAssetMetadata>>;
+  readonly sizes: Readonly<Record<string, number>>;
+  /** Resolved variant superset — declared, or the harvested union. */
+  readonly variants: readonly string[];
+  /** Authoring component for code export (`'Icon'`), if declared. */
+  readonly component?: string;
+}
+interface FontAssetGroupDefinition extends AssetGroupDefinitionBase {
+  readonly assetKind: 'font';
+  /** Members keyed by `FontID` (kebab-case) — pure-JSON data records. */
+  readonly members: Readonly<Record<string, FontAssetMember>>;
+}
+type AssetGroupDefinition = IconAssetGroupDefinition | FontAssetGroupDefinition;
+/**
+ * `defineAssetGroup(members)` return value — the only thing you can do
+ * with it is `.config({...})`, which completes the definition. The
+ * overloads branch the return type on the config union's discriminant.
+ * The phantom `P` generic flows from `defineAssetGroup<P>(...)` and
+ * constrains the `props` block keys/values to the member component's
+ * own props.
+ */
+interface AssetGroupBuilder<P = Record<string, unknown>> {
+  config(config: IconAssetGroupConfig<P>): IconAssetGroupDefinition;
+  config(config: FontAssetGroupConfig): FontAssetGroupDefinition;
+}
+/**
+ * Attach icon metadata to a single one-off icon and hand it back
+ * unchanged. `isSvgIcon: true` is implied —
+ * the point of the call is to mark the component as an icon so the
+ * group harvest picks it up. Slots still point at the *group*, never
+ * at this.
+ */
+declare function defineAssetIcon<T>(component: T, metadata: Omit<IconAssetMetadata, 'isSvgIcon'>): T & {
+  readonly metadata: IconAssetMetadata;
+};
+declare function defineAssetGroup<P = Record<string, unknown>>(members: Readonly<Record<string, unknown>>): AssetGroupBuilder<P>; //#endregion
+//#endregion
+export { AssetGroupBuilder, AssetGroupConfig, AssetGroupDefinition, FontAssetGroupConfig, FontAssetGroupDefinition, IconAssetGroupConfig, IconAssetGroupDefinition, IconAssetMember, IconAssetMetadata, defineAssetGroup, defineAssetIcon };