@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/migrations/20260908171448_settings_as_kind.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Settings became a KIND.
+ *
+ * Version 1 kept a system's settings in an `options` slot on the envelope: build settings flat under
+ * `options.buildOptions`, the dev server's under `options.playgroundOptions`. This version keeps
+ * them as the one `settings` item, in sections. `up` places each stored value in its section and
+ * takes it out of the slot; a value with no section stays under `build`, where the section's schema
+ * refuses it by name rather than losing it. Options nothing reads any more are dropped.
+ *
+ * The slot leaves the wire entirely. `Config.hydrateFrom` refuses, naming them, any keys still in it
+ * after the chain has run — the only way a key survives is a `buildOptions`/`playgroundOptions`
+ * that was not an object, which no writer ever produced.
+ *
+ * A short-lived scheme stamped this same shape as a dense counter `2`; `schemaVersionOf` reads that
+ * stamp as this version, so such an artifact never enters `up`.
+ *
+ * Deletable once no stored config artifact is at version 1 or carries an `options` slot.
+ */
+import { type RawWireConfig, type SchemaMigration, SETTINGS_AS_KIND_VERSION } from '../framework/schema-version';
+export { SETTINGS_AS_KIND_VERSION };
+export declare function settingsFromOptions(json: RawWireConfig): RawWireConfig;
+export declare const settingsAsKindMigration: SchemaMigration;

package/dist/migrations/20260908171448_settings_as_kind.js

@@ -0,0 +1,89 @@
+import { isPlainObject } from "../framework/utils/field-path.js";
+import { SETTINGS_AS_KIND_VERSION } from "../framework/schema-version.js";
+import { z } from "zod";
+//#region src/migrations/20260908171448_settings_as_kind.ts
+/**
+* Settings became a KIND.
+*
+* Version 1 kept a system's settings in an `options` slot on the envelope: build settings flat under
+* `options.buildOptions`, the dev server's under `options.playgroundOptions`. This version keeps
+* them as the one `settings` item, in sections. `up` places each stored value in its section and
+* takes it out of the slot; a value with no section stays under `build`, where the section's schema
+* refuses it by name rather than losing it. Options nothing reads any more are dropped.
+*
+* The slot leaves the wire entirely. `Config.hydrateFrom` refuses, naming them, any keys still in it
+* after the chain has run — the only way a key survives is a `buildOptions`/`playgroundOptions`
+* that was not an object, which no writer ever produced.
+*
+* A short-lived scheme stamped this same shape as a dense counter `2`; `schemaVersionOf` reads that
+* stamp as this version, so such an artifact never enters `up`.
+*
+* Deletable once no stored config artifact is at version 1 or carries an `options` slot.
+*/
+/** Where each `buildOptions` field lives now, as `[section, field]`. */
+const BUILD_OPTION_HOMES = {
+	systemId: ["system", "id"],
+	registryDir: ["build", "registryDir"],
+	inputDir: ["build", "inputDir"],
+	outDir: ["build", "outDir"],
+	cssPrefix: ["css", "prefix"],
+	cssScope: ["css", "scope"],
+	preflight: ["css", "preflight"],
+	canvasPackageAliases: ["canvas", "packageAliases"]
+};
+/** Build options nothing reads any more, so a stored value has no section to land in. */
+const RETIRED_BUILD_OPTIONS = new Set(["content", "skipCssVariables"]);
+/** The envelope this reads — version 1, loose, asserting only the slot it moves. `items` is left to
+*  the hydrate guard, which refuses a non-config by name; a refusal here would name this migration. */
+const before = z.looseObject({ options: z.record(z.string(), z.unknown()).optional() });
+/** What it produces — the slot is gone unless something unplaceable stayed in it. */
+const after = z.looseObject({ options: z.record(z.string(), z.unknown()).optional() });
+function settingsFromOptions(json) {
+	if (!isPlainObject(json.options)) return json;
+	const { buildOptions, playgroundOptions, ...unplaced } = json.options;
+	const sections = {};
+	const place = (section, field, value) => {
+		if (value === void 0) return;
+		const target = sections[section] ?? {};
+		target[field] = value;
+		sections[section] = target;
+	};
+	if (isPlainObject(buildOptions)) for (const [key, value] of Object.entries(buildOptions)) {
+		if (RETIRED_BUILD_OPTIONS.has(key)) continue;
+		const [section, field] = BUILD_OPTION_HOMES[key] ?? ["build", key];
+		place(section, field, value);
+	}
+	else if (buildOptions !== void 0) unplaced.buildOptions = buildOptions;
+	if (isPlainObject(playgroundOptions)) for (const [key, value] of Object.entries(playgroundOptions)) place("playground", key, value);
+	else if (playgroundOptions !== void 0) unplaced.playgroundOptions = playgroundOptions;
+	const { options: _moved, ...rest } = json;
+	const withOptions = Object.keys(unplaced).length > 0 ? {
+		...rest,
+		options: unplaced
+	} : rest;
+	if (Object.keys(sections).length === 0) return withOptions;
+	const items = isPlainObject(json.items) ? json.items : {};
+	const existing = isPlainObject(items.settings) ? items.settings : {};
+	const item = isPlainObject(existing.settings) ? existing.settings : {};
+	return {
+		...withOptions,
+		items: {
+			...items,
+			settings: {
+				...existing,
+				settings: {
+					...item,
+					...sections
+				}
+			}
+		}
+	};
+}
+const settingsAsKindMigration = {
+	version: SETTINGS_AS_KIND_VERSION,
+	up: settingsFromOptions,
+	fromSchema: before,
+	toSchema: after
+};
+//#endregion
+export { settingsAsKindMigration };

