@yahoo/uds-create-config 5.54.0 → 5.55.1

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

@@ -3,6 +3,7 @@ import { RegisteredComponentHandles, RegisteredGroupPaths, RegisteredModifiers,
 import { Authored } from "../../framework/authoring.js";
 import { StyleValue } from "./style-bag.js";
 import { ComponentSourceInput } from "./component-source-fields.js";
+import { ConditionalDefault } from "./conditional-defaults.js";
 import { VariantValues } from "./Component.js";
 import { AllHTMLAttributes, ComponentPropsWithRef, ComponentType, ElementType, JSX, ReactElement, ReactNode, Ref } from "react";
 
@@ -663,6 +664,11 @@ type ForwardedPropsOf<L extends LayerMap, F extends string> = [NonRootForward<L,
 type DefaultsOf<P extends PropMap> = Partial<DeclaredProps<P>> & {
   [key: string]: unknown;
 };
+/** {@link DefaultsOf} as `.defaultProps` takes it: a declared prop other than `as` may also default
+ *  through {@link conditionalDefault}. */
+type AuthoredDefaultsOf<P extends PropMap> = { [K in keyof DeclaredProps<P>]?: K extends 'as' ? DeclaredProps<P>[K] : DeclaredProps<P>[K] | ConditionalDefault<DeclaredProps<P>[K]> } & {
+  [key: string]: unknown;
+};
 /**
  * `T` without the keys in `K` — `Omit` that leaves an index signature alone.
  *
@@ -778,8 +784,11 @@ F extends string = never, /** The states `.states()` declared — what the rende
    *
    * `const`, so an `as` keeps its literal type: without it `{ as: 'input' }` widens to `string` and
    * there's no tag left to resolve the element's props against.
+   *
+   * A default that depends on another prop is a `conditionalDefault`:
+   * `includeScrim: conditionalDefault(true, [{ when: { modal: false }, value: false }])`.
    */
-  defaultProps<const D2 extends DefaultsOf<P>>(defaults: D2): ComponentBuilder<L, P, E, D2, F, S>;
+  defaultProps<const D2 extends AuthoredDefaultsOf<P>>(defaults: D2): ComponentBuilder<L, P, E, D2, F, S>;
   /**
    * The layers whose element props this component ALSO exposes, keyed by layer.
    *
@@ -892,4 +901,4 @@ interface DefineComponent {
 declare function definePropsFirst<const P extends PropMap<LayerPath>>(props: P & NoInfer<{ [K in keyof P]: Exact<P[K], AuthoredProp<LayerPath>> }>): ComponentBuilder<LayerMap, P>;
 declare const defineComponent: DefineComponent;
 //#endregion
-export { AsInput, AuthoredComponent, AuthoredProp, ComponentBuilder, ComponentPropsOf, DefaultsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, LinkedHandle, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StateMap, StyleRuleInput, defineComponent };
+export { AsInput, AuthoredComponent, AuthoredDefaultsOf, AuthoredProp, ComponentBuilder, ComponentPropsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, LinkedHandle, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StateMap, StyleRuleInput, defineComponent };

package/dist/entities/system/defineComponent.js

@@ -2,6 +2,7 @@ import { canonicalCondition, isRef, kindOf, memberRef, pathOf } from "../../fram
 import { glyphIdentityOf, glyphPackageRefOf, isComponentType } from "./glyph-identity.js";
 import "../../framework/preview-store.js";
 import { assertComponentSourceInput } from "./component-source-fields.js";
+import { isConditionalDefault, storedDefaults } from "./conditional-defaults.js";
 import { Component, layerRef, storedStyleRules } from "./Component.js";
 //#region src/entities/system/defineComponent.ts
 function build(body) {
@@ -145,6 +146,7 @@ function storableElement(value) {
 */
 function storableValue(value) {
 	if (value === null) return null;
+	if (isConditionalDefault(value)) throw new Error("`conditionalDefault` is a default, so it goes in `.defaultProps` or `.extend({ defaultProps })`. A preview conditions its props with `.preview({ when: [{ when, props }] })`.");
 	const type = typeof value;
 	if (type === "string" || type === "number" || type === "boolean") return value;
 	if (isComponentType(value)) return storableComponentRef(value);
@@ -388,6 +390,7 @@ function toStored(body) {
 		if (Object.keys(keyed).length === 0) delete stored.preview;
 		else stored.preview = keyed;
 	}
+	Object.assign(stored, storedDefaults(body));
 	if (body.props && typeof body.props === "object") {
 		const props = {};
 		for (const [name, decl] of Object.entries(body.props)) props[name] = storedProp(decl, body.layers);

package/dist/entities/system/link-plan.js

@@ -1,5 +1,5 @@
-import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { collectRefs, isMintedRow, ref, sourceOf, splitRef } from "../../framework/utils/refs.js";
+import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { blockedBy } from "../../framework/plan.js";
 import { excludedCondition } from "../../framework/source-integrity.js";
 import { PIN_KIND, covers, declarationOf, entriesFor, excludePaths, excludes, includePaths, narrowDeclaration } from "./link-declaration.js";

package/dist/entities/system/motion-convert.js

@@ -1,5 +1,5 @@
-import { isRef } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
+import { isRef } from "../../framework/utils/refs.js";
 import { MOTION_EASING_NAMES, bezierPoints, motionOfCssKeyword } from "./easings.js";
 import { cssEasing } from "./css-timing.js";
 import { JS_ONLY_FIELDS } from "./Motion.js";

package/dist/entities/system/motion-variants.js

@@ -1,6 +1,6 @@
-import { reject } from "../../framework/rejection.js";
-import { isRef, kindOf, pathOf } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
+import { isRef, kindOf, pathOf } from "../../framework/utils/refs.js";
+import { reject } from "../../framework/rejection.js";
 import { createSliceMemo } from "../../framework/memo.js";
 import { drawnMotionBody, drawnMotionName } from "./drawn-motion.js";
 import { webMotionBody } from "./motion-types.js";

package/dist/framework/Config.d.ts

@@ -73,7 +73,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 = 20261022184639;
+declare const SERIALIZED_CONFIG_VERSION = 20261023152030;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;

package/dist/framework/Config.js

@@ -1,8 +1,8 @@
+import { applyPathDelta, isPlainObject, namedFields, pathSegments, sectionDelta, touchedFields } from "./utils/field-path.js";
+import { MINTED, collectRefs, entityPathProblem, entityRefOf, isExtendedRef, isMintedRow, isRef, kindOf, memberOf, memberRef, pathOf, qualifyRefs, ref, rewriteRefNamespace, rewriteRefSource, rewriteRefs, routedSource, singletonRef, sourceHops, sourceOf, splitRef } from "./utils/refs.js";
 import "./config-operation-kind.js";
 import { ConfigFormatError, ConfigRejection, isConfigRejection, issuePath, refusalIssues, reject, rejectData, rejectInvalid, rejectReferrers } from "./rejection.js";
-import { MINTED, collectRefs, entityPathProblem, entityRefOf, isExtendedRef, isMintedRow, isRef, kindOf, memberOf, memberRef, pathOf, qualifyRefs, ref, rewriteRefNamespace, rewriteRefSource, rewriteRefs, routedSource, singletonRef, sourceHops, sourceOf, splitRef } from "./utils/refs.js";
 import { describePatch } from "./plan.js";
-import { applyPathDelta, isPlainObject, namedFields, pathSegments, sectionDelta, touchedFields } from "./utils/field-path.js";
 import { METADATA_KEYS, declaredField } from "./utils/field-schema.js";
 import { dataSchema, resolveInputSchema } from "./schemas.js";
 import { isComposedValue } from "../entities/system/composed-values.js";
@@ -280,6 +280,7 @@ function cachesFor(snapshot, sources) {
 	if (found) return found;
 	const bucket = {
 		sources: current,
+		entities: /* @__PURE__ */ new Map(),
 		extensions: /* @__PURE__ */ new Map(),
 		overlays: /* @__PURE__ */ new Map(),
 		lists: /* @__PURE__ */ new Map(),
@@ -438,13 +439,18 @@ function storeCollection(def, patch, next) {
 }
 /** Drop every member of a declared `orphans` collection that still points at `target` — what a
 *  delete leaves behind when a sibling member exists only to describe the one removed. */
-function dropOrphans(sub, def, target, namespace) {
+function dropOrphans(sub, def, target, namespace, keyed) {
 	if (!sub?.orphans?.length) return def;
 	let out = def;
 	for (const field of sub.orphans) {
 		const collection = out[field];
 		if (!isPlainObject(collection)) continue;
+		const keyedFields = Object.entries(keyed?.subEntities[field]?.namesMembersOf ?? {}).filter(([, names]) => names === keyed?.collection).map(([record]) => record);
 		const kept = Object.fromEntries(Object.entries(collection).filter(([, member]) => {
+			if (keyed && isPlainObject(member) && keyedFields.some((record) => {
+				const names = member[record];
+				return isPlainObject(names) && Object.hasOwn(names, keyed.key);
+			})) return false;
 			const refs = collectRefs(member);
 			if (refs.includes(target)) return false;
 			if (!namespace) return true;
@@ -2401,6 +2407,10 @@ var Config = class Config {
 			def = dropOrphans(sub, def, `${leafOf(patch.field).replace(/s$/, "")}:${refPathOf(patch, patch.key)}`, sub?.namespaces ? {
 				kind: sub.namespaces,
 				path: patch.key
+			} : void 0, patch.owner === void 0 ? {
+				collection: patch.field,
+				key: patch.key,
+				subEntities: entry.subEntities
 			} : void 0);
 		}
 		const next = snapshot.withChanges([itemChange(entry, patch.kind, patch.path, def)]);
@@ -2907,7 +2917,13 @@ var Config = class Config {
 		return new Entity(path, withComputed, [...entry.fieldKeys, ...Object.keys(computed)]);
 	}
 	resolve(kind, path) {
-		return this.resolvedIn(kind, path)?.entity;
+		const cache = this.caches.entities;
+		const key = `${kind}\u0000${path}`;
+		const cached = cache.get(key);
+		if (cached !== void 0) return cached ?? void 0;
+		const resolved = this.resolvedIn(kind, path)?.entity;
+		cache.set(key, resolved ?? null);
+		return resolved;
 	}
 	/**
 	* Whether this config holds `target`'s entity, at the path the source spells it, through `slug`.
@@ -6044,7 +6060,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 > 20261022184639) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20261023152030) 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.`);
 		const leftover = wire.options;

package/dist/framework/class-names.js

@@ -1,4 +1,5 @@
 import { isRef, kindOf, memberOf, pathOf, refLeaf, refOfKey, sourceHops, sourceOf } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { forwardsOf, rootLayerOf } from "../entities/system/element.js";
 import { createSliceMemo } from "./memo.js";
 import { moduleViewOf } from "./module-views.js";
@@ -658,9 +659,13 @@ function compositeMemberBag({ config, path, markedIn = config }) {
 function layerRoutedProps(config, path, state = {}) {
 	const component = config.resolve("component", path);
 	if (!component) return {};
-	const { layers = {}, styles = {}, defaultProps = {} } = component.toJSON();
+	const body = component.toJSON();
+	const { layers = {}, styles = {} } = body;
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const out = {};
@@ -707,9 +712,13 @@ function layerRoutedProps(config, path, state = {}) {
 * that layer through motion's factory and hands it the preset's props.
 */
 function layerJsMotionPresets(config, path, state = {}) {
-	const { styles = {}, defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
+	const { styles = {} } = body ?? {};
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const rules = Object.entries(styles);
@@ -746,9 +755,12 @@ function layerJsMotionPresets(config, path, state = {}) {
 * here, and one expanded from the config alone needs this.
 */
 function styleRuleMotionClasses(config, path, state = {}) {
-	const { defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
 	const resolved = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: state
+		}),
 		...state
 	};
 	const out = {};

package/dist/framework/default-conditions.d.ts

@@ -0,0 +1,26 @@
+//#region src/framework/default-conditions.d.ts
+/** One `defaultPropsWhen` entry as stored: the condition, and the defaults that hold under it. */
+interface StoredDefaultCondition {
+  readonly when: Record<string, unknown>;
+  readonly props: Record<string, unknown>;
+}
+/** Every `defaultPropsWhen` entry a body stores, keyed and ordered as stored. Empty for none. */
+declare function storedDefaultConditions(body: unknown): Readonly<Record<string, StoredDefaultCondition>>;
+/**
+ * The defaults that apply to a component given the props it was handed: `defaultProps`, with every
+ * `defaultPropsWhen` entry whose condition holds laid over it in stored order, so a later entry wins
+ * on the prop it sets.
+ *
+ * A condition reads a prop's given value, else its unconditional default. A prop that is itself
+ * conditionally defaulted can't be a condition (the schema refuses it), so one pass decides.
+ * Values compare by leaf, so a stored value ref and the bare name a call site writes match.
+ */
+declare function defaultsFor({
+  body,
+  given
+}: {
+  body: unknown;
+  given: Readonly<Record<string, unknown>>;
+}): Record<string, unknown>;
+//#endregion
+export { StoredDefaultCondition, defaultsFor, storedDefaultConditions };

package/dist/framework/default-conditions.js

@@ -0,0 +1,35 @@
+import { isPlainObject } from "./utils/field-path.js";
+import { refLeaf } from "./utils/refs.js";
+//#region src/framework/default-conditions.ts
+/**
+* A component's stored `defaultPropsWhen` collection, read off a body with nothing else in scope:
+* the defaults that hold only under a condition on the component's other props, beside the
+* unconditional `defaultProps` they override.
+*/
+/** Every `defaultPropsWhen` entry a body stores, keyed and ordered as stored. Empty for none. */
+function storedDefaultConditions(body) {
+	const stored = body?.defaultPropsWhen;
+	return isPlainObject(stored) ? stored : {};
+}
+/**
+* The defaults that apply to a component given the props it was handed: `defaultProps`, with every
+* `defaultPropsWhen` entry whose condition holds laid over it in stored order, so a later entry wins
+* on the prop it sets.
+*
+* A condition reads a prop's given value, else its unconditional default. A prop that is itself
+* conditionally defaulted can't be a condition (the schema refuses it), so one pass decides.
+* Values compare by leaf, so a stored value ref and the bare name a call site writes match.
+*/
+function defaultsFor({ body, given }) {
+	const defaults = body?.defaultProps ?? {};
+	const conditions = Object.values(storedDefaultConditions(body));
+	if (conditions.length === 0) return defaults;
+	const out = { ...defaults };
+	for (const { when, props } of conditions) if (Object.entries(when).every(([prop, value]) => {
+		const current = given[prop] !== void 0 ? given[prop] : defaults[prop];
+		return String(refLeaf(current)) === String(refLeaf(value));
+	})) Object.assign(out, props);
+	return out;
+}
+//#endregion
+export { defaultsFor, storedDefaultConditions };

package/dist/framework/defineEntity.js

@@ -1,5 +1,5 @@
-import { CONFIG_OPERATION_KIND } from "./config-operation-kind.js";
 import { isRef, kindOf, pathOf, ref, refSchema, refTo, sourceOf } from "./utils/refs.js";
+import { CONFIG_OPERATION_KIND } from "./config-operation-kind.js";
 import { resolveFields } from "./schemas.js";
 import { buildKind } from "./registry.js";
 import { brandGroup } from "./utils/group.js";

package/dist/framework/inline-sources.js

@@ -1,5 +1,5 @@
-import { rejectData } from "./rejection.js";
 import { MINTED, collectRefs, entityRefOf, isRef, kindOf, pathOf, ref, rewriteRefs, sourceOf } from "./utils/refs.js";
+import { rejectData } from "./rejection.js";
 import { kindBorrowable } from "./registry.js";
 //#region src/framework/inline-sources.ts
 /**

package/dist/framework/layer-styles.js

@@ -1,4 +1,5 @@
 import { isRef, refLeaf } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { authoredBag } from "./projections.js";
 import { resolveAppliedComposites } from "../entities/system/applied-composites.js";
 //#region src/framework/layer-styles.ts
@@ -44,6 +45,20 @@ function interactionHolds(state, key, value) {
 	if (on(state[key])) return true;
 	return on(state[`${key}@${value === true || value === "true" ? "root" : String(value)}`]);
 }
+const authoredBags = /* @__PURE__ */ new WeakMap();
+/** Every cell reads the same authored rules under its own coordinate. */
+function resolvedBag({ config, bag }) {
+	let bags = authoredBags.get(config);
+	if (!bags) {
+		bags = /* @__PURE__ */ new WeakMap();
+		authoredBags.set(config, bags);
+	}
+	const cached = bags.get(bag);
+	if (cached) return cached;
+	const resolved = authoredBag(config, resolveAppliedComposites(config, bag));
+	bags.set(bag, resolved);
+	return resolved;
+}
 /**
 * A bag's values as declarations, flattening any forced modifier block one specificity step up.
 *
@@ -83,9 +98,13 @@ function ruleSpecificity(when) {
 * "styled with nothing".
 */
 function layerStyles(config, path, props = {}, options = {}) {
-	const { styles = {}, defaultProps = {} } = config.resolve("component", path)?.toJSON() ?? {};
+	const body = config.resolve("component", path)?.toJSON();
+	const { styles = {} } = body ?? {};
 	const state = {
-		...defaultProps,
+		...defaultsFor({
+			body,
+			given: props
+		}),
 		...props
 	};
 	const forced = (options.forced ?? []).map((name) => name.replace(/^_/, ""));
@@ -94,7 +113,10 @@ function layerStyles(config, path, props = {}, options = {}) {
 	Object.values(styles).forEach((rule, index) => {
 		if (!ruleApplies(rule.when, state)) return;
 		for (const [layer, bag] of Object.entries(rule.layers ?? {})) collectBag({
-			bag: authoredBag(config, resolveAppliedComposites(config, bag ?? {})),
+			bag: resolvedBag({
+				config,
+				bag: bag ?? {}
+			}),
 			forced,
 			specificity: ruleSpecificity(rule.when),
 			push: (key, value, specificity) => declarations.push({

package/dist/framework/memo.d.ts

@@ -1,8 +1,8 @@
 import { Snapshot } from "./snapshot.js";
 
 //#region src/framework/memo.d.ts
-/** The structural shape a memo needs — any config-like that can produce its snapshot. Structural
- *  rather than an import of `Config`, which would be a cycle (Config memoizes through this). */
+/** An immutable config value. A changed snapshot or source requires a new value.
+ *  Structural to avoid importing `Config`, which memoizes through this module. */
 interface HasSnapshot {
   readonly snapshot: Snapshot;
   /**

package/dist/framework/memo.js

@@ -63,7 +63,9 @@ function sameSliceKeys({ before, after }) {
 function createSliceMemo({ kinds, compute }) {
 	if (kinds.length === 0) throw new Error("createSliceMemo needs at least one kind — a computation that reads nothing has nothing to key on");
 	const root = /* @__PURE__ */ new WeakMap();
+	const byConfig = /* @__PURE__ */ new WeakMap();
 	return (config) => {
+		if (byConfig.has(config)) return byConfig.get(config);
 		const keys = sliceKeys({
 			config,
 			kinds
@@ -78,9 +80,13 @@ function createSliceMemo({ kinds, compute }) {
 			level = next;
 		}
 		const cached = level.has(RESULT) ? level.get(RESULT) : MISS;
-		if (cached !== MISS) return cached;
+		if (cached !== MISS) {
+			byConfig.set(config, cached);
+			return cached;
+		}
 		const value = compute(config);
 		level.set(RESULT, value);
+		byConfig.set(config, value);
 		return value;
 	};
 }

package/dist/framework/plan.js

@@ -1,5 +1,5 @@
-import { isConfigRejection } from "./rejection.js";
 import { splitRef } from "./utils/refs.js";
+import { isConfigRejection } from "./rejection.js";
 //#region src/framework/plan.ts
 /**
 * One line for a patch, read off the patch itself: its kind, what it did, and where. The payload

package/dist/framework/projections.js

@@ -1,4 +1,5 @@
 import { declarationText, hasRefMarker, isRef, kindOf, memberOf, pathOf, ref, refLeaf, refOfKey, replaceRefMarkers, routedSource, sourceHops, sourceOf, splitRef } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { evaluateCalc, isCalc, leadingNumber } from "../entities/system/calc.js";
 import { isOklchColor, renderOklch } from "../entities/system/color.js";
 import { isComposedValue, renderComposedValue } from "../entities/system/composed-values.js";
@@ -1963,12 +1964,18 @@ function validateComponentProps(config, componentPath, props) {
 function previewDefaults(config, path, cell, options = {}) {
 	const component = config.resolve("component", path);
 	if (!component) return {};
-	const { props, defaultProps } = component.body;
+	const { props } = component.body;
 	const previewProps = unconditionalPreviewProps(component.body);
 	const base = {
 		...options.firstVariants === false ? {} : firstVariantValues(props),
 		...declaredPropDefaults(props),
-		...defaultProps,
+		...defaultsFor({
+			body: component.body,
+			given: {
+				...previewProps,
+				...cell
+			}
+		}),
 		...previewProps
 	};
 	if (!cell) return base;
@@ -2011,10 +2018,16 @@ function previewConditionalProps(config, path, cell) {
 function holdingPreviewConditions({ config, path, cell }) {
 	const component = config.resolve("component", path);
 	if (!component) return [];
-	const { defaultProps } = component.body;
+	const previewProps = unconditionalPreviewProps(component.body);
 	const state = {
-		...defaultProps,
-		...unconditionalPreviewProps(component.body),
+		...defaultsFor({
+			body: component.body,
+			given: {
+				...previewProps,
+				...cell
+			}
+		}),
+		...previewProps,
 		...cell
 	};
 	return Object.entries(keyedPreviewConditions(config, path)).flatMap(([key, condition]) => {

package/dist/framework/prop-surface.d.ts

@@ -164,6 +164,7 @@ declare function routesContent(config: Config, layers: Readonly<Record<string, u
 }): boolean;
 /**
  * Every prop a component exposes, in declaration order, projected for a control surface.
+ * Independent reads reuse the result for this immutable config.
  *
  * A `motion` prop is included as a scalar so it can't silently disappear from a surface that lists
  * what a component accepts; a caller with no editor for it can fall back to a generic one.

package/dist/framework/prop-surface.js

@@ -277,13 +277,25 @@ function slotProp(config, componentPath, name, decl) {
 		...routedKind === "composite" ? { compositeName: refPath(routed?.value) } : {}
 	};
 }
+const surfaces = /* @__PURE__ */ new WeakMap();
 /**
 * Every prop a component exposes, in declaration order, projected for a control surface.
+* Independent reads reuse the result for this immutable config.
 *
 * A `motion` prop is included as a scalar so it can't silently disappear from a surface that lists
 * what a component accepts; a caller with no editor for it can fall back to a generic one.
 */
 function surfaceProps(config, componentPath, seen = /* @__PURE__ */ new Set()) {
+	let cache;
+	if (seen.size === 0) {
+		cache = surfaces.get(config);
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			surfaces.set(config, cache);
+		}
+		const cached = cache.get(componentPath);
+		if (cached) return cached;
+	}
 	const declared = resolveComponentProps(config, componentPath);
 	const layers = (Component.get(config, componentPath)?.toJSON())?.layers;
 	const props = [];
@@ -346,6 +358,7 @@ function surfaceProps(config, componentPath, seen = /* @__PURE__ */ new Set()) {
 			required
 		}, when));
 	}
+	cache?.set(componentPath, props);
 	return props;
 }
 /**

package/dist/framework/render-spec.d.ts

@@ -206,22 +206,9 @@ declare function componentSpec(config: Config, path: string): ComponentSpec;
  */
 declare function previewSpec(config: Config, path: string): RenderSpec | undefined;
 interface ExpandOptions {
-  /**
-   * The spec `type`s the renderer already has a component for — in practice the keys of the
-   * codegen-emitted registry.
-   *
-   * A component in this set is LEFT NAMED, deliberately: its emitted module is the real thing, with
-   * whatever its render closes over (a hook, a context, an event handler) intact, and re-deriving it
-   * from data would be a worse copy of something that already exists. Expansion is for what the
-   * registry CAN'T name — which is exactly a component whose structure is data and whose module was
-   * never built.
-   *
-   * Omitted, everything the config describes expands, which is what a test wants and what a caller
-   * with no registry to consult gets.
-   *
-   * Only `has` is asked, so a caller can answer from its registry directly instead of copying every
-   * key into a `Set` first.
-   */
+  /** Membership lookup for types the renderer can draw. A Set or a registry-backed `has` works.
+   *  Recognized components keep their compiled modules, including hooks and handlers.
+   *  Omitted, everything the config describes expands. */
   readonly rendered?: Pick<ReadonlySet<string>, 'has'>;
   /** The functions `$computed` values call. Absent, a computed value stays on the element for the
    *  renderer, and a node repeated over a computed list emits once. */

package/dist/framework/render-spec.js

@@ -1,4 +1,5 @@
 import { isRef, kindOf, memberOf, pathOf, ref, refLeaf, splitRef } from "./utils/refs.js";
+import { defaultsFor } from "./default-conditions.js";
 import { renderedElement } from "../entities/system/element.js";
 import { createSliceMemo } from "./memo.js";
 import { componentStateDefaults, componentStates } from "./component-states.js";
@@ -1264,9 +1265,16 @@ function expandInstance(sink, path, instanceProps, content, hint, instanceSlots)
 	for (const [from, fills] of Object.entries(instanceSlots ?? {})) if (fills.length > 0 && instanceProps[from] === void 0) filled[from] = true;
 	const declaredDefaults = declaredPropDefaults(body.props);
 	const pins = instanceProps["__udsForceStates"] ?? {};
+	const defaults = defaultsFor({
+		body,
+		given: {
+			...filled,
+			...instanceProps
+		}
+	});
 	const state = {
 		...declaredDefaults,
-		...body.defaultProps,
+		...defaults,
 		...componentStateDefaults(config, path),
 		...filled,
 		...instanceProps,
@@ -1283,7 +1291,7 @@ function expandInstance(sink, path, instanceProps, content, hint, instanceSlots)
 	const forwardsClassName = [...valueRoutes.values()].some((routes) => routes.some((route) => route.from === "className"));
 	const supplied = {
 		...declaredDefaults,
-		...body.defaultProps ?? {},
+		...defaults,
 		...instanceProps
 	};
 	const stateNames = new Set(componentStates(config, path).map(({ name }) => name));

package/dist/framework/schema-version.d.ts

@@ -15,7 +15,7 @@ import { Patch, SerializedConfig } from "./Config.js";
  * sets this constant to its own older timestamp; the merge ref then carries a registered migration
  * newer than the constant, and the assertion fails until the author re-mints.
  */
-declare const CURRENT_SCHEMA_VERSION = 20261022184639;
+declare const CURRENT_SCHEMA_VERSION = 20261023152030;
 /** What the walkers need to see of an envelope — loose on purpose, so a typed `SerializedConfig`
  *  and a raw old-shape record both flow in without casts. */
 interface VersionStamped {

package/dist/framework/schema-version.js

@@ -13,7 +13,7 @@ import { ConfigFormatError } from "./rejection.js";
 * sets this constant to its own older timestamp; the merge ref then carries a registered migration
 * newer than the constant, and the assertion fails until the author re-mints.
 */
-const CURRENT_SCHEMA_VERSION = 20261022184639;
+const CURRENT_SCHEMA_VERSION = 20261023152030;
 /** The mint that moved `options` into the `settings` kind — restated here, rather than imported
 *  from the migration that owns it, because that migration imports this module. */
 const SETTINGS_AS_KIND_VERSION = 20260908171448;
@@ -45,7 +45,7 @@ function registerSchemaMigrations(...migrations) {
 	for (const migration of migrations) {
 		if (migration.version !== 1 && !isMintTimestamp(migration.version)) throw new Error(`Schema migration version ${migration.version} is not a mint timestamp — mint one with \`date +%Y%m%d%H%M%S\`, like a supabase migration.`);
 		if (REGISTERED.has(migration.version)) throw new Error(`A schema migration at version ${migration.version} is already registered.`);
-		if (migration.version > 20261022184639) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
+		if (migration.version > 20261023152030) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
 		REGISTERED.set(migration.version, migration);
 	}
 }
@@ -102,7 +102,7 @@ function pendingFor(version, target, options) {
 * Already-current input passes through untouched — same reference, so hot paths pay nothing.
 */
 function upgradeSerializedConfig(json, options) {
-	const target = options?.target ?? 20261022184639;
+	const target = options?.target ?? 20261023152030;
 	const version = detectedWireVersion(json);
 	if (version > target) throw new SchemaVersionTooNew(version, target);
 	const raw = json;
@@ -160,7 +160,7 @@ function upgradedSources(json, options) {
 * meaning under the current schema and replay skips it — reported by the caller, not swallowed here.
 */
 function upgradePatch(patch, writtenAt, options) {
-	const target = options?.target ?? 20261022184639;
+	const target = options?.target ?? 20261023152030;
 	if (writtenAt > target) throw new SchemaVersionTooNew(writtenAt, target);
 	let current = patch;
 	for (const migration of pendingFor(writtenAt, target, options)) {
@@ -179,7 +179,7 @@ function upgradePatch(patch, writtenAt, options) {
 * stamp would cause.
 */
 function upgradeDraftEntries(draft, options) {
-	const target = options?.target ?? 20261022184639;
+	const target = options?.target ?? 20261023152030;
 	const entries = [];
 	const held = [];
 	const retired = [];

package/dist/framework/schemas.js

@@ -1,8 +1,8 @@
-import { reject } from "./rejection.js";
+import { sectionDelta } from "./utils/field-path.js";
 import { ref } from "./utils/refs.js";
+import { reject } from "./rejection.js";
 import { planDelete, planRename } from "./plan.js";
 import { compileSchema } from "./utils/compiled-schema.js";
-import { sectionDelta } from "./utils/field-path.js";
 import { deriveCreateSchema, deriveMemberUpdateSchema, deriveUpdateSchema } from "./utils/field-schema.js";
 import { z } from "zod";
 //#region src/framework/schemas.ts

package/dist/framework/source-integrity.js

@@ -1,5 +1,5 @@
-import { collectRefs, isExtendedRef, isRef, kindOf, memberOf, pathOf, sourceOf, splitRef } from "./utils/refs.js";
 import { isPlainObject, setAtPath } from "./utils/field-path.js";
+import { collectRefs, isExtendedRef, isRef, kindOf, memberOf, pathOf, sourceOf, splitRef } from "./utils/refs.js";
 import { isComposedValue } from "../entities/system/composed-values.js";
 import { modifierCategory } from "../entities/system/modifier-axis.js";
 //#region src/framework/source-integrity.ts