@yahoo/uds-create-cli 5.65.0 → 5.66.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-cli",
-  "version": "5.65.0",
+  "version": "5.66.1",
   "publishConfig": {
     "access": "public"
   },
@@ -31,10 +31,10 @@
     "@modelcontextprotocol/sdk": "^1.32.2",
     "@orpc/client": "^1.13.9",
     "@orpc/contract": "^1.13.9",
-    "@yahoo/uds-create-config": "5.65.0",
-    "@yahoo/uds-create-loader": "5.65.0",
-    "@yahoo/uds-create-types": "5.65.0",
-    "@yahoo/uds-create-utils": "5.65.0",
+    "@yahoo/uds-create-config": "5.66.1",
+    "@yahoo/uds-create-loader": "5.66.1",
+    "@yahoo/uds-create-types": "5.66.1",
+    "@yahoo/uds-create-utils": "5.66.1",
     "esbuild": "^0.27.4",
     "ts-morph": "^27.0.2",
     "get-tsconfig": "^4.10.0",
@@ -51,11 +51,11 @@
     "lodash": "^4.17.23",
     "prettier": "^3.8.1"
   },
-  "udsSchemaVersion": 20261027205147,
+  "udsSchemaVersion": 20261030134149,
   "optionalDependencies": {
-    "@yahoo/uds-create-cli-darwin-arm64": "5.65.0",
-    "@yahoo/uds-create-cli-darwin-x64": "5.65.0",
-    "@yahoo/uds-create-cli-linux-arm64": "5.65.0",
-    "@yahoo/uds-create-cli-linux-x64": "5.65.0"
+    "@yahoo/uds-create-cli-darwin-arm64": "5.66.1",
+    "@yahoo/uds-create-cli-darwin-x64": "5.66.1",
+    "@yahoo/uds-create-cli-linux-arm64": "5.66.1",
+    "@yahoo/uds-create-cli-linux-x64": "5.66.1"
   }
 }

package/subprocess/transform-runner.mjs

@@ -78898,20 +78898,20 @@ function expandMemberEntries(config2, target2, opts) {
       path: qualify(path2)
     }];
   }
-  const leafOf6 = (memberPath) => memberPath.startsWith(`${path2}/`) ? memberPath.slice(path2.length + 1) : memberPath;
+  const leafOf7 = (memberPath) => memberPath.startsWith(`${path2}/`) ? memberPath.slice(path2.length + 1) : memberPath;
   const theirs = owner.members(kind, path2);
   if (source === void 0) return theirs.filter((member) => offered(owner, member.path)).map((member) => ({
-    leaf: leafOf6(member.path),
+    leaf: leafOf7(member.path),
     path: member.path
   }));
   const ours = config2.members(kind, path2);
   const held = new Set(ours.map((member) => member.path));
   const covered = new Set(theirs.map((member) => member.path));
   return [...theirs.filter((member) => offered(held.has(member.path) ? config2 : owner, member.path)).map((member) => ({
-    leaf: leafOf6(member.path),
+    leaf: leafOf7(member.path),
     path: held.has(member.path) ? member.path : qualify(member.path)
   })), ...ours.filter((member) => !covered.has(member.path) && offered(config2, member.path)).map((member) => ({
-    leaf: leafOf6(member.path),
+    leaf: leafOf7(member.path),
     path: member.path
   }))];
 }
@@ -83406,6 +83406,224 @@ function instanceAt({ config: config2, spec: spec2, elementKey }) {
   return new Instance(config2, elementKey, component.path, element2);
 }
 