package/dist/migrations/20260908194245_visible_state_pointer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A `visible` condition's `$state` is stored as a JSON pointer.
+ *
+ * An anatomy node's condition named its prop bare (`{ $state: "tone" }`) or slashed (`"/tone"`),
+ * and the two spellings compared as different values. The entity now stores one — slash-prefixed —
+ * and refuses a pointer with an interior slash (`resolveVisibility` reads one prop, so `/a/b` has
+ * nothing to descend into). `up` slashes every stored condition, including those inside `$or` and
+ * lists; a condition already slashed is left alone. The flat `{ prop: value }` form was never stored,
+ * only accepted at the op boundary, so nothing here compiles it.
+ *
+ * `upPatch` slashes the same field on the component patches that carry an anatomy node: a whole-body
+ * `create`/`update`/`replace` and `sub-create`/`sub-upsert`/`sub-update` on the `anatomy` field.
+ *
+ * Deletable once no stored config artifact or draft patch is at a version below this one.
+ */
+import type { RawWireConfig, SchemaMigration } from '../framework/schema-version';
+export declare const VISIBLE_STATE_POINTER_VERSION = 20260908194245;
+export declare function visibleStatePointer(json: RawWireConfig): RawWireConfig;
+export declare const visibleStatePointerMigration: SchemaMigration;

package/dist/migrations/20260908194245_visible_state_pointer.js

