@yahoo/uds-create-config 5.55.0 → 5.55.1

package/dist/entities/system/Component.js

@@ -755,6 +755,17 @@ function withNone(value, declaration) {
 	if (declaration?.required === true) return value;
 	return z.union([value, z.literal(false)]);
 }
+/** Optional values build their domain on first use, not while the bag enumerates its keys. */
+function optionalBagValue(build) {
+	let schema;
+	return z.unknown().transform((input, ctx) => {
+		schema ??= build();
+		const result = schema.safeParse(input);
+		if (result.success) return result.data;
+		for (const issue of result.error.issues) ctx.addIssue({ ...issue });
+		return z.NEVER;
+	}).optional();
+}
 /** One element's bag, built. Reached only through the memo above. */
 function buildBagFor(config, layerElement) {
 	const shape = { ...stylePropShape(config) };
@@ -762,13 +773,15 @@ function buildBagFor(config, layerElement) {
 	const glyphProps = component ? glyphPropsOf(config, component) : {};
 	for (const [name, decl] of Object.entries(component ? resolveComponentProps(config, component) : {})) {
 		const forwarded = decl?.type === "forward";
-		const value = styleBagValue({
-			config,
-			declaration: decl,
-			name,
-			glyphLibraries: forwarded ? glyphProps[name] : void 0
+		shape[name] = optionalBagValue(() => {
+			const value = styleBagValue({
+				config,
+				declaration: decl,
+				name,
+				glyphLibraries: forwarded ? glyphProps[name] : void 0
+			});
+			return forwarded ? withNone(value, decl) : value;
 		});
-		shape[name] = (forwarded ? withNone(value, decl) : value).optional();
 	}
 	const declared = component ? (config.resolve("component", component)?.toJSON())?.props ?? {} : {};
 	for (const [name, decl] of Object.entries(declared)) {
@@ -819,14 +832,14 @@ function stylePropShape(config) {
 	const cached = stylePropShapes.get(config);
 	if (cached) return cached;
 	const shape = {};
-	for (const prop of config.list("style-property")) shape[prop.path] = styleBagValue({
+	for (const prop of config.list("style-property")) shape[prop.path] = optionalBagValue(() => styleBagValue({
 		config,
 		declaration: {
 			type: "styleProperty",
 			value: { __ref: `style-property:${prop.path}` }
 		},
 		name: prop.path
-	}).optional();
+	}));
 	stylePropShapes.set(config, shape);
 	return shape;
 }

package/dist/entities/system/component-module.js

@@ -55,7 +55,7 @@ function isCreatedComponent(config, path) {
 	if (isNativeConfig(config)) return false;
 	const component = Component.get(config, path);
 	if (!component || component.source !== void 0) return false;
-	const { file, export: exportName, anatomy } = component.body;
+	const { file, export: exportName, anatomy } = component;
 	return !file && !exportName && Object.keys(anatomy ?? {}).length > 0;
 }
 /**
@@ -133,7 +133,7 @@ function componentsByFile(config) {
 	if (cached) return cached;
 	const byFile = /* @__PURE__ */ new Map();
 	for (const component of Component.list(config)) {
-		const { file, export: exportName } = component.body;
+		const { file, export: exportName } = component;
 		if (!file || !exportName) continue;
 		const ref = splitRef(file.__ref);
 		if (ref.source) continue;
@@ -163,7 +163,7 @@ function componentRegistryImports(config, filePath) {
 		const byExport = /* @__PURE__ */ new Map();
 		const ambiguous = /* @__PURE__ */ new Set();
 		for (const component of byFile.get(target.path) ?? []) {
-			const { export: exportName } = component.body;
+			const { export: exportName } = component;
 			if (!exportName) continue;
 			if (byExport.has(exportName)) ambiguous.add(exportName);
 			byExport.set(exportName, {
@@ -221,7 +221,8 @@ function componentModuleBuildPlan(config, filePath) {
 		const parsed = splitRef(target);
 		if (parsed.kind !== "component" || parsed.source) return false;
 		const component = Component.get(config, parsed.path);
-		const { file, export: exportName } = component?.body ?? {};
+		const file = component?.file;
+		const exportName = component?.export;
 		if (!component || !file || !exportName) return false;
 		const owner = splitRef(file.__ref);
 		if (owner.kind !== "file" || owner.source) return false;
@@ -257,7 +258,7 @@ function componentModuleBuildPlan(config, filePath) {
 		const file = File.get(config, next);
 		if (!file?.hash) continue;
 		recordEntity(`file:${next}`);
-		const imports = file.body.imports ?? {};
+		const imports = file.imports ?? {};
 		const registryImports = new Map(componentRegistryImports(config, next).map((entry) => [entry.specifier, entry]));
 		for (const [specifier, imported] of Object.entries(imports)) {
 			const registryImport = registryImports.get(specifier);
@@ -305,7 +306,7 @@ function componentModuleSource(config, componentPathOrRef) {
 	if (isNativeConfig(config)) return void 0;
 	const component = Component.get(config, componentPathOrRef);
 	if (!component) return void 0;
-	const { file, export: exportName } = component.body;
+	const { file, export: exportName } = component;
 	if (!file || !exportName) {
 		if (!isCreatedComponent(config, component.path)) return void 0;
 		const moduleKey = createdModuleKey(config, component.path);
@@ -405,7 +406,7 @@ function cachedView(consumer, owner, slug, shadowed) {
 function linkedComponentModule(config, componentPathOrRef) {
 	const component = Component.get(config, componentPathOrRef);
 	if (!component) return void 0;
-	const { file, export: exportName } = component.body;
+	const { file, export: exportName } = component;
 	if (!file || !exportName) return void 0;
 	const asked = typeof componentPathOrRef === "string" ? componentPathOrRef : componentPathOrRef.__ref;
 	const parsed = asked.includes(":") ? splitRef(asked) : void 0;
@@ -422,8 +423,7 @@ function linkedComponentModule(config, componentPathOrRef) {
 	const moduleKey = componentModuleKey(view, filePath);
 	if (!moduleKey) return void 0;
 	const authored = Component.list(owner).find((candidate) => {
-		const fields = candidate.body;
-		return fields.export === exportName && fields.file !== void 0 && splitRef(fields.file.__ref).path === filePath;
+		return candidate.export === exportName && candidate.file !== void 0 && splitRef(candidate.file.__ref).path === filePath;
 	});
 	return {
 		source: {

package/dist/framework/Config.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(),
@@ -2916,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`.

package/dist/framework/layer-styles.js

@@ -45,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.
 *
@@ -99,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/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. */