@yahoo/uds-create-config 4.27.0 → 4.28.0

package/dist/configs/system.js

@@ -41,6 +41,7 @@ import { transitionTokenValueMigration } from "../migrations/20260923144958_tran
 import { renderTokenRefsMigration } from "../migrations/20260923160425_render_token_refs.js";
 import { globalStyleDerivedColorsMigration } from "../migrations/20260923163604_global_style_derived_colors.js";
 import { slotCodeFormsMigration } from "../migrations/20260924044539_slot_code_forms.js";
+import { canvasRoleSlotMigration } from "../migrations/20260925143319_canvas_role_slot.js";
 //#region src/configs/system.ts
 /**
 * `System` — the design-system config TYPE. Declares the exact kinds a design system owns (tokens,
@@ -102,5 +103,6 @@ if (!registeredSchemaMigrations().has(20260923144958)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20260923160425)) registerSchemaMigrations(renderTokenRefsMigration);
 if (!registeredSchemaMigrations().has(20260923163604)) registerSchemaMigrations(globalStyleDerivedColorsMigration);
 if (!registeredSchemaMigrations().has(20260924044539)) registerSchemaMigrations(slotCodeFormsMigration);
+if (!registeredSchemaMigrations().has(20260925143319)) registerSchemaMigrations(canvasRoleSlotMigration);
 //#endregion
 export { System };

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

@@ -3,19 +3,14 @@ import { z } from "zod";
 
 //#region src/entities/system/CanvasRole.d.ts
 /**
- * The roles a canvas has a tool for — the vocabulary a design system fills in.
+ * The roles a canvas has a tool for, the vocabulary a design system fills in. A role a config leaves
+ * unregistered has no entries, and its tool is disabled rather than falling back to a guess; what
+ * fills a role is whichever component the config points at, never a name the editor chose.
  *
- * This is the set of tools an editor offers, and each one is a SLOT: a role a config leaves
- * unregistered has no entries, and its tool is disabled rather than falling back to a guess. So
- * naming a role here offers the slot without asserting anything fills it, and what fills it is
- * never a name the editor chose — it is whichever component the config pointed at.
- *
- * The names live here, with the entity, because the entity is what they are names OF. They were
- * previously kept in `@yahoo/uds-create-platform-types` as a hand-maintained copy, annotated as
- * one ("mirrors `@yahoo/uds-create-config`'s `CanvasRole` union without importing it") — a second
- * source of truth wearing a comment admitting it.
+ * `slot` is the one role no toolbar draws with. Its entries are the host layers a component's new
+ * slot property can start as, and an entry's `defaultProps` are the props that layer starts with.
  */