@@ -0,0 +1,115 @@
+import { isPlainObject } from "../framework/utils/field-path.js";
+import { z } from "zod";
+//#region src/migrations/20260908194245_visible_state_pointer.ts
+/**
+* A `visible` condition's `$state` is stored as a JSON pointer.
+*
+* An anatomy node's condition named its prop bare (`{ $state: "tone" }`) or slashed (`"/tone"`),
+* and the two spellings compared as different values. The entity now stores one — slash-prefixed —
+* and refuses a pointer with an interior slash (`resolveVisibility` reads one prop, so `/a/b` has
+* nothing to descend into). `up` slashes every stored condition, including those inside `$or` and
+* lists; a condition already slashed is left alone. The flat `{ prop: value }` form was never stored,
+* only accepted at the op boundary, so nothing here compiles it.
+*
+* `upPatch` slashes the same field on the component patches that carry an anatomy node: a whole-body
+* `create`/`update`/`replace` and `sub-create`/`sub-upsert`/`sub-update` on the `anatomy` field.
+*
+* Deletable once no stored config artifact or draft patch is at a version below this one.
+*/
+const VISIBLE_STATE_POINTER_VERSION = 20260908194245;
+function slashed(state) {
+	if (typeof state !== "string") return state;
+	return state.startsWith("/") ? state : `/${state}`;
+}
+/** One condition in json-render's grammar: a `$state` test, an `$or`, or a list of either. Hands
+*  back the input when nothing in it moves. */
+function pointerCondition(visible) {
+	if (Array.isArray(visible)) {
+		const next = visible.map(pointerCondition);
+		return next.every((item, i) => item === visible[i]) ? visible : next;
+	}
+	if (!isPlainObject(visible)) return visible;
+	if ("$or" in visible && Array.isArray(visible.$or)) {
+		const or = pointerCondition(visible.$or);
+		return or === visible.$or ? visible : {
+			...visible,
+			$or: or
+		};
+	}
+	if ("$state" in visible) {
+		const state = slashed(visible.$state);
+		return state === visible.$state ? visible : {
+			...visible,
+			$state: state
+		};
+	}
+	return visible;
+}
+function pointerNode(node) {
+	if (!isPlainObject(node) || node.visible === void 0) return node;
+	const visible = pointerCondition(node.visible);
+	return visible === node.visible ? node : {
+		...node,
+		visible
+	};
+}
+/** Maps values, handing back the input record when no value moved. */
+function mapRecord(record, map) {
+	let moved = false;
+	const out = {};
+	for (const [key, value] of Object.entries(record)) {
+		const next = map(value);
+		if (next !== value) moved = true;
+		out[key] = next;
+	}
+	return moved ? out : record;
+}
+function pointerAnatomy(anatomy) {
+	return isPlainObject(anatomy) ? mapRecord(anatomy, pointerNode) : anatomy;
+}
+function pointerComponent(body) {
+	if (!isPlainObject(body) || body.anatomy === void 0) return body;
+	const anatomy = pointerAnatomy(body.anatomy);
+	return anatomy === body.anatomy ? body : {
+		...body,
+		anatomy
+	};
+}
+function visibleStatePointer(json) {
+	const items = json.items;
+	if (!isPlainObject(items) || !isPlainObject(items.component)) return json;
+	const component = mapRecord(items.component, pointerComponent);
+	if (component === items.component) return json;
+	return {
+		...json,
+		items: {
+			...items,
+			component
+		}
+	};
+}
+const visibleStatePointerMigration = {
+	version: VISIBLE_STATE_POINTER_VERSION,
+	up: visibleStatePointer,
+	upPatch(patch) {
+		if (patch.kind !== "component" || !("data" in patch)) return patch;
+		const { operation } = patch;
+		if (operation === "create" || operation === "update" || operation === "replace") return {
+			...patch,
+			data: pointerComponent(patch.data)
+		};
+		if ((operation === "sub-create" || operation === "sub-upsert" || operation === "sub-update") && patch.field === "anatomy") return {
+			...patch,
+			data: pointerNode(patch.data)
+		};
+		return patch;
+	},
+	fromSchema: z.looseObject({}),
+	toSchema: z.looseObject({}).refine((json) => {
+		const items = json.items;
+		if (!isPlainObject(items) || !isPlainObject(items.component)) return true;
+		return mapRecord(items.component, pointerComponent) === items.component;
+	}, { message: "every stored `$state` must be a slash-prefixed pointer" })
+};
+//#endregion
+export { VISIBLE_STATE_POINTER_VERSION, visibleStatePointerMigration };

package/dist/migrations/20260909183001_icon_knockout_variants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An additive fence: three schema changes that move no stored byte.
+ *
+ * - An icon member's metadata gains an optional `knockoutVariants` list. An artifact without it
+ *   reads as before; only a source that flags its own knockouts writes one.
+ * - A layer element's `__foreign` marker arm is gone. It was an input-only shape the loader wrote
+ *   and the schema transformed to a `package:` ref on parse, so a stored artifact never held it.
+ * - Guidance `appliesTo` is typed on `GUIDANCE_LANES`, the same four values `GUIDANCE_SURFACES`
+ *   named.
+ *
+ * Identity, so a stamp below this version means "may lack `knockoutVariants`" and one at it means
+ * the field is understood — which is what lets the pull gate keep an older client from stripping it.
+ *
+ * Deletable once no stored config artifact is below this version.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const ICON_KNOCKOUT_VARIANTS_VERSION = 20260909183001;
+export declare const iconKnockoutVariantsMigration: SchemaMigration;

