@yahoo/uds-create-config 3.1.0 → 3.3.0

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.`
 					});
 				}
 			}
@@ -1249,6 +1276,22 @@ const componentFields = z.strictObject({
 	}
 });
 /**
+* The body a blank component is created with: one intrinsic `div` layer and the anatomy node that
+* renders it, nothing else. Studio's "+" and the `create-blank` op both write exactly this.
+*
+* Both halves are needed. The kind requires a `root` layer, but layers alone project the component
+* rendering itself, a painting with nothing to compose into; the node is what puts a real `div`
+* carrying the editor's selection markers on the canvas. `div` is an intrinsic tag rather than a
+* system component, so no system is without it. Anything more (a `children` slot, preview content, a
+* style rule) makes the component authored rather than blank, and the editor's drop frame stands down.
+*/
+function blankComponentBody() {
+	return {
+		layers: { root: "div" },
+		anatomy: { root: { element: { __ref: "layer:root" } } }
+	};
+}
+/**
 * Where a component keeps its bags: each style rule's per-layer bag, each anatomy node's props, and
 * the component's own defaults.
 *
@@ -1271,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;
@@ -1314,7 +1357,7 @@ slots: ({ config, path, member }) => {
 	schemas: {
 		create: {
 			data: componentFields,
-			description: "Create a component at a new qualified `path`. When its complete body is known, include all layers, anatomy, props, defaults, and styles in this one operation. `data.layers` maps each stable layer name to the element it renders and must include `root` — a tag for a primitive (`{ \"layers\": { \"root\": \"div\" } }`), and for anything built on top, a ref to a primitive (`{ \"root\": { \"__ref\": \"component:Box\" }, \"label\": { \"__ref\": \"component:Text\" } }`), which is what lets the layer take that primitive's style props. A primitive exposes style props as `{ \"type\": \"styleProperty\", \"value\": { \"__ref\": \"style-property:bg\" } }` and declares `children: { \"type\": \"slot\", \"text\": true }` when it holds content — without the slot, nothing nested inside it renders. A composed component exposes a layer's props at its own top level through `forwards`, keyed by layer: `{ \"forwards\": { \"root\": \"*\" } }` passes every prop the root's element takes (so `<Button width=\"full\">` reaches the root's `width`), and a list of member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`, each naming the component that declares the prop) passes only those. A prop a layer already exposes is forwarded, never redeclared in `props`; a `props` entry of `{ \"type\": \"forward\" }` is the reverse route, one of this component's props into a layer's. `anatomy` is the tree the build would read off a render: each node renders a layer (`{ \"__ref\": \"layer:<name>\" }`), an intrinsic tag, or `Slot` (`{ \"element\": \"Slot\", \"props\": { \"name\": \"children\" } }`, where a slot prop's content lands — but a declared slot fills `root` by default, so a primitive still declares its `children` slot prop yet needs no `Slot` node or `children` entry for it, and a `Slot` node is only for landing that content in a nested layer); `children` lists sibling node keys from the `root` node, never a prop name; `text` is a fixed string; `visible` is a condition on a prop (`{ \"$state\": \"<prop>\" }`, or with `eq`); content shown in a nested layer is a route, `children: { \"type\": \"forward\", \"target\": \"label/children\" }`. `$state` appears only in `visible` and in an `element` a prop chooses, never as a prop value. A glyph is a node of its own, `{ \"element\": { \"__ref\": \"icon:<library>/<Name>\" } }`, listed in the `children` of the layer node that holds it, never a prop value. Text a prop supplies to a text layer is never a node either: declare the prop `{ \"type\": \"forward\", \"target\": \"<layer>/children\" }` and the layer shows it; a `Slot` node goes only under a layer that takes nodes. A style rule is `\"styles\": { \"*\": { \"when\": null, \"layers\": { \"root\": { \"bg\": \"surface\" } } } }`, keyed by a name, with each layer's bag under `layers`. A composed component carries its own styles: give it an unconditional (`\"*\"`) rule that lays out and surfaces it through the system's style properties — spacing, alignment and gap on the container, a background and color where it has one — rather than leaning on the bare primitives, which paint flat. Style a layer only with the style props the primitive it renders exposes, set to the values those props accept: `component/get` on the primitive lists both, so read it and choose from that rather than reaching for a CSS name or value the system has no style property for. Set `previewProps` (or `defaultProps`) so the component previews with content; a root that takes children renders empty otherwise. A style rule's layer bag is keyed by style-prop name (`fontWeight`, `color`), never by CSS property name, and each value is one of that prop's values.",
+			description: "Create a component at a new qualified `path`. For a component with nothing in it yet, one to design on the canvas before it has props or variants, use `create-blank` with only a `path` instead of authoring a minimal body here. When its complete body is known, include all layers, anatomy, props, defaults, and styles in this one operation. `data.layers` maps each stable layer name to the element it renders and must include `root` — a tag for a primitive (`{ \"layers\": { \"root\": \"div\" } }`), and for anything built on top, a ref to a primitive (`{ \"root\": { \"__ref\": \"component:Box\" }, \"label\": { \"__ref\": \"component:Text\" } }`), which is what lets the layer take that primitive's style props. A primitive exposes style props as `{ \"type\": \"styleProperty\", \"value\": { \"__ref\": \"style-property:bg\" } }` and declares `children: { \"type\": \"slot\", \"text\": true }` when it holds content — without the slot, nothing nested inside it renders. A composed component exposes a layer's props at its own top level through `forwards`, keyed by layer: `{ \"forwards\": { \"root\": \"*\" } }` passes every prop the root's element takes (so `<Button width=\"full\">` reaches the root's `width`), and a list of member refs (`[{ \"__ref\": \"component:Box#props/width\" }]`, each naming the component that declares the prop) passes only those. A prop a layer already exposes is forwarded, never redeclared in `props`; a `props` entry of `{ \"type\": \"forward\" }` is the reverse route, one of this component's props into a layer's. `anatomy` is the tree the build would read off a render: each node renders a layer (`{ \"__ref\": \"layer:<name>\" }`), an intrinsic tag, or `Slot` (`{ \"element\": \"Slot\", \"props\": { \"name\": \"children\" } }`, where a slot prop's content lands — but a declared slot fills `root` by default, so a primitive still declares its `children` slot prop yet needs no `Slot` node or `children` entry for it, and a `Slot` node is only for landing that content in a nested layer); `children` lists sibling node keys from the `root` node, never a prop name; `text` is a fixed string; `visible` is a condition on a prop (`{ \"$state\": \"<prop>\" }`, or with `eq`); content shown in a nested layer is a route, `children: { \"type\": \"forward\", \"target\": \"label/children\" }`. `$state` appears only in `visible` and in an `element` a prop chooses, never as a prop value. A glyph is a node of its own, `{ \"element\": { \"__ref\": \"icon:<library>/<Name>\" } }`, listed in the `children` of the layer node that holds it, never a prop value. Text a prop supplies to a text layer is never a node either: declare the prop `{ \"type\": \"forward\", \"target\": \"<layer>/children\" }` and the layer shows it; a `Slot` node goes only under a layer that takes nodes. A style rule is `\"styles\": { \"*\": { \"when\": null, \"layers\": { \"root\": { \"bg\": \"surface\" } } } }`, keyed by a name, with each layer's bag under `layers`. A composed component carries its own styles: give it an unconditional (`\"*\"`) rule that lays out and surfaces it through the system's style properties — spacing, alignment and gap on the container, a background and color where it has one — rather than leaning on the bare primitives, which paint flat. Style a layer only with the style props the primitive it renders exposes, set to the values those props accept: `component/get` on the primitive lists both, so read it and choose from that rather than reaching for a CSS name or value the system has no style property for. Set `previewProps` (or `defaultProps`) so the component previews with content; a root that takes children renders empty otherwise. A style rule's layer bag is keyed by style-prop name (`fontWeight`, `color`), never by CSS property name, and each value is one of that prop's values.",
 			example: ({ config }) => {
 				const path = freeExamplePath(config);
 				const composed = composedCreateExample(config, path);
@@ -1355,6 +1398,28 @@ slots: ({ config, path, member }) => {
 				};
 			}
 		},