-declare const CANVAS_ROLES: readonly ["frame", "text", "image", "icon"];
+declare const CANVAS_ROLES: readonly ["frame", "text", "image", "icon", "slot"];
 type CanvasRoleName = (typeof CANVAS_ROLES)[number];
 declare const CanvasRole: EntityClass<z.ZodObject<{
   entries: z.ZodArray<z.ZodObject<{

package/dist/entities/system/CanvasRole.js

@@ -15,23 +15,19 @@ import { z } from "zod";
 *   });
 */
 /**
-* The roles a canvas has a tool for — the vocabulary a design system fills in.
+* The roles a canvas has a tool for, the vocabulary a design system fills in. A role a config leaves
+* unregistered has no entries, and its tool is disabled rather than falling back to a guess; what
+* fills a role is whichever component the config points at, never a name the editor chose.
 *
-* This is the set of tools an editor offers, and each one is a SLOT: a role a config leaves
-* unregistered has no entries, and its tool is disabled rather than falling back to a guess. So
-* naming a role here offers the slot without asserting anything fills it, and what fills it is
-* never a name the editor chose — it is whichever component the config pointed at.
-*
-* The names live here, with the entity, because the entity is what they are names OF. They were
-* previously kept in `@yahoo/uds-create-platform-types` as a hand-maintained copy, annotated as
-* one ("mirrors `@yahoo/uds-create-config`'s `CanvasRole` union without importing it") — a second
-* source of truth wearing a comment admitting it.
+* `slot` is the one role no toolbar draws with. Its entries are the host layers a component's new
+* slot property can start as, and an entry's `defaultProps` are the props that layer starts with.
 */
 const CANVAS_ROLES = [
 	"frame",
 	"text",
 	"image",
-	"icon"
+	"icon",
+	"slot"
 ];
 const CanvasRole = defineEntity({
 	kind: "canvas-role",

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

package/dist/framework/Config.js

@@ -4883,7 +4883,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 > 20260924044539) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20260925143319) 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/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 = 20260924044539;
+declare const CURRENT_SCHEMA_VERSION = 20260925143319;
 /** 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 = 20260924044539;
+const CURRENT_SCHEMA_VERSION = 20260925143319;
 /** 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 > 20260924044539) 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 > 20260925143319) 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 ?? 20260924044539;
+	const target = options?.target ?? 20260925143319;
 	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 ?? 20260924044539;
+	const target = options?.target ?? 20260925143319;
 	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 ?? 20260924044539;
+	const target = options?.target ?? 20260925143319;
 	const entries = [];
 	const held = [];
 	const retired = [];

package/dist/migrations/20260925143319_canvas_role_slot.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An additive fence: `slot` joins the canvas roles, naming the host layer a new slot property starts
+ * as. No stored byte moves.
+ *
+ * Identity, so a stamp below this version means "may lack these fields" and one at it means they
+ * are understood, which is what lets the pull gate keep an older client from stripping them.
+ *
+ * Deletable once no stored config artifact is below this version.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const CANVAS_ROLE_SLOT_VERSION = 20260925143319;
+export declare const canvasRoleSlotMigration: SchemaMigration;

package/dist/migrations/20260925143319_canvas_role_slot.js

@@ -0,0 +1,8 @@
+//#region src/migrations/20260925143319_canvas_role_slot.ts
+const CANVAS_ROLE_SLOT_VERSION = 20260925143319;
+const canvasRoleSlotMigration = {
+	version: CANVAS_ROLE_SLOT_VERSION,
+	up: (json) => json
+};
+//#endregion
+export { CANVAS_ROLE_SLOT_VERSION, canvasRoleSlotMigration };

package/dist/spec/instance.d.ts

@@ -38,7 +38,8 @@ declare class Instance {
   get slots(): readonly InstanceSlot[];
   /** The slot a prop names, or `undefined` when the prop is no slot. */
   slot(prop: string): InstanceSlot | undefined;
-  /** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. */
+  /** The slot whose content lands in `layer`, or `undefined` when the layer hosts none; a slot on
+   *  the root is hosted by no layer, as {@link slotHostedBy} says. */
   slotHostedBy(layer: string): InstanceSlot | undefined;
   /** The slot holding the element `childKey`, or `undefined` when it holds none of this instance's. */
   slotHolding(childKey: string): InstanceSlot | undefined;