package/dist/migrations/20260909183001_icon_knockout_variants.js

@@ -0,0 +1,8 @@
+//#region src/migrations/20260909183001_icon_knockout_variants.ts
+const ICON_KNOCKOUT_VARIANTS_VERSION = 20260909183001;
+const iconKnockoutVariantsMigration = {
+	version: ICON_KNOCKOUT_VARIANTS_VERSION,
+	up: (json) => json
+};
+//#endregion
+export { ICON_KNOCKOUT_VARIANTS_VERSION, iconKnockoutVariantsMigration };

package/dist/migrations/20260910212453_linked_system_link_ops.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An additive fence: the `linked-system` kind gains the ops `link`, `link-plan`, `unlink`,
+ * `unlink-plan`, `break`, `break-plan` and `rows`, so the operation catalogue's fingerprint moves.
+ * No stored byte changes — every op writes the pin's existing `link` field and ordinary rows.
+ *
+ * Identity, so a stamp below this version means "does not know the link ops" and one at it means the
+ * catalogue is understood.
+ *
+ * Deletable once no stored config artifact is below this version.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const LINKED_SYSTEM_LINK_OPS_VERSION = 20260910212453;
+export declare const linkedSystemLinkOpsMigration: SchemaMigration;

package/dist/migrations/20260910212453_linked_system_link_ops.js

@@ -0,0 +1,8 @@
+//#region src/migrations/20260910212453_linked_system_link_ops.ts
+const LINKED_SYSTEM_LINK_OPS_VERSION = 20260910212453;
+const linkedSystemLinkOpsMigration = {
+	version: LINKED_SYSTEM_LINK_OPS_VERSION,
+	up: (json) => json
+};
+//#endregion
+export { LINKED_SYSTEM_LINK_OPS_VERSION, linkedSystemLinkOpsMigration };

package/dist/migrations/index.d.ts

@@ -0,0 +1,2 @@
+import { LoadV1Options, V1Artifact, V1Diagnostic, V1DiagnosticCode, V1_DIAGNOSTIC_CODES, loadV1Artifact, v1ComponentRenames } from "./2.0.0/v1-artifact.js";
+export { type LoadV1Options, type V1Artifact, type V1Diagnostic, type V1DiagnosticCode, V1_DIAGNOSTIC_CODES, loadV1Artifact, v1ComponentRenames };

package/dist/migrations/index.js

@@ -0,0 +1,2 @@
+import { V1_DIAGNOSTIC_CODES, loadV1Artifact, v1ComponentRenames } from "./2.0.0/v1-artifact.js";
+export { V1_DIAGNOSTIC_CODES, loadV1Artifact, v1ComponentRenames };

package/dist/react-native/style-keys.generated.d.ts