+		/**
+		* A component with nothing in it yet, as Studio's "+" makes one. Its own op because `create`
+		* teaches the full grammar, and a model asked for a blank component authors a `children` slot and
+		* preview content from it, at which point the component is no longer blank. Decomposes into the one
+		* `create` patch the rail writes, so the changes list and undo read both gestures alike.
+		*/
+		"create-blank": {
+			input: z.object({ path: pathInput("component") }),
+			readOnly: false,
+			label: "Create blank",
+			description: "Create an empty component at a new qualified `path`, to design on the canvas first: one `div` root layer and the node that renders it, with no props, no variants, no slot, no styles and no preview content. This is exactly what Studio's \"+\" creates. Takes only `path`. Use it for \"a new component\", \"a blank component\" or \"start a component from nothing\"; `create` is for a component whose body is already known.",
+			scope: "item",
+			creates: true,
+			title: (entity) => `Create blank ${entity}`,
+			example: ({ config }) => ({ path: freeExamplePath(config) }),
+			handler: (input, config) => config.apply({
+				kind: "component",
+				operation: "create",
+				path: String(input.path),
+				data: blankComponentBody()
+			})
+		},
 		"sub-create/anatomy": { description: "Add one anatomy node (`key` + `data`) to a component. In a batch, create child nodes before a parent whose `children` or `slots` names them; each referenced node must already exist when this operation runs." },
 		"sub-create/props": { description: "Declare a prop this component owns (`key` + `data`): a `variant`, a `slot`, a `styleProperty` or `composite` on a primitive, a `forward` routing this prop into a layer's (`{ \"type\": \"forward\", \"target\": \"<layer>/<prop>\" }`), or `null` to drop a forwarded prop from the surface. A prop one of its layers already exposes — `width` on a root that renders `Box` — is not declared here; `sub-create/forwards` exposes it at the top level." },
 		"sub-create/forwards": {
@@ -1843,4 +1908,4 @@ function exampleProps(config, componentPath) {
 	return {};
 }
 //#endregion
-export { Component, canonicalWhen, forwardedNames, layerRef, ownValues, ownsItsValues, valueRef };
+export { Component, blankComponentBody, canonicalWhen, forwardedNames, layerRef, ownValues, ownsItsValues, valueRef };

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 = 20260912164927;
+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 > 20260912164927) 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 };