@yahoo/uds-create-config 5.33.0 → 5.34.1

package/dist/entities/canvas/node-gestures.js

@@ -242,15 +242,41 @@ function remove(config, input) {
 		path
 	}))];
 }
+/** The annotations on `paths`, oldest first, as a layer lists them. */
+function annotationsOn({ config, paths }) {
+	return config.list("annotation").map((note) => ({
+		...note.body,
+		path: note.path
+	})).filter((note) => paths.has(pathOf(note.target))).sort((left, right) => (left.authoredAt ?? "").localeCompare(right.authoredAt ?? "") || left.path.localeCompare(right.path));
+}
+/**
+* Each copy of a duplicated element carries copies of the annotations on it. A copy names no author: the
+* writer who duplicates is its author, and stamps it where the write lands.
+*/
 function duplicate(config, input) {
 	const place = placeOf(config, input.path, ["path"]);
 	const fresh = freshPaths(config, rootOf(input.path));
 	const subtree = subtreeOf(config, input.path);
+	const notes = annotationsOn({
+		config,
+		paths: new Set(subtree)
+	});
 	const count = input.data?.count ?? 1;
 	const patches = [];
+	const annotationPatches = [];
 	const copies = [];
 	for (let n = 0; n < count; n++) {
 		const pathFor = new Map(subtree.map((path) => [path, fresh(path.split("/").at(-1) ?? path)]));
+		for (const note of notes) annotationPatches.push({
+			kind: "annotation",
+			operation: "create",
+			path: crypto.randomUUID(),
+			data: {
+				target: ref("node", pathFor.get(pathOf(note.target))),
+				...note.layer ? { layer: note.layer } : {},
+				content: note.content
+			}
+		});
 		const remap = (entry) => {
 			const to = pathFor.get(pathOf(entry));
 			return to ? ref("node", to) : entry;
@@ -272,7 +298,7 @@ function duplicate(config, input) {
 	}
 	const list = [...place.list];
 	list.splice(place.index + 1, 0, ...copies);
-	patches.push(placeUpdate(place, list));
+	patches.push(placeUpdate(place, list), ...annotationPatches);
 	return patches;
 }
 function unwrap(config, input) {
@@ -537,7 +563,7 @@ const nodeGestureOps = {
 		input: duplicateInput,
 		readOnly: false,
 		label: "Duplicate an element",
-		description: "Copy this element and everything inside it (\"duplicate\", \"make 3 more of these\"): each copy lands right after it among its siblings, `count` of them.",
+		description: "Copy this element and everything inside it (\"duplicate\", \"make 3 more of these\"): each copy lands right after it among its siblings, `count` of them, with a copy of each annotation on the copied elements.",
 		scope: "item",
 		title: (entity) => `Duplicate ${entity}`,
 		example: () => ({

package/dist/entities/system/Component.js

@@ -12,10 +12,10 @@ import { translateLinkedStyleBags } from "./linked-style-values.js";
 import { listedIn } from "../../framework/utils/enumerated.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
 import { Package } from "./Package.js";
-import { bindPreviewGlyphs, glyphLeafOf } from "./glyph-identity.js";
+import { bindPreviewGlyphs, glyphMemberRefIn } from "./glyph-identity.js";
 import { Style, addBagKeyIssues, anatomyPropValue, bagNameEdges, bagRewriteName, bindBagTokens, collectBag, isPlainRecord, openBag, styleValue } from "./style-bag.js";
 import { storedPreview } from "../../framework/preview-store.js";
-import { glyphPropsOf, propOwner, propValueDomain, refListOf, resolveComponentProps, stylePropNumberUnit, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
+import { glyphPropsOf, glyphPropsOfBody, propOwner, propValueDomain, refListOf, resolveComponentProps, stylePropNumberUnit, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
 import { carriesContent, intoName, isValueSlot, renderBoundProp, routedPropIn, routesContent } from "../../framework/prop-surface.js";
 import { slotAnatomyPropOf, slotTargetsOf, withoutTruthyTerm } from "../../framework/render-spec.js";
 import { listSlots, namedSlots, slotHostedBy, slotOf, slotsFor } from "../../spec/slot.js";
@@ -664,7 +664,7 @@ function canonicalWhen(when) {
 function styleBagValue({ config, declaration, name = "<prop>", glyphLibraries }) {
 	const domain = valueSchemaOf(declaration, config);
 	const bound = declaration?.value;
-	if (glyphLibraries && glyphLibraries.length > 0) return z.union([glyphLeafOf({
+	if (glyphLibraries && glyphLibraries.length > 0) return z.union([glyphMemberRefIn({
 		config,
 		libraries: glyphLibraries
 	}), domain]);
@@ -1131,6 +1131,10 @@ const Preview = defineSubEntity({
 			config,
 			owner: body,
 			build: () => {
+				const glyphProps = glyphPropsOfBody({
+					config,
+					body
+				});
 				const when = {};
 				for (const [name, decl] of Object.entries(body.props ?? {})) when[name] = conditionValue(name, decl, config).optional();
 				for (const [name, decl] of Object.entries(body.states ?? {})) when[name] = stateConditionValue(decl).optional();
@@ -1138,7 +1142,8 @@ const Preview = defineSubEntity({
 					when: z.strictObject(when, { error: previewShapeError }).nullable().default(null),
 					props: z.record(z.string(), z.unknown()).transform((props) => bindPreviewGlyphs({
 						config,
-						props
+						props,
+						glyphProps
 					}))
 				}, { error: previewShapeError });
 			}

package/dist/entities/system/glyph-identity.js

@@ -175,16 +175,30 @@ function glyphOfLibrary({ library, module, leaves }) {
 }
 /**
 * The glyph form for a key that reaches a library through a forward (`icon` → `icon/name`): the
-* component or its `package:` ref, answered as the bare member name. The forwarded key stores the
-* leaf rather than a member ref, and the emitter and the renderer resolve it through the same
-* libraries (`glyphPropsOf`), taking the first that holds it. Each library's arm refuses by cause,
-* so a glyph of a library the key does not reach says so.
+* component, its `package:` ref, the member's name a surface writes, or the member ref a stored
+* config already holds, answered as the member ref `icon:<library>/<name>`. The ref names its library, so a key reaching several resolves
+* without a lookup. Each library's arm refuses by cause, so a glyph of a library the key does not
+* reach says so.
 */
-function glyphLeafOf({ config, libraries }) {
-	const arms = libraries.map((library) => glyphOfLibrary(libraryGlyphFacts({
-		config,
-		target: `icon:${library}`
-	})));
+function glyphMemberRefIn({ config, libraries }) {
+	const arms = libraries.map((library) => {
+		const facts = libraryGlyphFacts({
+			config,
+			target: `icon:${library}`
+		});
+		const toRef = (name) => ({ __ref: `icon:${library}/${name}` });
+		const memberOfRef = (value) => {
+			if (!isRef(value) || kindOf(value) !== "icon") return void 0;
+			const path = pathOf(value);
+			const name = path.slice(library.length + 1);
+			return path.startsWith(`${library}/`) && facts.leaves.includes(name) ? name : void 0;
+		};
+		return z.union([
+			z.custom((value) => memberOfRef(value) !== void 0).transform((value) => toRef(memberOfRef(value))),
+			z.string().refine((name) => facts.leaves.includes(name)).transform(toRef),
+			glyphOfLibrary(facts).transform((name) => toRef(name))
+		]);
+	});
 	if (arms.length === 1) return arms[0];
 	return z.union(arms);
 }
@@ -204,9 +218,11 @@ function glyphMemberRefOf(config, identity) {
 * way `defaultProps` are. Once an owner is known, this pass binds each such ref to
 * `icon:<library>/<name>` through the library whose package ships it, at the top level and inside a
 * stored element's props, which is the spelling the build writes when it reads `.preview()` from
-* source. A `package:` ref no library claims is another package's export and stays as written.
+* source. A member's name written under one of the owner's glyph props (`glyphProps`) binds through
+* the first of that prop's libraries holding it. A `package:` ref no library claims is another
+* package's export and stays as written.
 */
-function bindPreviewGlyphs({ config, props }) {
+function bindPreviewGlyphs({ config, props, glyphProps = {} }) {
 	const bind = (value) => {
 		if (typeof value !== "object" || value === null) return value;
 		if (Array.isArray(value)) return value.map(bind);
@@ -216,7 +232,14 @@ function bindPreviewGlyphs({ config, props }) {
 		for (const [key, member] of Object.entries(value)) out[key] = bind(member);
 		return out;
 	};
-	return bind(props);
+	const out = bind(props);
+	for (const [prop, libraries] of Object.entries(glyphProps)) {
+		const name = out[prop];
+		if (typeof name !== "string") continue;
+		const library = libraries.find((path) => memberLeaves(config, `icon:${path}`).includes(name));
+		if (library) out[prop] = { __ref: `icon:${library}/${name}` };
+	}
+	return out;
 }
 //#endregion
-export { bindPreviewGlyphs, glyphIdentityOf, glyphLeafOf, glyphMembersOf, glyphOfLibrary, glyphPackageRef, glyphPackageRefOf, isComponentType, libraryGlyphFacts, recordGlyphIdentities };
+export { bindPreviewGlyphs, glyphIdentityOf, glyphMemberRefIn, glyphMembersOf, glyphOfLibrary, glyphPackageRef, glyphPackageRefOf, isComponentType, libraryGlyphFacts, recordGlyphIdentities };

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

@@ -3,7 +3,7 @@ import { composedValueSchemas } from "./composed-values.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { isCssProperty, kebabCase } from "../../css/values.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
-import { glyphLeafOf, glyphPackageRef } from "./glyph-identity.js";
+import { glyphMemberRefIn, glyphPackageRef } from "./glyph-identity.js";
 import { glyphPropsOfBody, isCustomPropertyKey, refListOf, stylePropTokenPath } from "../../framework/projections.js";
 import { z } from "zod";
 //#region src/entities/system/style-bag.ts
@@ -59,7 +59,7 @@ const Style = defineSubEntity({
 				config,
 				body: parent
 			})[key];
-			if (libraries && libraries.length > 0) return z.union([glyphLeafOf({
+			if (libraries && libraries.length > 0) return z.union([glyphMemberRefIn({
 				config,
 				libraries
 			}), styleValue]);

package/dist/framework/Config.js

@@ -5864,7 +5864,7 @@ var Config = class Config {
 		const claimed = schemaVersionOf(stored);
 		if (claimed > 20261013201548) 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\`.`);
+		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;
 		if (isPlainObject(leftover) && Object.keys(leftover).length > 0) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" carries an \`options\` slot holding ${Object.keys(leftover).map((key) => `"${key}"`).join(", ")} after every migration ran — this config type has nowhere to keep them. Rebuild it: \`uds build\` and \`uds push\` for a system with a repo; for a system created in Create, reset the local database that holds it.`);
 		const meta = this.metaDraft();

package/dist/migrations/2.0.0/v1-artifact.js

@@ -19,18 +19,16 @@ import { parseRawCss } from "./raw-css.js";
 import { System } from "../../configs/system.js";
 //#region src/migrations/2.0.0/v1-artifact.ts
 /**
-* The v1 → config-v2 reader, for `uds migrate` and nothing else.
+* The v1 → config-v2 reader, run by the cutover schema migration in `configs/system.ts`.
 *
 * A v1 system's authoring vocabulary is gone, so its `uds.config.ts` cannot be imported — but what
-* that config DESCRIBED survives in the flat `config.json` its last build wrote. This reads that
-* artifact into a config-v2 `System`, which `uds migrate` then renders back out as v2 source.
+* that config described survives in the flat `config.json` its last build wrote. This reads that
+* artifact into a config-v2 `System`.
 *
-* **Runtime code must not come through here.** Every stored artifact is the config-v2 wire form and
-* `Config.fromJSON` is the one door to it; this exists for the one-time port of a repo that never
-* built on the new version. It is also best-effort in a way a runtime path must not be: the few old
-* shapes config-v2 doesn't model (color expressions, component `preview`) pass through or drop
-* rather than failing the load, so a config read through here is the
-* starting point for a migration, not a faithful copy of a system.
+* Runtime code doesn't come through here directly. `Config.fromJSON` is the one door to a stored
+* artifact, and it reaches this only for one stamped before config-v2. It is best-effort: the few
+* old shapes config-v2 doesn't model (color expressions, component `preview`) pass through or drop
+* rather than failing the load, so a config read through here is not a faithful copy of a system.
 */
 /**
 * Default authoring guidance seeded onto a system that declares none — the stop-gap that fills