@@ -0,0 +1,10 @@
+//#region src/react-native/style-keys.generated.d.ts
+/**
+ * GENERATED — do not edit. `bun scripts/generate-rn-style-keys.ts` regenerates this from React
+ * Native's own StyleSheetTypes declarations (react-native@0.86.2): every key `ViewStyle`,
+ * `TextStyle` and `ImageStyle` accept, including inherited interfaces. `NativeStyleProperty`
+ * validates against this, so the native style vocabulary is React Native's, not a hand-kept list.
+ */
+declare const RN_STYLE_KEYS: readonly ["alignContent", "alignItems", "alignSelf", "aspectRatio", "backfaceVisibility", "backgroundColor", "borderBlockColor", "borderBlockEndColor", "borderBlockStartColor", "borderBottomColor", "borderBottomEndRadius", "borderBottomLeftRadius", "borderBottomRightRadius", "borderBottomStartRadius", "borderBottomWidth", "borderColor", "borderCurve", "borderEndColor", "borderEndEndRadius", "borderEndStartRadius", "borderEndWidth", "borderLeftColor", "borderLeftWidth", "borderRadius", "borderRightColor", "borderRightWidth", "borderStartColor", "borderStartEndRadius", "borderStartStartRadius", "borderStartWidth", "borderStyle", "borderTopColor", "borderTopEndRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderTopStartRadius", "borderTopWidth", "borderWidth", "bottom", "boxShadow", "boxSizing", "color", "columnGap", "cursor", "direction", "display", "elevation", "end", "experimental_backgroundImage", "experimental_backgroundPosition", "experimental_backgroundRepeat", "experimental_backgroundSize", "filter", "flex", "flexBasis", "flexDirection", "flexGrow", "flexShrink", "flexWrap", "fontFamily", "fontSize", "fontStyle", "fontVariant", "fontWeight", "gap", "height", "includeFontPadding", "inset", "insetBlock", "insetBlockEnd", "insetBlockStart", "insetInline", "insetInlineEnd", "insetInlineStart", "isolation", "justifyContent", "left", "letterSpacing", "lineHeight", "margin", "marginBlock", "marginBlockEnd", "marginBlockStart", "marginBottom", "marginEnd", "marginHorizontal", "marginInline", "marginInlineEnd", "marginInlineStart", "marginLeft", "marginRight", "marginStart", "marginTop", "marginVertical", "maxHeight", "maxWidth", "minHeight", "minWidth", "mixBlendMode", "objectFit", "opacity", "outlineColor", "outlineOffset", "outlineStyle", "outlineWidth", "overflow", "overlayColor", "padding", "paddingBlock", "paddingBlockEnd", "paddingBlockStart", "paddingBottom", "paddingEnd", "paddingHorizontal", "paddingInline", "paddingInlineEnd", "paddingInlineStart", "paddingLeft", "paddingRight", "paddingStart", "paddingTop", "paddingVertical", "pointerEvents", "position", "resizeMode", "right", "rotation", "rowGap", "scaleX", "scaleY", "shadowColor", "shadowOffset", "shadowOpacity", "shadowRadius", "start", "textAlign", "textAlignVertical", "textDecorationColor", "textDecorationLine", "textDecorationStyle", "textShadowColor", "textShadowOffset", "textShadowRadius", "textTransform", "tintColor", "top", "transform", "transformMatrix", "transformOrigin", "translateX", "translateY", "userSelect", "verticalAlign", "width", "writingDirection", "zIndex"];
+//#endregion
+export { RN_STYLE_KEYS };

package/dist/react-native/style-keys.generated.js