+// ../config/dist/framework/config-op.js
+function editOp(edit) {
+  if ("op" in edit && typeof edit.op === "object" && edit.op !== null) {
+    const { op, id } = edit;
+    return {
+      op,
+      id
+    };
+  }
+  return { op: edit };
+}
+function opVerb(op) {
+  return op.field === void 0 ? op.operation : `${op.operation}/${op.field}`;
+}
+function addressOf(op) {
+  return `${op.kind}/${opVerb(op)}`;
+}
+function inputOf(op) {
+  const { kind: _kind, operation: _operation, field: _field, ...input2 } = op;
+  return input2;
+}
+function opOf({ kind, verb, input: input2 = {} }) {
+  const slash = verb.indexOf("/");
+  if (slash === -1) return {
+    ...input2,
+    kind,
+    operation: verb
+  };
+  return {
+    ...input2,
+    kind,
+    operation: verb.slice(0, slash),
+    field: verb.slice(slash + 1)
+  };
+}
+
+// ../config/dist/spec/rewrite-refs.js
+function nestedBag(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function modifierBlock(config2, key2, value, renames) {
+  if (!key2.startsWith("_")) return void 0;
+  const leaf = key2.slice(1);
+  return config2.resolve("modifier", leaf) !== void 0 || renames.some((rename) => rename.kind === "modifier" && (leafOf2(rename.from) === leaf || leafOf2(rename.to) === leaf)) ? nestedBag(value) : void 0;
+}
+var leafOf2 = (path2) => path2.slice(path2.lastIndexOf("/") + 1);
+function layerComponent(config2, component, layer) {
+  const element2 = Component.get(config2, component)?.layers?.[layer];
+  return isRef2(element2) ? pathOf2(element2.__ref) : void 0;
+}
+
+// ../config/dist/spec/prop-mapping.js
+var propMappingRuleSchema = external_exports.object({
+  when: external_exports.record(external_exports.string(), external_exports.union([
+    external_exports.string(),
+    external_exports.number(),
+    external_exports.boolean()
+  ])).describe('The stored values an instance must hold for the rule to apply, every one of them: { "variant": "brand-secondary" }.'),
+  set: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe('The props to write: { "color": "brand", "prominence": "outline" }.'),
+  unset: external_exports.array(external_exports.string()).optional().describe("The props to remove. A prop the rule matches on stays unless it is named here, so a removed prop has to be.")
+});
+var propMappingRulesSchema = external_exports.array(propMappingRuleSchema).min(1).describe("Every rule whose `when` matches an instance as stored applies to it, so separate props are mapped by separate rules, and a combination by one rule naming both.");
+function valueRefusal(config2, component, prop, value) {
+  if (typeof value !== "string" || value.startsWith("[")) return void 0;
+  if (prop.kind === "variant" || prop.kind === "slot") return prop.values && !prop.values.includes(value) ? `"${value}", which isn't one of its values (${prop.values.join(", ")})` : void 0;
+  const declaration = resolveComponentProps(config2, component)[prop.name];
+  const domain2 = declaration ? propValueDomain(config2, declaration) : null;
+  return domain2 && !domain2.accepts(value) ? `"${value}", which isn't one of its values (${domain2.leaves.slice(0, 12).join(", ")}${domain2.leaves.length > 12 ? ", \u2026" : ""})` : void 0;
+}
+function propMappingErrors(config2, mapping) {
+  if (!config2.resolve("component", mapping.component)) return [`No component "${mapping.component}"`];
+  const errors = [];
+  mapping.rules.forEach((rule, i) => {
+    if (Object.keys(rule.when).length === 0) errors.push(`Rule ${i + 1} matches every instance: name what it matches in \`when\``);
+    for (const [name, value] of Object.entries(rule.set ?? {})) {
+      const prop = surfaceProp(config2, mapping.component, name);
+      if (!prop) {
+        errors.push(`Rule ${i + 1} sets "${name}", which ${mapping.component} doesn't have`);
+        continue;
+      }
+      const refusal2 = valueRefusal(config2, mapping.component, prop, value);
+      if (refusal2) errors.push(`Rule ${i + 1} sets ${name} to ${refusal2}`);
+    }
+  });
+  return errors;
+}
+function mapBag(bag, rules) {
+  const matched = rules.filter((rule) => Object.entries(rule.when).every(([name, value]) => name in bag && bag[name] === value));
+  if (matched.length === 0) return { kind: "same" };
+  const writes = /* @__PURE__ */ new Map();
+  const removes = /* @__PURE__ */ new Set();
+  const disagreed = /* @__PURE__ */ new Set();
+  for (const rule of matched) {
+    for (const [name, value] of Object.entries(rule.set ?? {})) {
+      if (writes.has(name) && writes.get(name) !== value) disagreed.add(name);
+      writes.set(name, value);
+    }
+    for (const name of rule.unset ?? []) removes.add(name);
+  }
+  if (disagreed.size > 0) return {
+    kind: "conflict",
+    props: [...disagreed]
+  };
+  const next = {};
+  for (const [name, value] of Object.entries(bag)) if (writes.has(name)) {
+    next[name] = writes.get(name);
+    writes.delete(name);
+  } else if (!removes.has(name)) next[name] = value;
+  for (const [name, value] of writes) next[name] = value;
+  return Object.keys(next).length === Object.keys(bag).length && Object.entries(next).every(([name, value]) => bag[name] === value) ? { kind: "same" } : {
+    kind: "changed",
+    bag: next
+  };
+}
+function mapProps(walk, component, props, at) {
+  let next;
+  if (component === walk.mapping.component) {
+    const outcome2 = mapBag(props, walk.mapping.rules);
+    if (outcome2.kind === "conflict") walk.conflicts.push({
+      element: walk.element,
+      at,
+      props: outcome2.props
+    });
+    else if (outcome2.kind === "changed") {
+      next = outcome2.bag;
+      walk.changed++;
+    }
+  }
+  for (const [key2, value] of Object.entries(next ?? props)) {
+    let rewritten;
+    if (key2 === "layerProps") rewritten = component ? mapLayerProps(walk, component, value, `${at}.${key2}`) : void 0;
+    else {
+      const block = modifierBlock(walk.config, key2, value, []);
+      rewritten = block ? mapProps(walk, component, block, `${at}.${key2}`) : void 0;
+    }
+    if (!rewritten) continue;
+    next ??= { ...props };
+    next[key2] = rewritten;
+  }
+  return next;
+}
+function mapLayerProps(walk, component, layerProps2, at) {
+  const bags = nestedBag(layerProps2);
+  if (!bags) return void 0;
+  let next;
+  for (const [layer, value] of Object.entries(bags)) {
+    const bag = nestedBag(value);
+    if (!bag) continue;
+    const rewritten = mapProps(walk, layerComponent(walk.config, component, layer), bag, `${at}.${layer}`);
+    if (!rewritten) continue;
+    next ??= { ...bags };
+    next[layer] = rewritten;
+  }
+  return next;
+}
+function componentOf(type) {
+  if (typeof type !== "string") return void 0;
+  if (!type.includes(":")) return pathOf2(`component:${type}`);
+  return kindOf2(type) === "component" ? pathOf2(type) : void 0;
+}
+function applyPropMapping(config2, spec2, mapping) {
+  let elements;
+  let changed = 0;
+  const conflicts = [];
+  for (const [key2, element2] of Object.entries(spec2.elements ?? {})) {
+    if (!element2?.props) continue;
+    const walk = {
+      config: config2,
+      mapping,
+      element: key2,
+      conflicts,
+      changed: 0
+    };
+    const props = mapProps(walk, componentOf(element2.type), element2.props, "props");
+    if (!props) continue;
+    elements ??= { ...spec2.elements };
+    elements[key2] = {
+      ...element2,
+      props
+    };
+    changed += walk.changed;
+  }
+  return elements ? {
+    spec: {
+      ...spec2,
+      elements
+    },
+    changed,
+    conflicts
+  } : {
+    spec: spec2,
+    changed: 0,
+    conflicts
+  };
+}
+function mapComponentProps(config2, mapping, instances) {
+  const errors = propMappingErrors(config2, mapping);
+  if (errors.length > 0) return {
+    ok: false,
+    errors
+  };
+  const { spec: spec2, conflicts } = applyPropMapping(config2, { elements: Object.fromEntries(instances.map((props, i) => [String(i), {
+    type: `component:${mapping.component}`,
+    props
+  }])) }, mapping);
+  return {
+    ok: true,
+    instances: instances.map((props, i) => {
+      const after5 = spec2.elements?.[String(i)]?.props ?? props;
+      return {
+        props: after5,
+        changed: after5 !== props,
+        conflicts: conflicts.filter((conflict) => conflict.element === String(i)).flatMap((conflict) => conflict.props)
+      };
+    })
+  };
+}
+
 // ../config/dist/entities/system/component-forwards.js
 function siteOf({ config: config2, path: path2, layer, member }) {
   const body = member ?? config2.resolve("component", path2)?.toJSON();
@@ -83533,7 +83751,7 @@ function bagKey(modifier) {
   const name = modifier.startsWith("_") ? modifier.slice(1) : modifier;
   return `_${name.slice(name.lastIndexOf("/") + 1)}`;
 }
-function addressOf({ layer, modifiers, prop }) {
+function addressOf2({ layer, modifiers, prop }) {
   return [
     "layers",
     layer,
@@ -83628,7 +83846,7 @@ function styleSetEdits({ config: config2, path: path2, changes, isInteraction })
         ...pins,
         [bagKey(change.state)]: true
       };
-      const address2 = addressOf({
+      const address2 = addressOf2({
         layer,
         modifiers: nested,
         prop
@@ -83636,14 +83854,14 @@ function styleSetEdits({ config: config2, path: path2, changes, isInteraction })
       ruleAt(condition).delta[address2] = change.value;
       if (clear && !change.ownRuleOnly) reaching.add(`${canonicalCondition(condition)}
 ${address2}`);
-      if (clear) ruleAt(pins).delta[addressOf({
+      if (clear) ruleAt(pins).delta[addressOf2({
         layer,
         modifiers: [change.state, ...nested],
         prop
       })] = null;
       continue;
     }
-    const address = addressOf({
+    const address = addressOf2({
       layer,
       modifiers: change.state ? [change.state, ...nested] : nested,
       prop
@@ -84261,9 +84479,9 @@ function overrideModifiers(on) {
   return (Array.isArray(on) ? on : [on]).filter(isRef2).map(pathOf2);
 }
 function overrideKey(on) {
-  return overrideModifiers(on).map(leafOf2).sort((a, b) => a.localeCompare(b)).join("&");
+  return overrideModifiers(on).map(leafOf3).sort((a, b) => a.localeCompare(b)).join("&");
 }
-var leafOf2 = (path2) => path2.slice(path2.lastIndexOf("/") + 1);
+var leafOf3 = (path2) => path2.slice(path2.lastIndexOf("/") + 1);
 function declaredCondition(config2) {
   const canonical = (ref2) => {
     if (sourceOf2(ref2) !== void 0) return ref2;
@@ -86817,6 +87035,55 @@ var ComponentEntity = defineEntity({
         data: { props: exampleProps(config2, path2) }
       }),
       handler: (input2, config2) => validateComponentProps(config2, String(input2.path), input2.data.props ?? {})
+    },
+    "map-props": {
+      input: external_exports.object({
+        path: pathInput("component"),
+        data: external_exports.object({ rules: propMappingRulesSchema })
+      }),
+      readOnly: false,
+      approval: "reference-change",
+      label: "Map props",
+      description: "Move a component's instances onto its props as they are now, after its API changed: `variant: 'primary'` becomes `color: 'brand', prominence: 'solid'`. It changes nothing in the config. Where it runs decides what it moves: in Create, the instances in the branch's design files; in a checkout (`uds config edit`, the local UDS MCP), the call sites in the project's source. Refuses a rule that writes a prop or value the component doesn't take. Run it with `plan: true` first: the plan says what it would move, and writes nothing.",
+      scope: "item",
+      title: (entity) => `Map ${entity} props`,
+      example: ({ config: config2, path: path2 }) => {
+        const { data, ...rest } = exampleMapping(config2, path2);
+        return {
+          ...rest,
+          data: { rules: data.rules }
+        };
+      },
+      handler: (input2, config2) => {
+        const errors = propMappingErrors(config2, {
+          component: String(input2.path),
+          rules: input2.data.rules
+        });
+        if (errors.length > 0) rejectData(errors.join(" "));
+        return config2;
+      }
+    },
+    "map-props-plan": {
+      input: external_exports.object({
+        path: pathInput("component"),
+        data: external_exports.object({
+          rules: propMappingRulesSchema,
+          instances: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).default([]).describe("Instances' props as they are stored or written: each comes back with the rules applied.")
+        })
+      }),
+      readOnly: true,
+      label: "Plan a props mapping",
+      description: "Try a mapping on some instances' props before `map-props` applies it: refuses a rule that writes a prop or value the component doesn't take, and returns each given instance's props with the rules applied. Writes nothing.",
+      scope: "item",
+      title: (entity) => `Plan mapping ${entity} props`,
+      example: ({ config: config2, path: path2 }) => exampleMapping(config2, path2),
+      handler: (input2, config2) => {
+        const data = input2.data;
+        return mapComponentProps(config2, {
+          component: String(input2.path),
+          rules: data.rules
+        }, data.instances ?? []);
+      }
     }
   },
   invariants: (config2) => [
@@ -86930,6 +87197,32 @@ function exampleProps(config2, componentPath) {
   }
   return {};
 }
+function exampleMapping(config2, componentPath) {
+  const instance = exampleProps(config2, componentPath);
+  const [name, value] = Object.entries(instance)[0] ?? [];
+  if (name === void 0 || value === void 0) return {
+    path: componentPath,
+    data: {
+      rules: [{
+        when: { variant: "primary" },
+        unset: ["variant"]
+      }],
+      instances: [{ variant: "primary" }]
+    }
+  };
+  const decl = config2.resolve("component", componentPath)?.toJSON()?.props?.[name];
+  const next = (decl ? propValueDomain(config2, decl)?.leaves ?? [] : []).find((leaf) => leaf !== value) ?? value;
+  return {
+    path: componentPath,
+    data: {
+      rules: [{
+        when: { [name]: value },
+        set: { [name]: next }
+      }],
+      instances: [instance]
+    }
+  };
+}
 
 // ../config/dist/framework/prop-surface.js
 function isValueSlot(decl) {
@@ -87158,6 +87451,9 @@ function boundProp(config2, layers, decl, seen) {
   if (!farBody) return void 0;
   return propName in resolveComponentProps(config2, target2) || propName in (farBody.props ?? {}) ? void 0 : undeclared;
 }
+function surfaceProp(config2, componentPath, name) {
+  return surfaceProps(config2, componentPath).find((prop) => prop.name === name);
+}
 function computeForwardClaims(config2, componentPath) {
   const body = Component.get(config2, componentPath)?.toJSON();
   const own2 = /* @__PURE__ */ new Set();
@@ -88746,42 +89042,6 @@ var Device = defineEntity({
   })
 });
 
-// ../config/dist/framework/config-op.js
-function editOp(edit) {
-  if ("op" in edit && typeof edit.op === "object" && edit.op !== null) {
-    const { op, id } = edit;
-    return {
-      op,
-      id
-    };
-  }
-  return { op: edit };
-}
-function opVerb(op) {
-  return op.field === void 0 ? op.operation : `${op.operation}/${op.field}`;
-}
-function addressOf2(op) {
-  return `${op.kind}/${opVerb(op)}`;
-}
-function inputOf(op) {
-  const { kind: _kind, operation: _operation, field: _field, ...input2 } = op;
-  return input2;
-}
-function opOf({ kind, verb, input: input2 = {} }) {
-  const slash = verb.indexOf("/");
-  if (slash === -1) return {
-    ...input2,
-    kind,
-    operation: verb
-  };
-  return {
-    ...input2,
-    kind,
-    operation: verb.slice(0, slash),
-    field: verb.slice(slash + 1)
-  };
-}
-
 // ../config/dist/framework/signature.js
 function isNever(node2) {
   return node2.not !== void 0 && typeof node2.not === "object" && Object.keys(node2.not).length === 0 && Object.keys(node2).length === 1;
@@ -89446,7 +89706,7 @@ var Entity = class {
 };
 
 // ../config/dist/framework/schema-version.js
-var CURRENT_SCHEMA_VERSION = 20261027205147;
+var CURRENT_SCHEMA_VERSION = 20261030134149;
 var SETTINGS_AS_KIND_VERSION = 20260908171448;
 var SchemaVersionTooNew = class extends ConfigFormatError {
   found;
@@ -89466,7 +89726,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 \u2014 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 > 20261027205147) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) \u2014 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 > 20261030134149) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) \u2014 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);
   }
 }
@@ -89497,7 +89757,7 @@ function pendingFor(version2, target2, options) {
   return [...(options?.migrations ?? REGISTERED).values()].filter((m) => m.version > version2 && m.version <= target2).sort((a, b) => a.version - b.version);
 }
 function upgradeSerializedConfig(json2, options) {
-  const target2 = options?.target ?? 20261027205147;
+  const target2 = options?.target ?? 20261030134149;
   const version2 = detectedWireVersion(json2);
   if (version2 > target2) throw new SchemaVersionTooNew(version2, target2);
   const raw = json2;
@@ -90469,7 +90729,7 @@ function groupsAbove(source, items) {
   return groups;
 }
 var recordedSourceCache = /* @__PURE__ */ new WeakMap();
-function leafOf3(field) {
+function leafOf4(field) {
   const slash = field.lastIndexOf("/");
   return slash === -1 ? field : field.slice(slash + 1);
 }
@@ -90520,7 +90780,7 @@ function collectionIn(def, patch) {
   const outer = def[outerField];
   const holder = isPlainObject(outer) ? outer[String(patch.owner)] : void 0;
   if (!isPlainObject(holder)) reject("NOT_FOUND", `No ${outerField}/${patch.owner} on ${patch.kind} "${patch.path}"`);
-  const field = leafOf3(patch.field);
+  const field = leafOf4(patch.field);
   const collection = holder[field];
   if (collection === void 0) return {};
   if (!isPlainObject(collection) || isRef2(collection)) reject("UNSUPPORTED", `"${patch.owner}" on ${patch.kind} "${patch.path}" does not enumerate its own ${field}`);
@@ -90537,7 +90797,7 @@ function storeCollection(def, patch, next) {
   const outer = { ...def[outerField] };
   outer[owner] = {
     ...outer[owner],
-    [leafOf3(patch.field)]: next
+    [leafOf4(patch.field)]: next
   };
   return {
     ...def,
@@ -91080,7 +91340,7 @@ var Config = class Config2 {
       try {
         const start = next.state.pending.length;
         const produced = next.dispatch(op, id);
-        if (!(produced instanceof Config2)) reject("UNSUPPORTED", `${addressOf2(op)} is a read, not an edit.`);
+        if (!(produced instanceof Config2)) reject("UNSUPPORTED", `${addressOf(op)} is a read, not an edit.`);
         next = produced;
         ranges.push({
           opIndex,
@@ -91136,7 +91396,7 @@ var Config = class Config2 {
       const account = `${opVerb(op)}-plan`;
       const declared2 = next.entityOf(op.kind)?.schemas[account];
       if (declared2?.readOnly && declared2.handler) impact.push({
-        op: addressOf2(op),
+        op: addressOf(op),
         answer: next.dispatch({
           ...op,
           operation: account,
@@ -91144,7 +91404,7 @@ var Config = class Config2 {
         })
       });
       const produced = next.dispatch(op);
-      if (!(produced instanceof Config2)) reject("UNSUPPORTED", `${addressOf2(op)} is a read, not an edit.`);
+      if (!(produced instanceof Config2)) reject("UNSUPPORTED", `${addressOf(op)} is a read, not an edit.`);
       next = produced;
     }
     const patches = next.state.pending.slice(this.state.pending.length);
@@ -92429,7 +92689,7 @@ var Config = class Config2 {
       const renamed = {};
       for (const key2 of Object.keys(collection)) renamed[key2 === patch.key ? patch.to : key2] = collection[key2];
       def = store(def, renamed);
-      const refKind = leafOf3(patch.field).replace(/s$/, "");
+      const refKind = leafOf4(patch.field).replace(/s$/, "");
       def = rewriteRefs(def, `${refKind}:${refPathOf(patch, patch.key)}`, `${refKind}:${refPathOf(patch, patch.to)}`);
       def = renameNamedValues(sub, def, patch.owner, patch.key, patch.to);
       def = renameKeyedByName(sub, def, patch.key, patch.to);
@@ -92452,7 +92712,7 @@ var Config = class Config2 {
       def = renameKeyedByName(sub, def, patch.key, void 0);
       def = renameListedNames(sub, def, patch.key, void 0);
       def = dropVacated(entry, sub, def);
-      def = dropOrphans(sub, def, `${leafOf3(patch.field).replace(/s$/, "")}:${refPathOf(patch, patch.key)}`, sub?.namespaces ? {
+      def = dropOrphans(sub, def, `${leafOf4(patch.field).replace(/s$/, "")}:${refPathOf(patch, patch.key)}`, sub?.namespaces ? {
         kind: sub.namespaces,
         path: patch.key
       } : void 0, patch.owner === void 0 ? {
@@ -94306,9 +94566,9 @@ var Config = class Config2 {
   */
   displayLabelOf(target2) {
     const { path: path2, member, marked } = splitRef2(target2);
-    if (member) return leafOf3(member);
-    if (!marked) return leafOf3(path2);
-    return this.resolveRef(target2)?.displayLabel ?? leafOf3(path2);
+    if (member) return leafOf4(member);
+    if (!marked) return leafOf4(path2);
+    return this.resolveRef(target2)?.displayLabel ?? leafOf4(path2);
   }
   /**
   * The `data` schema for a mutation `verb`, narrowed to one target entity — the same per-owner
@@ -96354,7 +96614,7 @@ var Config = class Config2 {
   *  links from the provided sources. A declared `linkedKind` with no provided source throws. */
   hydrateFrom(stored, options) {
     const claimed = schemaVersionOf(stored);
-    if (claimed > 20261027205147) throw new SchemaVersionTooNew(claimed);
+    if (claimed > 20261030134149) 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 \u2014 import the config type's module (e.g. \`configs/system\`) before hydrating.`);
     const leftover = wire.options;
@@ -99740,6 +100000,13 @@ var lintIgnoreMigration = {
   up: (json2) => json2
 };
 
+// ../config/dist/migrations/20261030134149_component_map_props.js
+var COMPONENT_MAP_PROPS_VERSION = 20261030134149;
+var componentMapPropsMigration = {
+  version: COMPONENT_MAP_PROPS_VERSION,
+  up: (json2) => json2
+};
+
 // ../../node_modules/css-tree/lib/generator/sourceMap.js
 var import_source_map_generator = __toESM(require_source_map_generator(), 1);
 var trackNodes = /* @__PURE__ */ new Set(["Atrule", "Selector", "Declaration"]);
@@ -101492,7 +101759,7 @@ var before3 = external_exports.looseObject({ items: external_exports.looseObject
   previewWhen: external_exports.array(external_exports.unknown()).optional()
 })).optional() }).optional() });
 var after3 = external_exports.looseObject({ items: external_exports.looseObject({ component: external_exports.record(external_exports.string(), external_exports.looseObject({ preview: external_exports.record(external_exports.string(), external_exports.unknown()).optional() })).optional() }).optional() });
-function leafOf4(value) {
+function leafOf5(value) {
   if (isPlainObject(value) && typeof value.__ref === "string") {
     const path2 = /^[^:]*:(.*)$/.exec(value.__ref)?.[1] ?? value.__ref;
     return /([^/]*)$/.exec(path2)?.[1] ?? path2;
@@ -101501,7 +101768,7 @@ function leafOf4(value) {
 }
 function keyOf(when) {
   const entries = Object.entries(isPlainObject(when) ? when : {}).filter(([, value]) => value !== void 0 && value !== null).sort(([a], [b]) => a.localeCompare(b));
-  return entries.length === 0 ? UNCONDITIONAL : entries.map(([prop, value]) => `${prop}=${leafOf4(value)}`).join("&");
+  return entries.length === 0 ? UNCONDITIONAL : entries.map(([prop, value]) => `${prop}=${leafOf5(value)}`).join("&");
 }
 function foldedPreview({ preview, previewProps, previewWhen }) {
   const keyed = isPlainObject(preview) ? { ...preview } : {};
@@ -102232,7 +102499,7 @@ var linkedComponentModulesMigration = {
 
 // ../config/dist/migrations/20261013154037_component_states.js
 var COMPONENT_STATES_VERSION = 20261013154037;
-function leafOf5(value) {
+function leafOf6(value) {
   if (isPlainObject(value) && typeof value.__ref === "string") return /([^/]*)$/.exec(value.__ref)?.[1] ?? value.__ref;
   return value;
 }
@@ -102251,8 +102518,8 @@ function foldedStates(body) {
       const fallback = defaults?.[name];
       states[name] = {
         type: "variant",
-        value: value.map((member) => String(leafOf5(member))),
-        ...typeof leafOf5(fallback) === "string" ? { default: leafOf5(fallback) } : {}
+        value: value.map((member) => String(leafOf6(member))),
+        ...typeof leafOf6(fallback) === "string" ? { default: leafOf6(fallback) } : {}
       };
     } else states[name] = { type: "boolean" };
     if (defaults) delete defaults[name];
@@ -102261,7 +102528,7 @@ function foldedStates(body) {
   const plainWhen = (entry) => {
     if (!isPlainObject(entry) || !isPlainObject(entry.when)) return entry;
     const when = { ...entry.when };
-    for (const name of movedVariants) if (name in when) when[name] = leafOf5(when[name]);
+    for (const name of movedVariants) if (name in when) when[name] = leafOf6(when[name]);
     return {
       ...entry,
       when
@@ -102474,6 +102741,7 @@ if (!registeredSchemaMigrations().has(20261023152030)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20261026125912)) registerSchemaMigrations(timingValueMigration);
 if (!registeredSchemaMigrations().has(20261027184442)) registerSchemaMigrations(variantValuesListWithBodiesMigration);
 if (!registeredSchemaMigrations().has(20261027205147)) registerSchemaMigrations(lintIgnoreMigration);
+if (!registeredSchemaMigrations().has(20261030134149)) registerSchemaMigrations(componentMapPropsMigration);
 
 // ../config/dist/capture/node-ops.js
 var DEFAULT_WIDTH = 1600;
@@ -102737,7 +103005,7 @@ function insert(config2, input2) {
   }
   const slot = input2.data.slotProp;
   if (slot !== void 0) {
-    const component = componentOf({
+    const component = componentOf2({
       config: config2,
       body: parent
     });
@@ -102764,7 +103032,7 @@ function insert(config2, input2) {
   });
   return patches;
 }
-function componentOf({ config: config2, body }) {
+function componentOf2({ config: config2, body }) {
   if (!body.type) return void 0;
   const { system } = attachedSystem(config2);
   const entity = system.resolve("component", pathOf2(body.type));
@@ -102980,7 +103248,7 @@ function reparent({ config: config2, path: path2, parent, slotProp: slot, index
   if (subtreeOf(config2, path2).includes(to)) return rejectData(`"${to}" is inside "${path2}".`, ["data", "parent"]);
   const target2 = bodyOf2(config2, to, ["data", "parent"]);
   const moving = config2.resolve("node", path2)?.body?.type;
-  const component = componentOf({
+  const component = componentOf2({
     config: config2,
     body: target2
   });
@@ -103020,7 +103288,7 @@ function wrap(config2, input2) {
     slug: slug2
   });
   const slotName = input2.data.container.slotProp ?? "children";
-  const component = componentOf({
+  const component = componentOf2({
     config: config2,
     body: { type }
   });