@yahoo/uds-create-config 3.2.0 → 3.4.0

package/dist/configs/react-native-system.d.ts

@@ -1109,6 +1109,7 @@ declare const ReactNativeSystem: ConfigClass<{
       target: _$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>;
       names: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
     }, _$zod_v4_core0.$strip>>>;
+    exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
   }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "file", Record<never, never>, {
     readonly binary: ({
       path
@@ -2633,6 +2634,7 @@ declare const ReactNativeSystem: ConfigClass<{
         target: _$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>;
         names: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
       }, _$zod_v4_core0.$strip>>>;
+      exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
     }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "file", Record<never, never>, {
       readonly binary: ({
         path

package/dist/configs/react-native-system.js

@@ -18,6 +18,7 @@ import { visibleStatePointerMigration } from "../migrations/20260908194245_visib
 import { iconKnockoutVariantsMigration } from "../migrations/20260909183001_icon_knockout_variants.js";
 import { linkedSystemLinkOpsMigration } from "../migrations/20260910212453_linked_system_link_ops.js";
 import { componentCreateBlankOpMigration } from "../migrations/20260914155048_component_create_blank_op.js";
+import { anatomyHarnessMigration } from "../migrations/20260914181845_anatomy_harness.js";
 import { NativeModifier } from "../entities/native/NativeModifier.js";
 import { NativeSettings } from "../entities/native/NativeSettings.js";
 import { NativeStyleProperty } from "../entities/native/NativeStyleProperty.js";
@@ -62,5 +63,6 @@ if (!registeredSchemaMigrations().has(20260908194245)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20260909183001)) registerSchemaMigrations(iconKnockoutVariantsMigration);
 if (!registeredSchemaMigrations().has(20260910212453)) registerSchemaMigrations(linkedSystemLinkOpsMigration);
 if (!registeredSchemaMigrations().has(20260914155048)) registerSchemaMigrations(componentCreateBlankOpMigration);
+if (!registeredSchemaMigrations().has(20260914181845)) registerSchemaMigrations(anatomyHarnessMigration);
 //#endregion
 export { ReactNativeSystem };

package/dist/configs/system.d.ts

@@ -973,6 +973,7 @@ declare const System: ConfigClass<{
       target: _$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>;
       names: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
     }, _$zod_v4_core0.$strip>>>;
+    exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
   }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "file", Record<never, never>, {
     readonly binary: ({
       path
@@ -2381,6 +2382,7 @@ declare const System: ConfigClass<{
         target: _$zod.ZodType<Ref, unknown, _$zod_v4_core0.$ZodTypeInternals<Ref, unknown>>;
         names: _$zod.ZodOptional<_$zod.ZodArray<_$zod.ZodString>>;
       }, _$zod_v4_core0.$strip>>>;
+      exports: _$zod.ZodOptional<SubEntityClass<_$zod.ZodObject<{}, _$zod_v4_core0.$strict>>>;
     }, _$zod_v4_core0.$strict>, _$zod.ZodObject<Record<never, never>, _$zod_v4_core0.$strip>, "file", Record<never, never>, {
       readonly binary: ({
         path

package/dist/configs/system.js

@@ -28,6 +28,7 @@ import { linkedSystemLinkOpsMigration } from "../migrations/20260910212453_linke
 import { previewConditionsMigration } from "../migrations/20260912161840_preview_conditions.js";
 import { fontVariableMigration } from "../migrations/20260912164927_font_variable.js";
 import { componentCreateBlankOpMigration } from "../migrations/20260914155048_component_create_blank_op.js";
+import { anatomyHarnessMigration } from "../migrations/20260914181845_anatomy_harness.js";
 //#region src/configs/system.ts
 /**
 * `System` — the design-system config TYPE. Declares the exact kinds a design system owns (tokens,
@@ -76,5 +77,6 @@ if (!registeredSchemaMigrations().has(20260910212453)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20260912161840)) registerSchemaMigrations(previewConditionsMigration);
 if (!registeredSchemaMigrations().has(20260912164927)) registerSchemaMigrations(fontVariableMigration);
 if (!registeredSchemaMigrations().has(20260914155048)) registerSchemaMigrations(componentCreateBlankOpMigration);
+if (!registeredSchemaMigrations().has(20260914181845)) registerSchemaMigrations(anatomyHarnessMigration);
 //#endregion
 export { System };

package/dist/entities/system/Component.js

@@ -8,7 +8,7 @@ import { derivedColor, gradient } from "./color.js";
 import { childrenPolicy } from "./element.js";
 import { listedIn } from "../../framework/utils/enumerated.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
-import { Style, addBagKeyIssues, bagNameEdges, bagRewriteName, bindBagTokens, collectBag, isPlainRecord, openBag, styleValue } from "./style-bag.js";
+import { Style, addBagKeyIssues, anatomyPropValue, bagNameEdges, bagRewriteName, bindBagTokens, collectBag, isPlainRecord, openBag, styleValue } from "./style-bag.js";
 import { propValueDomain, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
 import { intoName, routedPropIn, routesContent } from "../../framework/prop-surface.js";
 import { slotAnatomyPropOf, slotTargetsOf, withoutTruthyTerm } from "../../framework/render-spec.js";
@@ -773,6 +773,13 @@ function sameElement(left, right) {
 function spellsLayer(element, key, layer) {
 	return element === key || sameElement(element, layer);
 }
+/** Whether a node keyed like a layer renders it: the layer's ref, or an element the prop chooses
+*  that names the layer it stands in for (`{ "$state": "/type", …, "layer": "root" }`), which wears
+*  the layer's markers and classes on whichever component the value picks. */
+function rendersLayer(element, key) {
+	if (isRef(element)) return element.__ref === `layer:${key}`;
+	return typeof element === "object" && element !== null && "$state" in element && element.layer === key;
+}
 /** The shape of a rule, for a bag written where the rule belongs or a rule with no `layers`. */
 const ruleShapeError = (issue) => issue.code === "invalid_type" || issue.code === "unrecognized_keys" ? "a style rule is `{ \"when\": null, \"layers\": { \"<layer>\": { \"<styleProp>\": \"<value>\" } } }` under a key of your own (`*` for the unconditional rule), or with `\"when\": { \"<prop>\": \"<value>\" }` for a variant; the layer bags sit under `layers`, never directly under the rule" : void 0;
 const StyleRule = defineSubEntity({
@@ -845,7 +852,20 @@ const ruleSchemas = /* @__PURE__ */ new WeakMap();
 const nodeElement = z.union([
 	refSchema.describe("A ref. `layer:<name>` renders through one of this component's layers, which is the only way a node can be styled; `component:<path>`, `icon:<path>` or `package:<export>` renders that directly, unstyled."),
 	z.string().describe("An intrinsic tag such as `div`, rendered unstyled, or `Slot`: the position where an untargeted slot prop's content lands, with the prop named in `props.name`, listed in the `children` of a layer that takes nodes. A text layer shows a prop through a `forward` declared on the prop instead."),
-	z.strictObject({ $state: z.string() }).describe("An element the instance chooses: the value of the prop `$state` names, from that prop's own domain (an icon prop whose value is a glyph). It carries no per-value table; to show a different fixed glyph per variant value, give each glyph its own node with `visible: { \"$state\": \"<prop>\", \"eq\": \"<value>\" }`.")
+	z.strictObject({
+		$state: z.string(),
+		/** The render's own value → element table, for a root that mounts a different component per
+		*  value of one prop (`if (mode === 'link') return <ChipLink/>`). Absent for a domain lookup,
+		*  where the prop's declaration knows the values. */
+		map: z.record(z.string(), z.union([z.string(), refSchema])).optional(),
+		/** What mounts when no map entry matches — the render's final return. */
+		else: z.union([z.string(), refSchema]).optional(),
+		/** The layer the chosen element stands in for, so it keeps that layer's markers and classes. */
+		layer: z.string().optional()
+	}).refine((element) => element.map === void 0 || element.else !== void 0, {
+		message: "a `$state` element with a `map` needs an `else`: the element that mounts for a value the map does not name",
+		path: ["else"]
+	}).describe("An element the instance chooses: the value of the prop `$state` names. With no `map`, the value is resolved in that prop's own domain (an icon prop whose value is a glyph). With a `map` (value → `{ \"__ref\": \"component:<path>\" }`) and an `else`, it is the component the render mounts for that value — a root swapped by a variant — and `layer` names the layer it stands in for.")
 ], { error: "an element is `{ \"__ref\": \"layer:<name>\" }` for one of this component's layers, `{ \"__ref\": \"icon:<library>/<Name>\" }` for a glyph, `{ \"__ref\": \"component:<path>\" }` for a component rendered unstyled, an intrinsic tag such as `div`, `Slot` for where a slot prop's content lands, or `{ \"$state\": \"<prop>\" }` for an element the prop chooses" }).describe("What this node renders. Name a layer (`{ \"__ref\": \"layer:<name>\" }`) for anything a style rule should reach.");
 /** The operand each comparison accepts. Checked against the framework's operator set both ways, so
 *  the schema can neither drop an operator the readers handle nor accept one they don't. */
@@ -1028,8 +1048,16 @@ const AnatomyNode = defineSubEntity({
 		const body = parent;
 		const shape = {
 			element: nodeElement,
+			/** A package factory the element renders THROUGH — `{ "__ref": "package:motion/react#motion" }`
+			*  for a layer the render wrapped as `motion.create(Box)`. The registry holds an entry for each
+			*  (wrapper, element) pair the anatomies name, so the wrapped layer paints as the module does,
+			*  reading the same motion props off this node. */
+			wrapper: refSchema.optional().describe("A package factory this node renders through, such as `{ \"__ref\": \"package:motion/react#motion\" }` for a motion-wrapped layer. The node's props then include the wrapper's (`initial`, `animate`, `variants`, `transition`, …)."),
 			visible: visibility.optional().describe("When the node renders: a condition on a prop value (`{ \"$state\": \"<prop>\", \"eq\": <value> }`), an `$or` of them, or a list that must all hold. Omit for a node that always renders."),
-			props: (config ? openBag(config, { cssBehind: false }) : z.record(z.string(), styleValue)).optional().describe("Props passed to what the node renders, keyed by prop or style-property name, as literal values. Content is not set here: a `slot` prop's content lands where a `{ \"element\": \"Slot\", \"props\": { \"name\": \"<prop>\" } }` node sits among a parent's `children` (on the root when there is none), and a `forward` prop (`{ \"type\": \"forward\", \"target\": \"label/children\" }`) routes it into that layer with no node entry. `$state` belongs to `visible` and to an `element` a prop chooses."),
+			props: (config ? openBag(config, {
+				cssBehind: false,
+				values: anatomyPropValue
+			}) : z.record(z.string(), anatomyPropValue)).optional().describe("Props passed to what the node renders, keyed by prop or style-property name, as literal values. Content is not set here: a `slot` prop's content lands where a `{ \"element\": \"Slot\", \"props\": { \"name\": \"<prop>\" } }` node sits among a parent's `children` (on the root when there is none), and a `forward` prop (`{ \"type\": \"forward\", \"target\": \"label/children\" }`) routes it into that layer with no node entry. `$state` belongs to `visible` and to an `element` a prop chooses."),
 			text: z.string().optional().describe("Literal text content, for a node that renders a fixed string.")
 		};
 		if (!config || !body) return z.object({
@@ -1063,14 +1091,13 @@ const AnatomyNode = defineSubEntity({
 			const current = key ? body.anatomy?.[key] : void 0;
 			const element = node.element ?? current?.element;
 			if (key !== void 0 && body.layers && key in body.layers) {
-				const rendersLayer = isRef(element) && element.__ref === `layer:${key}`;
-				if (element !== void 0 && !rendersLayer && !spellsLayer(element, key, body.layers[key])) {
+				if (element !== void 0 && !rendersLayer(element, key) && !spellsLayer(element, key, body.layers[key])) {
 					const spelled = isRef(element) ? `\`${element.__ref}\`` : JSON.stringify(element);
 					ctx.issues.push({
 						code: "custom",
 						input: node,
 						path: ["element"],
-						message: `node "${key}" is keyed like the layer "${key}", so it renders that layer: \`{ "__ref": "layer:${key}" }\`. Written as ${spelled} it would paint the element directly, unstyled, outside every style rule that reaches the layer.`
+						message: `node "${key}" is keyed like the layer "${key}", so it renders that layer: \`{ "__ref": "layer:${key}" }\`, or an element the prop chooses with \`"layer": "${key}"\`. Written as ${spelled} it would paint the element directly, unstyled, outside every style rule that reaches the layer.`
 					});
 				}
 			}
@@ -1287,7 +1314,7 @@ const componentBags = (data) => {
 		if (!isPlainRecord(node)) continue;
 		collectBag(node.props, (next) => {
 			node.props = next;
-		}, out);
+		}, out, node.element);
 	}
 	collectBag(body?.defaultProps, (next) => {
 		if (body) body.defaultProps = next;

package/dist/entities/system/File.d.ts

@@ -53,6 +53,7 @@ declare const File: EntityClass<z.ZodObject<{
     target: z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>;
     names: z.ZodOptional<z.ZodArray<z.ZodString>>;
   }, z.core.$strip>>>;
+  exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "file", Record<never, never>, {
   /**
    * Bytes rather than text, so a restore knows how to write it — derived from the path, because

package/dist/entities/system/File.js

@@ -82,6 +82,24 @@ const FileImport = defineSubEntity({
 	})
 });
 /**
+* One export of a sealed source file that a render places in JSX — `file:components/pagination.tsx#PaginationProvider`.
+*
+* A component file exports more than its components: a context provider the composite wraps its
+* root in, a plain function component two renders share. When a render puts one in the tree, the
+* anatomy has to name it — the same way it names a package's export — and the registry has to
+* import it from the module the file emits to. The member is that name, with the same empty body a
+* `Package` export has: its identity is its name, and the module it lives in is the owning file.
+*
+* Only what a render placed in JSX, for the reason a `Package` lists only that: nobody browses a
+* file's exports, and a hook or a helper no JSX mentions is not a render surface.
+*/
+const FileExport = defineSubEntity({
+	name: "exports",
+	label: "Export",
+	labelPlural: "Exports",
+	fields: z.strictObject({})
+});
+/**
 * File (`file:components/card.tsx`) — one artifact the seal owns.
 *
 * A component is a definition plus the React that renders it, and `config.json` cannot hold JSX, so
@@ -110,13 +128,17 @@ const File = defineEntity({
 	labelPlural: "Files",
 	authoredRefs: false,
 	linkable: false,
+	bareMember: "exports",
 	fields: z.strictObject({
 		/** SHA-256 of the exact bytes — what the seal hashed, so a restore verifies rather than trusts. */
 		hash: z.string(),
 		/** What this file imports — keyed by the text the source wrote, in the order it wrote it. Every
 		*  local edge, plus each bare specifier a `Package` group already names; one the config names
 		*  nowhere is left out rather than pointed at a group minted to receive it. */
-		imports: FileImport.optional()
+		imports: FileImport.optional(),
+		/** The exports a render placed in JSX — a same-file provider or function component an anatomy
+		*  names by `file:<path>#<export>`. Absent for a file no anatomy reaches into. */
+		exports: FileExport.optional()
 	}),
 	computed: { 
 	/**
@@ -130,7 +152,10 @@ const File = defineEntity({
 	* boolean read as a tri-state at every call site.
 	*/
 binary: ({ path }) => isBinaryAsset(path) },
-	subEntities: { imports: FileImport }
+	subEntities: {
+		imports: FileImport,
+		exports: FileExport
+	}
 });
 //#endregion
 export { File, SCRIPT_EXTENSIONS, isBinaryAsset };

package/dist/entities/system/style-bag.js

@@ -17,6 +17,21 @@ const styleValue = z.lazy(() => z.union([
 	gradient,
 	z.record(z.string(), styleValue)
 ]));
+const anatomyPropValue = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	refSchema,
+	derivedColor,
+	gradient,
+	z.array(z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	])),
+	z.record(z.string(), anatomyPropValue)
+]));
 /**
 * A style bag as a keyed COLLECTION — style-prop key → {@link styleValue}, with each key a member
 * in its own right.
@@ -68,11 +83,15 @@ function isPlainRecord(value) {
 * written into its parent before that parent is rebuilt. A modifier block holds a bag of the same
 * shape, so this is the only recursion either hook needs.
 */
-function collectBag(bag, write, out) {
+function collectBag(bag, write, out, element) {
 	if (!isPlainRecord(bag)) return;
-	out.push({
+	out.push(element === void 0 ? {
 		bag,
 		write
+	} : {
+		bag,
+		write,
+		element
 	});
 	for (const [key, value] of Object.entries(bag)) {
 		if (!key.startsWith("_") || !isPlainRecord(value)) continue;
@@ -234,8 +253,8 @@ function addBagKeyIssues({ config, bag, ctx, nested, declared, cssBehind = true,
 }
 /** The open bag — every key a style value, with token names bound to their tokens. `cssBehind`
 *  as in {@link bagKeyIssue}: off for a bag that may reach an intrinsic element's attributes. */
-function openBag(config, { cssBehind = true } = {}) {
-	return z.record(z.string(), styleValue).superRefine((bag, ctx) => addBagKeyIssues({
+function openBag(config, { cssBehind = true, values = styleValue } = {}) {
+	return z.record(z.string(), values).superRefine((bag, ctx) => addBagKeyIssues({
 		config,
 		bag,
 		ctx,
@@ -244,4 +263,4 @@ function openBag(config, { cssBehind = true } = {}) {
 	})).transform((bag) => bindBagTokens(config, bag));
 }
 //#endregion
-export { Style, addBagKeyIssues, bagNameEdges, bagRewriteName, bindBagTokens, camelCase, collectBag, isPlainRecord, openBag, styleValue };
+export { Style, addBagKeyIssues, anatomyPropValue, bagNameEdges, bagRewriteName, bindBagTokens, camelCase, collectBag, isPlainRecord, openBag, styleValue };

package/dist/framework/Config.d.ts

@@ -72,7 +72,7 @@ interface RecordedSource {
  * The dense-counter `2` a short-lived scheme stamped before the chain existed reads as the mint
  * that replaced it (see `detectedWireVersion`).
  */
-declare const SERIALIZED_CONFIG_VERSION = 20260914155048;
+declare const SERIALIZED_CONFIG_VERSION = 20260914181845;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;

package/dist/framework/Config.js

@@ -4715,7 +4715,7 @@ var Config = class Config {
 	*  links from the provided sources. A declared `linkedKind` with no provided source throws. */
 	hydrateFrom(stored, options) {
 		const claimed = schemaVersionOf(stored);
-		if (claimed > 20260914155048) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20260914181845) throw new SchemaVersionTooNew(claimed);
 		const wire = upgradeSerializedConfig(stored);
 		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating, or port the repo once with \`uds migrate\`.`);
 		const leftover = wire.options;

package/dist/framework/anatomy-check.d.ts

@@ -0,0 +1,99 @@
+//#region src/framework/anatomy-check.d.ts
+/**
+ * Anatomy check — does a component's ANATOMY, expanded by the config, paint what the component's
+ * MODULE paints?
+ *
+ * The two are one component seen two ways: the editor paints a matrix cell from the stored anatomy
+ * (`expandSpec`), a canvas paints a dropped instance from the module. Every place they differ is a
+ * bug in the anatomy reader, the expansion, or a render the anatomy grammar cannot express. This
+ * module is the comparison: both renderings reduced to the same flat shape ({@link RenderedNode}),
+ * aligned, and their differences reported by kind, so a check can fail on them and a person can read
+ * them.
+ *
+ * Two ways in. {@link snapshotHtml} reads the markup `react-dom/server` produces, which is what
+ * `uds anatomy` compares in a Bun process — structure, text and classes, since no layout runs there.
+ * A browser surface snapshots live DOM instead (the studio's `?anatomyCheck=true`), and adds computed
+ * style to each node; {@link diffRendered} compares whatever a node carries.
+ */
+/** One rendered element, reduced to what anatomy cares about. */
+interface RenderedNode {
+  /** The component whose layer this element is, when it is one (`data-uds-component`). */
+  readonly component?: string;
+  /** The layer (`data-uds-layer`), when the element is one. */
+  readonly layer?: string;
+  readonly tag: string;
+  /** The element's OWN text — its direct text nodes, whitespace collapsed — never its children's. */
+  readonly text: string;
+  readonly classes: readonly string[];
+  /**
+   * Style, as the snapshot could read it. From live DOM, the computed subset {@link STYLE_PROPERTIES},
+   * compared where both sides carry a property. From markup, the element's inline `style`
+   * declarations — the only style markup has — compared as a whole: a declaration one side writes
+   * and the other does not is a difference, since inline is what a render's literal becomes.
+   */
+  readonly style: Readonly<Record<string, string>>;
+  /** `true` when `style` holds inline declarations rather than a computed subset. */
+  readonly inlineStyle?: boolean;
+  /** What the alignment matches on — see {@link renderedSignatureOf}. */
+  readonly signature: string;
+}
+type AnatomyIssueKind = /** The module renders this element and the anatomy does not. */'missing' /** The anatomy renders this element and the module does not. */ | 'extra' /** Both render it — aligned as the same layer — as different elements (`div` against `span`). */ | 'tag' /** Both render it, with different own text. */ | 'text' /** Both render it, with a computed style that differs beyond tolerance. */ | 'style'
+/** Both render it, with different class sets. Classes are how a style arrives, so where a
+ *  computed style is available this is informational; where none is (markup only) it is the
+ *  paint difference itself — see `diffRendered`'s `classesFail`. */
+| 'classes';
+interface AnatomyIssue {
+  readonly kind: AnatomyIssueKind;
+  /** The element, by signature, plus its ordinal among same-signature elements (`Modal/divider#2`). */
+  readonly node: string;
+  readonly property?: string;
+  readonly anatomy?: string;
+  readonly instance?: string;
+}
+interface AnatomyReport {
+  /** `true` when nothing that counts as a paint difference was found. */
+  readonly ok: boolean;
+  readonly issues: readonly AnatomyIssue[];
+  /** How many elements each side rendered under the component root. */
+  readonly counts: {
+    readonly anatomy: number;
+    readonly instance: number;
+  };
+}
+/**
+ * The computed properties compared on aligned elements. Paint, box, type — what a designer would
+ * notice. `width`/`height`/`line-height` compare with a pixel tolerance; everything else exactly,
+ * after {@link normalizeStyleValue}.
+ */
+declare const STYLE_PROPERTIES: readonly string[];
+/** Pixel slack for the size comparisons — sub-pixel layout and font rounding. */
+declare const SIZE_TOLERANCE_PX = 1.5;
+/** The alignment key: a layer is `Component/layer`; anything else is its tag. */
+declare function renderedSignatureOf(tag: string, component: string | undefined, layer: string | undefined): string;
+/**
+ * Every element under the component root of `html`, in document order, as {@link RenderedNode}s
+ * without computed style. The root is the first element carrying `data-uds-component`; hosts and
+ * shells above it are scaffolding. `data-anatomy-check-ignore` subtrees are skipped.
+ */
+declare function snapshotHtml(html: string): RenderedNode[];
+/** `rgb(…)` spacing and a trailing `px` zero are the browser's spelling, not a difference. */
+declare function normalizeStyleValue(value: string): string;
+interface DiffOptions {
+  /**
+   * Count a class-set difference as a failure. Off where computed styles are compared (the class is
+   * only how the style arrived); on where only markup is (the class IS the paint).
+   */
+  readonly classesFail?: boolean;
+}
+/**
+ * Compare the anatomy's rendering with the module's.
+ *
+ * Elements align by signature in document order; what the module renders and the anatomy does not
+ * is `missing`, the reverse is `extra`. Aligned elements then compare own text, computed style (when
+ * both sides carry it) and class set.
+ */
+declare function diffRendered(anatomy: readonly RenderedNode[], instance: readonly RenderedNode[], options?: DiffOptions): AnatomyReport;
+/** The allowlist spelling of an issue: kind, node, and the property for a style difference. */
+declare function anatomyIssueKey(issue: AnatomyIssue): string;
+//#endregion
+export { AnatomyIssue, AnatomyIssueKind, AnatomyReport, DiffOptions, RenderedNode, SIZE_TOLERANCE_PX, STYLE_PROPERTIES, anatomyIssueKey, diffRendered, normalizeStyleValue, renderedSignatureOf, snapshotHtml };