@@ -0,0 +1,167 @@
+//#region src/react-native/style-keys.generated.ts
+/**
+* GENERATED — do not edit. `bun scripts/generate-rn-style-keys.ts` regenerates this from React
+* Native's own StyleSheetTypes declarations (react-native@0.86.2): every key `ViewStyle`,
+* `TextStyle` and `ImageStyle` accept, including inherited interfaces. `NativeStyleProperty`
+* validates against this, so the native style vocabulary is React Native's, not a hand-kept list.
+*/
+const RN_STYLE_KEYS = [
+	"alignContent",
+	"alignItems",
+	"alignSelf",
+	"aspectRatio",
+	"backfaceVisibility",
+	"backgroundColor",
+	"borderBlockColor",
+	"borderBlockEndColor",
+	"borderBlockStartColor",
+	"borderBottomColor",
+	"borderBottomEndRadius",
+	"borderBottomLeftRadius",
+	"borderBottomRightRadius",
+	"borderBottomStartRadius",
+	"borderBottomWidth",
+	"borderColor",
+	"borderCurve",
+	"borderEndColor",
+	"borderEndEndRadius",
+	"borderEndStartRadius",
+	"borderEndWidth",
+	"borderLeftColor",
+	"borderLeftWidth",
+	"borderRadius",
+	"borderRightColor",
+	"borderRightWidth",
+	"borderStartColor",
+	"borderStartEndRadius",
+	"borderStartStartRadius",
+	"borderStartWidth",
+	"borderStyle",
+	"borderTopColor",
+	"borderTopEndRadius",
+	"borderTopLeftRadius",
+	"borderTopRightRadius",
+	"borderTopStartRadius",
+	"borderTopWidth",
+	"borderWidth",
+	"bottom",
+	"boxShadow",
+	"boxSizing",
+	"color",
+	"columnGap",
+	"cursor",
+	"direction",
+	"display",
+	"elevation",
+	"end",
+	"experimental_backgroundImage",
+	"experimental_backgroundPosition",
+	"experimental_backgroundRepeat",
+	"experimental_backgroundSize",
+	"filter",
+	"flex",
+	"flexBasis",
+	"flexDirection",
+	"flexGrow",
+	"flexShrink",
+	"flexWrap",
+	"fontFamily",
+	"fontSize",
+	"fontStyle",
+	"fontVariant",
+	"fontWeight",
+	"gap",
+	"height",
+	"includeFontPadding",
+	"inset",
+	"insetBlock",
+	"insetBlockEnd",
+	"insetBlockStart",
+	"insetInline",
+	"insetInlineEnd",
+	"insetInlineStart",
+	"isolation",
+	"justifyContent",
+	"left",
+	"letterSpacing",
+	"lineHeight",
+	"margin",
+	"marginBlock",
+	"marginBlockEnd",
+	"marginBlockStart",
+	"marginBottom",
+	"marginEnd",
+	"marginHorizontal",
+	"marginInline",
+	"marginInlineEnd",
+	"marginInlineStart",
+	"marginLeft",
+	"marginRight",
+	"marginStart",
+	"marginTop",
+	"marginVertical",
+	"maxHeight",
+	"maxWidth",
+	"minHeight",
+	"minWidth",
+	"mixBlendMode",
+	"objectFit",
+	"opacity",
+	"outlineColor",
+	"outlineOffset",
+	"outlineStyle",
+	"outlineWidth",
+	"overflow",
+	"overlayColor",
+	"padding",
+	"paddingBlock",
+	"paddingBlockEnd",
+	"paddingBlockStart",
+	"paddingBottom",
+	"paddingEnd",
+	"paddingHorizontal",
+	"paddingInline",
+	"paddingInlineEnd",
+	"paddingInlineStart",
+	"paddingLeft",
+	"paddingRight",
+	"paddingStart",
+	"paddingTop",
+	"paddingVertical",
+	"pointerEvents",
+	"position",
+	"resizeMode",
+	"right",
+	"rotation",
+	"rowGap",
+	"scaleX",
+	"scaleY",
+	"shadowColor",
+	"shadowOffset",
+	"shadowOpacity",
+	"shadowRadius",
+	"start",
+	"textAlign",
+	"textAlignVertical",
+	"textDecorationColor",
+	"textDecorationLine",
+	"textDecorationStyle",
+	"textShadowColor",
+	"textShadowOffset",
+	"textShadowRadius",
+	"textTransform",
+	"tintColor",
+	"top",
+	"transform",
+	"transformMatrix",
+	"transformOrigin",
+	"translateX",
+	"translateY",
+	"userSelect",
+	"verticalAlign",
+	"width",
+	"writingDirection",
+	"zIndex"
+];
+//#endregion
+export { RN_STYLE_KEYS };

package/dist/renderer/RendererErrorBoundary.d.ts