@@ -58,8 +59,8 @@ declare function instanceAt({
 }): Instance | undefined;
 /**
  * The instance and slot holding the element `childKey`, or `undefined` when no instance in the spec
- * holds it in a slot. A container's children are its children, not a slot's content: a component
- * that takes children on its root lists no `children` slot, so its children resolve to nothing here.
+ * holds it in a slot. A component that takes children on its root holds them in its `children`
+ * slot, whose `onRoot` says the slot is no level of its own.
  */
 declare function instanceHolding({
   config,

package/dist/spec/instance.js

@@ -37,9 +37,10 @@ var Instance = class {
 	slot(prop) {
 		return this.slots.find((entry) => entry.slot.from === prop);
 	}
-	/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. */
+	/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none; a slot on
+	*  the root is hosted by no layer, as {@link slotHostedBy} says. */
 	slotHostedBy(layer) {
-		return this.slots.find((entry) => entry.slot.layer === layer);
+		return this.slots.find((entry) => entry.slot.layer === layer && !entry.slot.onRoot);
 	}
 	/** The slot holding the element `childKey`, or `undefined` when it holds none of this instance's. */
 	slotHolding(childKey) {
@@ -58,8 +59,8 @@ function instanceAt({ config, spec, elementKey }) {
 }
 /**
 * The instance and slot holding the element `childKey`, or `undefined` when no instance in the spec
-* holds it in a slot. A container's children are its children, not a slot's content: a component
-* that takes children on its root lists no `children` slot, so its children resolve to nothing here.
+* holds it in a slot. A component that takes children on its root holds them in its `children`
+* slot, whose `onRoot` says the slot is no level of its own.
 */
 function instanceHolding({ config, spec, childKey }) {
 	if (!spec) return void 0;

package/dist/spec/slot.d.ts

@@ -26,8 +26,11 @@ declare class Slot implements SlotTarget {
   readonly accepts: readonly string[];
   /** Built by {@link listSlots}; a surface reaches one through `Component.slots` or `Component.slot`. */
   constructor(config: Config, component: string, facts: SlotFacts);
-  /** Whether this is the component's `children`, positioned inside one of its layers. */
+  /** Whether this is the component's `children`. */
   get isChildren(): boolean;
+  /** Whether the content lands on the component's root layer, so an instance holds it directly
+   *  rather than in a layer of its own. */
+  get onRoot(): boolean;
   /**
    * Whether the slot takes an element: anything when it accepts nothing in particular, else an
    * element whose ref one of the accepted refs names, exactly or as a member of a group the ref
@@ -162,10 +165,9 @@ declare class Slot implements SlotTarget {
   private writeSource;
 }
 /**
- * Every slot of a component that content can be placed in: its named node slots, and its `children`
- * when a layer of several positions them. A text slot is typed in place rather than filled, so it is
- * not one; nor is `children` landing on the root, which is the open hole every container has. The
- * same array comes back for the same config.
+ * Every slot of a component that content can be placed in, `children` included wherever it lands.
+ * A text slot is typed in place rather than filled, so it is not one. The same array comes back for
+ * the same config.
  */
 declare function listSlots({
   config,
@@ -192,7 +194,8 @@ declare function slotOf({
   path: string;
   slot: string;
 }): Slot | undefined;
-/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. */
+/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. A root
+ *  layer stands for the instance itself, so a slot on the root is listed but hosted by no layer. */
 declare function slotHostedBy({
   config,
   path,

package/dist/spec/slot.js

@@ -47,10 +47,16 @@ var Slot = class {
 		this.into = facts.into;
 		this.accepts = facts.accepts;
 	}
-	/** Whether this is the component's `children`, positioned inside one of its layers. */
+	/** Whether this is the component's `children`. */
 	get isChildren() {
 		return this.from === "children";
 	}
+	/** Whether the content lands on the component's root layer, so an instance holds it directly
+	*  rather than in a layer of its own. */
+	get onRoot() {
+		const layers = (this.config.resolve("component", this.component)?.body)?.layers;
+		return layers !== void 0 && rootLayerOf(layers)[0] === this.layer;
+	}
 	/**
 	* Whether the slot takes an element: anything when it accepts nothing in particular, else an
 	* element whose ref one of the accepted refs names, exactly or as a member of a group the ref
@@ -282,10 +288,9 @@ var Slot = class {
 	}
 };
 /**
-* Every slot of a component that content can be placed in: its named node slots, and its `children`
-* when a layer of several positions them. A text slot is typed in place rather than filled, so it is
-* not one; nor is `children` landing on the root, which is the open hole every container has. The
-* same array comes back for the same config.
+* Every slot of a component that content can be placed in, `children` included wherever it lands.
+* A text slot is typed in place rather than filled, so it is not one. The same array comes back for
+* the same config.
 */
 function listSlots({ config, path }) {
 	let byPath = listsByConfig.get(config);
@@ -313,12 +318,13 @@ function slotOf({ config, path, slot }) {
 		path
 	}).find((entry) => entry.from === slot);
 }
-/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. */
+/** The slot whose content lands in `layer`, or `undefined` when the layer hosts none. A root
+*  layer stands for the instance itself, so a slot on the root is listed but hosted by no layer. */
 function slotHostedBy({ config, path, layer }) {
 	return listSlots({
 		config,
 		path
-	}).find((entry) => entry.layer === layer);
+	}).find((entry) => entry.layer === layer && !entry.onRoot);
 }
 /** A list stored back the way content is authored: one element bare, several as the list. */
 function storedContent(list) {
@@ -483,13 +489,10 @@ function slotFacts(config, path) {
 function factsOfBody({ config, body, routes }) {
 	const props = body.props;
 	const layers = body.layers;
-	const fillable = routes.filter((route) => {
+	return routes.filter((route) => {
 		if ((props?.[route.from])?.text === true) return false;
 		return !routesToText(config, layers, route);
-	});
-	const root = layers ? rootLayerOf(layers)[0] : void 0;
-	const positionedChildren = layers !== void 0 && Object.keys(layers).length >= 2;
-	return fillable.filter((route) => route.from !== "children" || positionedChildren && route.layer !== root).map((route) => ({
+	}).map((route) => ({
 		...route,
 		accepts: acceptsOf({
 			config,