@@ -2,23 +2,50 @@ import React from "react";
 
 //#region src/renderer/RendererErrorBoundary.d.ts
 /**
- * Error boundary wrapped around each component's render entry. One
- * broken component renders an inline error tile but doesn't take down
- * the rest of the Spec.
+ * Error boundary wrapped around each component's render entry — the INNERMOST
+ * boundary, inside json-render's own per-element `ElementErrorBoundary`. That
+ * placement is the point: json-render's boundary latches to `null` and logs
+ * the full component stack, so a throwing component painted NOTHING (an empty
+ * preview with no visible signal) and, on surfaces that remount elements per
+ * re-render, re-threw and re-logged every cycle. Catching here instead keeps
+ * one broken component as one labeled tile while the rest of the Spec keeps
+ * rendering.
+ *
+ * The tile clears when `resetKey` changes by content. The entry passes the
+ * element's props, so a component that threw on one render — a node painted
+ * mid-stream, before the props batch that carries a required value arrived —
+ * shows a tile only until those props settle, then renders. While the props
+ * read the same it stays latched: a component that throws on the same input
+ * every render (a deliberately-broken preview) is one tile and never
+ * re-throws, which is the re-log storm this boundary exists to stop. Content
+ * rather than identity because json-render resolves a fresh props object on
+ * every render of the element.
  */
 declare class RendererErrorBoundary extends React.Component<{
   name: string;
-  children: React.ReactNode;
+  resetKey?: unknown;
+  children?: React.ReactNode;
 }, {
   error: string | null;
+  resetKey: unknown;
 }> {
   constructor(props: {
     name: string;
-    children: React.ReactNode;
+    resetKey?: unknown;
+    children?: React.ReactNode;
   });
   static getDerivedStateFromError(err: unknown): {
     error: string;
   };
+  static getDerivedStateFromProps(props: {
+    resetKey?: unknown;
+  }, state: {
+    error: string | null;
+    resetKey: unknown;
+  }): {
+    error: null;
+    resetKey: unknown;
+  } | null;
   componentDidCatch(err: unknown): void;
   render(): React.ReactNode;
 }

package/dist/renderer/RendererErrorBoundary.js

@@ -1,30 +1,79 @@
 import React from "react";
 //#region src/renderer/RendererErrorBoundary.tsx
 /**
-* Error boundary wrapped around each component's render entry. One
-* broken component renders an inline error tile but doesn't take down
-* the rest of the Spec.
+* Error boundary wrapped around each component's render entry — the INNERMOST
+* boundary, inside json-render's own per-element `ElementErrorBoundary`. That
+* placement is the point: json-render's boundary latches to `null` and logs
+* the full component stack, so a throwing component painted NOTHING (an empty
+* preview with no visible signal) and, on surfaces that remount elements per
+* re-render, re-threw and re-logged every cycle. Catching here instead keeps
+* one broken component as one labeled tile while the rest of the Spec keeps
+* rendering.
+*
+* The tile clears when `resetKey` changes by content. The entry passes the
+* element's props, so a component that threw on one render — a node painted
+* mid-stream, before the props batch that carries a required value arrived —
+* shows a tile only until those props settle, then renders. While the props
+* read the same it stays latched: a component that throws on the same input
+* every render (a deliberately-broken preview) is one tile and never
+* re-throws, which is the re-log storm this boundary exists to stop. Content
+* rather than identity because json-render resolves a fresh props object on
+* every render of the element.
 */
 var RendererErrorBoundary = class extends React.Component {
 	constructor(props) {
 		super(props);
-		this.state = { error: null };
+		this.state = {
+			error: null,
+			resetKey: props.resetKey
+		};
 	}
 	static getDerivedStateFromError(err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}
+	static getDerivedStateFromProps(props, state) {
+		if (sameKey(props.resetKey, state.resetKey)) return null;
+		return {
+			error: null,
+			resetKey: props.resetKey
+		};
+	}
 	componentDidCatch(err) {
 		console.error(`[json-render] Rendering error in <${this.props.name}>:`, err);
 	}
 	render() {
-		if (this.state.error) return React.createElement("div", { style: {
-			padding: 8,
-			fontSize: 11,
-			color: "#ef4444",
-			fontFamily: "monospace"
-		} }, `<${this.props.name}> render error`);
+		if (this.state.error) {
+			if (typeof document === "undefined") return null;
+			return React.createElement("div", {
+				"data-uds-render-error": this.props.name,
+				style: {
+					padding: 8,
+					fontSize: 11,
+					color: "#ef4444",
+					fontFamily: "monospace"
+				}
+			}, `<${this.props.name}> render error`);
+		}
 		return this.props.children;
 	}
 };
+/** Structural equality over the JSON-shaped values element props hold. Anything else compares by
+*  identity. */
+function sameKey(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((item, index) => sameKey(item, b[index]));
+	}
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	return keys.every((key) => Object.hasOwn(b, key) && sameKey(a[key], b[key]));
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
 //#endregion
 export { RendererErrorBoundary };