@yahoo/uds-create-cli 5.69.0 → 5.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-cli",
-  "version": "5.69.0",
+  "version": "5.71.0",
   "publishConfig": {
     "access": "public"
   },
@@ -32,10 +32,10 @@
     "@modelcontextprotocol/sdk": "^1.32.2",
     "@orpc/client": "^1.13.9",
     "@orpc/contract": "^1.13.9",
-    "@yahoo/uds-create-config": "5.69.0",
-    "@yahoo/uds-create-loader": "5.69.0",
-    "@yahoo/uds-create-types": "5.69.0",
-    "@yahoo/uds-create-utils": "5.69.0",
+    "@yahoo/uds-create-config": "5.71.0",
+    "@yahoo/uds-create-loader": "5.71.0",
+    "@yahoo/uds-create-types": "5.71.0",
+    "@yahoo/uds-create-utils": "5.71.0",
     "esbuild": "^0.27.4",
     "ts-morph": "^27.0.2",
     "get-tsconfig": "^4.10.0",
@@ -52,13 +52,13 @@
     "lodash": "^4.17.23",
     "prettier": "^3.8.1"
   },
-  "udsSchemaVersion": 20261102143821,
+  "udsSchemaVersion": 20261102193912,
   "optionalDependencies": {
-    "@yahoo/uds-create-cli-darwin-arm64": "5.69.0",
-    "@yahoo/uds-create-cli-darwin-x64": "5.69.0",
-    "@yahoo/uds-create-cli-linux-arm64": "5.69.0",
-    "@yahoo/uds-create-cli-linux-x64": "5.69.0",
-    "@yahoo/uds-create-cli-linux-arm64-musl": "5.69.0",
-    "@yahoo/uds-create-cli-linux-x64-musl": "5.69.0"
+    "@yahoo/uds-create-cli-darwin-arm64": "5.71.0",
+    "@yahoo/uds-create-cli-darwin-x64": "5.71.0",
+    "@yahoo/uds-create-cli-linux-arm64": "5.71.0",
+    "@yahoo/uds-create-cli-linux-x64": "5.71.0",
+    "@yahoo/uds-create-cli-linux-arm64-musl": "5.71.0",
+    "@yahoo/uds-create-cli-linux-x64-musl": "5.71.0"
   }
 }

package/subprocess/transform-runner.mjs

@@ -83515,6 +83515,13 @@ var propMappingRuleSchema = external_exports.object({
   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.");
+var swapMappingRulesSchema = external_exports.array(propMappingRuleSchema).describe("The rules for the swapped instances, as a mapping has them. `when: {}` applies to every one of them (to `unset` a prop the new component lacks), and none keeps their props as they are.");
+var mapPropsRulesSchema = external_exports.array(propMappingRuleSchema).default([]).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. A mapping needs at least one. With `from`, none keeps the swapped instances' props, and `when: {}` reaches every swapped instance.");
+var mappingScopeSchema = external_exports.object({
+  canvas: external_exports.string().min(1).describe("The design file's canvas id."),
+  nodes: external_exports.array(external_exports.string().min(1)).min(1).describe("The ids of the nodes it reaches, in that design file.")
+}).describe("Create only: limits the mapping to these nodes of one design file, for fixing one instance before asking about the rest. A checkout's call sites aren't nodes, so there it isn't taken.");
+var mappingFromSchema = external_exports.string().min(1).describe("The component whose instances become this one's, as a path: the one a design file still names after the system lost it (`SelectContent`, replaced by `SelectMenu`). It needn't exist. Which component replaces which is the user's call: propose it, and apply it only once they confirm.");
 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;
@@ -83524,9 +83531,10 @@ function valueRefusal(config2, component, prop, value) {
 }
 function propMappingErrors(config2, mapping) {
   if (!config2.resolve("component", mapping.component)) return [`No component "${mapping.component}"`];
+  if (mapping.from === mapping.component) return [`"${mapping.component}" can't replace itself: \`from\` names the component its instances are now`];
   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\``);
+    if (Object.keys(rule.when).length === 0 && mapping.from === void 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) {
@@ -83567,6 +83575,10 @@ function mapBag(bag, rules) {
     bag: next
   };
 }
+function retyped(type, to) {
+  const at = type.lastIndexOf("@");
+  return `component:${to}${type.includes(":") && at > 0 ? type.slice(at) : ""}`;
+}
 function mapProps(walk, component, props, at) {
   let next;
   if (component === walk.mapping.component) {
@@ -83617,8 +83629,10 @@ function applyPropMapping(config2, spec2, mapping) {
   let elements;
   let changed = 0;
   const conflicts = [];
+  const reached = mapping.only ? new Set(mapping.only.nodes) : void 0;
   for (const [key2, element2] of Object.entries(spec2.elements ?? {})) {
-    if (!element2?.props) continue;
+    if (!element2) continue;
+    if (reached && !reached.has(key2)) continue;
     const walk = {
       config: config2,
       mapping,
@@ -83626,14 +83640,18 @@ function applyPropMapping(config2, spec2, mapping) {
       conflicts,
       changed: 0
     };
-    const props = mapProps(walk, componentOf(element2.type), element2.props, "props");
-    if (!props) continue;
+    const component = componentOf(element2.type);
+    const swapped = mapping.from !== void 0 && component === mapping.from && typeof element2.type === "string";
+    if (!swapped && !element2.props) continue;
+    const props = mapProps(walk, swapped ? mapping.component : component, element2.props ?? {}, "props");
+    if (!props && !swapped) continue;
     elements ??= { ...spec2.elements };
     elements[key2] = {
       ...element2,
-      props
+      ...swapped ? { type: retyped(element2.type, mapping.component) } : {},
+      ...props ? { props } : {}
     };
-    changed += walk.changed;
+    changed += walk.changed + (swapped && walk.changed === 0 ? 1 : 0);
   }
   return elements ? {
     spec: {
@@ -83655,7 +83673,7 @@ function mapComponentProps(config2, mapping, instances) {
     errors
   };
   const { spec: spec2, conflicts } = applyPropMapping(config2, { elements: Object.fromEntries(instances.map((props, i) => [String(i), {
-    type: `component:${mapping.component}`,
+    type: `component:${mapping.from ?? mapping.component}`,
     props
   }])) }, mapping);
   return {
@@ -83664,7 +83682,7 @@ function mapComponentProps(config2, mapping, instances) {
       const after5 = spec2.elements?.[String(i)]?.props ?? props;
       return {
         props: after5,
-        changed: after5 !== props,
+        changed: after5 !== props || mapping.from !== void 0,
         conflicts: conflicts.filter((conflict) => conflict.element === String(i)).flatMap((conflict) => conflict.props)
       };
     })
@@ -87099,12 +87117,16 @@ var ComponentEntity = defineEntity({
     "map-props": {
       input: external_exports.object({
         path: pathInput("component"),
-        data: external_exports.object({ rules: propMappingRulesSchema })
+        data: external_exports.object({
+          from: mappingFromSchema.optional(),
+          only: mappingScopeSchema.optional(),
+          rules: mapPropsRulesSchema
+        })
       }),
       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.",
+      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. With `from`, it swaps the component too: instances of `from`, a component the system may no longer have, become this component's, and the rules move their props onto it (`when: {}` reaches every swapped instance). 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 }) => {
@@ -87115,10 +87137,7 @@ var ComponentEntity = defineEntity({
         };
       },
       handler: (input2, config2) => {
-        const errors = propMappingErrors(config2, {
-          component: String(input2.path),
-          rules: input2.data.rules
-        });
+        const errors = propMappingErrors(config2, mappingOf(String(input2.path), input2.data));
         if (errors.length > 0) rejectData(errors.join(" "));
         return config2;
       }
@@ -87127,7 +87146,8 @@ var ComponentEntity = defineEntity({
       input: external_exports.object({
         path: pathInput("component"),
         data: external_exports.object({
-          rules: propMappingRulesSchema,
+          from: mappingFromSchema.optional(),
+          rules: mapPropsRulesSchema,
           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.")
         })
       }),
@@ -87139,10 +87159,7 @@ var ComponentEntity = defineEntity({
       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 ?? []);
+        return mapComponentProps(config2, mappingOf(String(input2.path), input2.data), data.instances ?? []);
       }
     }
   },
@@ -87257,6 +87274,16 @@ function exampleProps(config2, componentPath) {
   }
   return {};
 }
+function mappingOf(component, data) {
+  const { from, only, rules = [] } = data ?? {};
+  if (from === void 0 && rules.length === 0) rejectData("Name at least one rule in `rules`, or `from` to swap another component's instances onto this one.");
+  return {
+    component,
+    ...from === void 0 ? {} : { from: from.replace(/^component:/, "") },
+    ...only === void 0 ? {} : { only },
+    rules
+  };
+}
 function exampleMapping(config2, componentPath) {
   const instance = exampleProps(config2, componentPath);
   const [name, value] = Object.entries(instance)[0] ?? [];
@@ -89766,7 +89793,7 @@ var Entity = class {
 };
 
 // ../config/dist/framework/schema-version.js
-var CURRENT_SCHEMA_VERSION = 20261102143821;
+var CURRENT_SCHEMA_VERSION = 20261102193912;
 var SETTINGS_AS_KIND_VERSION = 20260908171448;
 var SchemaVersionTooNew = class extends ConfigFormatError {
   found;
@@ -89786,7 +89813,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 > 20261102143821) 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 > 20261102193912) 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);
   }
 }
@@ -89817,7 +89844,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 ?? 20261102143821;
+  const target2 = options?.target ?? 20261102193912;
   const version2 = detectedWireVersion(json2);
   if (version2 > target2) throw new SchemaVersionTooNew(version2, target2);
   const raw = json2;
@@ -96703,7 +96730,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 > 20261102143821) throw new SchemaVersionTooNew(claimed);
+    if (claimed > 20261102193912) 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;
@@ -98039,7 +98066,15 @@ function planLinkApplied({ config: config2, input: input2 }) {
   const shadows = [];
   const gains = /* @__PURE__ */ new Map();
   let leftAnywhere = false;
+  const replacements = replacementTakes({
+    config: config2,
+    slug: slug2,
+    source,
+    input: input2
+  });
+  const landing = new Set(replacements.entries.map(({ kind, path: path2 }) => `${kind}:${path2}`));
   const shadow2 = (kind, path2) => {
+    if (landing.has(`${kind}:${path2}`)) return true;
     const held = config2.resolve(kind, path2);
     if (!held || held.borrowedFrom === slug2) return true;
     if (sharedWithOrigin({
@@ -98119,7 +98154,7 @@ function planLinkApplied({ config: config2, input: input2 }) {
         if (path2 === "*") continue;
         rejectData(`Cannot link "${path2}" through "${slug2}" \u2014 the source has no ${kind} there.`, ["data", accessor]);
       }
-      const taken = entries.filter((entry) => {
+      const taken2 = entries.filter((entry) => {
         const fit = config2.canBorrow({
           kind,
           path: entry.from,
@@ -98129,12 +98164,12 @@ function planLinkApplied({ config: config2, input: input2 }) {
         if (source.resolve(kind, path2)) rejectData(fit.error, ["data", accessor]);
         return false;
       }).filter((entry) => shadow2(kind, entry.from));
-      if (taken.length === entries.length) {
+      if (taken2.length === entries.length) {
         if (path2 !== "*") gained.push(path2);
         continue;
       }
       whole = false;
-      gained.push(...taken.map((entry) => entry.from));
+      gained.push(...taken2.map((entry) => entry.from));
     }
     if (whole) gains.set(accessor, "*");
     else if (gained.length > 0) gains.set(accessor, gained);
@@ -98184,12 +98219,13 @@ function planLinkApplied({ config: config2, input: input2 }) {
     declared2 = Object.keys(next).length === 0 ? current : next;
   }
   const planned = [
+    ...replacements.patches,
     ...takes2,
     ...declares,
     ...shadows
   ];
   let result = planned.length > 0 ? applied(config2, planned) : void 0;
-  if (takes2.length > 0 && result && "failed" in result) throw result.failed;
+  if ((takes2.length > 0 || replacements.patches.length > 0) && result && "failed" in result) throw result.failed;
   const { dropped, stranded, patches: drops } = takes2.length > 0 && result && "config" in result ? directivesTakenFrom({
     config: config2,
     slug: slug2,
@@ -98200,7 +98236,74 @@ function planLinkApplied({ config: config2, input: input2 }) {
     patches: []
   };
   if (drops.length > 0 && result && "config" in result) result = applied(result.config, drops);
-  const patches = [...planned, ...drops];
+  const taken = [];
+  const leaves2 = [];
+  for (const entry of replacements.entries) {
+    const { kind, accessor, path: path2, replaces, from } = entry;
+    if (from === void 0 || !result || !("config" in result)) {
+      taken.push({
+        kind,
+        path: replaces,
+        with: path2,
+        ...from ? { from } : {},
+        excluded: false,
+        dropped: []
+      });
+      continue;
+    }
+    const leftOut = { [accessor]: [replaces] };
+    const keptFor = linkedDependents({
+      config: result.config,
+      slug: from,
+      data: leftOut
+    });
+    if (keptFor.length > 0) {
+      taken.push({
+        kind,
+        path: replaces,
+        with: path2,
+        from,
+        excluded: false,
+        keptFor,
+        dropped: []
+      });
+      continue;
+    }
+    const exclusion = planExclude({
+      config: result.config,
+      input: {
+        path: from,
+        data: leftOut
+      }
+    });
+    if (exclusion.blocked !== void 0) {
+      taken.push({
+        kind,
+        path: replaces,
+        with: path2,
+        from,
+        excluded: false,
+        keptBecause: exclusion.blocked,
+        dropped: []
+      });
+      continue;
+    }
+    leaves2.push(...exclusion.patches);
+    result = applied(result.config, exclusion.patches);
+    taken.push({
+      kind,
+      path: replaces,
+      with: path2,
+      from,
+      excluded: true,
+      dropped: exclusion.dropped
+    });
+  }
+  const patches = [
+    ...planned,
+    ...drops,
+    ...leaves2
+  ];
   return {
     plan: {
       declared: declared2,
@@ -98214,6 +98317,7 @@ function planLinkApplied({ config: config2, input: input2 }) {
       addresses: addresses2,
       linked,
       extended,
+      replaced: taken,
       dropped,
       shared,
       patches,
@@ -98225,6 +98329,71 @@ function planLinkApplied({ config: config2, input: input2 }) {
     after: stranded.length === 0 && result && "config" in result ? result.config : void 0
   };
 }
+function replacementTakes({ config: config2, slug: slug2, source, input: input2 }) {
+  const entries = [];
+  const patches = [];
+  const accessors = config2.accessors();
+  const landing = /* @__PURE__ */ new Map();
+  for (const [accessor, pairs] of Object.entries(input2.replace ?? {})) {
+    const kind = accessors[accessor]?.kind;
+    if (!kind) rejectData(`Cannot replace anything through "${slug2}" \u2014 this system has no "${accessor}".`, ["replace", accessor]);
+    for (const [replaces, path2] of Object.entries(pairs)) {
+      const at = [
+        "replace",
+        accessor,
+        replaces
+      ];
+      if (input2.data !== "*" && !covers({
+        declared: input2.data,
+        accessor,
+        path: path2
+      })) rejectData(`Cannot replace "${replaces}" with "${path2}" \u2014 \`data\` doesn't link "${path2}" through "${slug2}". Name it there too.`, at);
+      if (!source.resolve(kind, path2)) rejectData(`Cannot replace "${replaces}" with "${path2}" \u2014 "${slug2}" has no ${kind} "${path2}".`, at);
+      if (path2 === replaces) rejectData(`Cannot replace "${path2}" with itself \u2014 taking the source's "${path2}" over it is \`onLinked: 'take'\`.`, at);
+      const twice = landing.get(`${kind}:${path2}`);
+      if (twice !== void 0) rejectData(`Cannot replace both "${twice}" and "${replaces}" with "${path2}".`, at);
+      const held = config2.resolve(kind, replaces);
+      if (!held) rejectData(`Cannot replace "${replaces}" \u2014 this system has no ${kind} "${replaces}".`, at);
+      if (held.borrowedFrom === slug2) rejectData(`Cannot replace "${replaces}" with "${path2}" \u2014 "${replaces}" already comes from "${slug2}".`, at);
+      const occupied = config2.storedBody(kind, path2);
+      if (occupied !== void 0 && !isMintedRow(occupied)) rejectData(`Cannot replace "${replaces}" with "${path2}" \u2014 this system already has a ${kind} of its own at "${path2}".`, at);
+      landing.set(`${kind}:${path2}`, replaces);
+      const from = held.borrowedFrom ?? declaredElsewhere({
+        config: config2,
+        slug: slug2,
+        kind,
+        path: replaces
+      });
+      const stored = config2.storedBody(kind, replaces);
+      const minted = stored !== void 0 && isMintedRow(stored);
+      entries.push({
+        kind,
+        accessor,
+        path: path2,
+        replaces,
+        ...from ? { from } : {}
+      });
+      patches.push({
+        kind,
+        operation: minted ? "create" : "replace",
+        path: replaces,
+        data: {
+          ...ref(kind, path2, slug2),
+          extend: {}
+        }
+      }, {
+        kind,
+        operation: "rename",
+        path: replaces,
+        to: path2
+      });
+    }
+  }
+  return {
+    entries,
+    patches
+  };
+}
 function directivesTakenFrom({ config: config2, slug: slug2, after: after5 }) {
   const key2 = (at) => `${at.slug}\0${at.accessor}\0${at.path}`;
   const already = new Set(danglingDirectives(config2).map(key2));
@@ -99029,7 +99198,16 @@ var linkInput = external_exports.object({
   data: external_exports.union([external_exports.literal("*"), external_exports.record(external_exports.string(), copyPaths)]),
   /** What to do at a path another linked system provides: `'take'` makes it follow this source,
   *  `'keep'` leaves it where it comes from. Required when there is one; `link-plan` lists them. */
-  onLinked: external_exports.enum(["keep", "take"]).optional()
+  onLinked: external_exports.enum(["keep", "take"]).optional(),
+  /**
+  * A component this config holds under one name, replaced with the source's of another name, keyed
+  * by accessor: `{ components: { SelectContent: 'SelectMenu' } }` replaces the `SelectContent` this
+  * config holds with the source's `SelectMenu`. Every ref to `SelectContent` is renamed to
+  * `SelectMenu`, so design files and code follow the way they follow a rename, and the system
+  * `SelectContent` came through stops deriving it unless its own rows still use it. Each source path
+  * is one `data` names; `link-plan` lists each in `replaced`. A take at the same name is `onLinked`.
+  */
+  replace: external_exports.record(external_exports.string(), external_exports.record(external_exports.string().min(1), external_exports.string().min(1))).optional()
 });
 var unlinkInput = external_exports.object({
   path: pathInput("linked-system"),
@@ -99071,7 +99249,8 @@ function linkPlanInputOf(input2) {
   return {
     path: String(input2.path),
     data: input2.data,
-    ...input2.onLinked === void 0 ? {} : { onLinked: input2.onLinked }
+    ...input2.onLinked === void 0 ? {} : { onLinked: input2.onLinked },
+    ...input2.replace === void 0 ? {} : { replace: input2.replace }
   };
 }
 function linkExample({ config: config2, path: path2 }) {
@@ -99150,7 +99329,7 @@ var LinkedSystemDefinition = defineEntity({
       input: linkInput,
       readOnly: false,
       label: "Link from",
-      description: "Draw entities from a linked system, following the source: `data` names them by accessor \u2014 `{ tokens: ['color/brand', 'color'] }` takes an entity and a folder's members, `{ tokens: '*' }` every token, and `'*'` the whole system. What this config already holds at those paths is replaced by theirs, so run `linked-system/link-plan` with the same input first to see what that is. To hold their values as your own instead, `copy`.",
+      description: "Draw entities from a linked system, following the source: `data` names them by accessor \u2014 `{ tokens: ['color/brand', 'color'] }` takes an entity and a folder's members, `{ tokens: '*' }` every token, and `'*'` the whole system. What this config already holds at those paths is replaced by theirs, so run `linked-system/link-plan` with the same input first to see what that is. To replace something this config holds under another name (the `SelectContent` it has with the source's `SelectMenu`), name the pair in `replace` (`{ components: { SelectContent: 'SelectMenu' } }`): every reference to the old name moves to the new one, in design files and code too. To hold their values as your own instead, `copy`.",
       scope: "item",
       approval: "reference-change",
       title: (entity) => `Link something from ${entity}`,
@@ -99173,7 +99352,7 @@ var LinkedSystemDefinition = defineEntity({
       input: linkInput,
       readOnly: true,
       label: "Plan a link",
-      description: "What `link` with the same input replaces \u2014 rows of yours deleted so the source shows through, every path another linked system provides (`linked`, turned into extensions when `onLinked` says take), the `options` entries another linked system holds at what a take moves, which it removes since they would apply to nothing (`dropped`), members left alone because they are already here from the same origin, paths another linked system declares that the link reaches as a different entity (`settled`), whose row stays, and why the config would refuse the link (`blocked`), a collision it would leave among them. Writes nothing.",
+      description: "What `link` with the same input replaces \u2014 rows of yours deleted so the source shows through, every path another linked system provides (`linked`, turned into extensions when `onLinked` says take), the `options` entries another linked system holds at what a take moves, which it removes since they would apply to nothing (`dropped`), members left alone because they are already here from the same origin, paths another linked system declares that the link reaches as a different entity (`settled`), whose row stays, what `replace` replaces under another name (`replaced`: each path, what replaces it, the pin it came through, and whether it is left out of that pin or kept because rows of that pin still use it), and why the config would refuse the link (`blocked`), a collision it would leave among them. Writes nothing.",
       scope: "item",
       title: (entity) => `Plan a link from ${entity}`,
       example: linkExample,
@@ -100112,6 +100291,22 @@ var defaultColorsMigration = {
   }
 };
 
+// ../config/dist/migrations/20261102185610_link_replace.js
+var LINK_REPLACE_VERSION = 20261102185610;
+var linkReplaceMigration = {
+  version: LINK_REPLACE_VERSION,
+  up: (json2) => json2
+};
+
+// ../config/dist/migrations/20261102193912_map_props_from.js
+var MAP_PROPS_FROM_VERSION = 20261102193912;
+var mapPropsFromMigration = {
+  version: MAP_PROPS_FROM_VERSION,
+  up(json2) {
+    return 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"]);
@@ -102849,6 +103044,8 @@ if (!registeredSchemaMigrations().has(20261027205147)) registerSchemaMigrations(
 if (!registeredSchemaMigrations().has(20261030134149)) registerSchemaMigrations(componentMapPropsMigration);
 if (!registeredSchemaMigrations().has(20261030163028)) registerSchemaMigrations(layerPrefixMigration);
 if (!registeredSchemaMigrations().has(20261102143821)) registerSchemaMigrations(defaultColorsMigration);
+if (!registeredSchemaMigrations().has(20261102185610)) registerSchemaMigrations(linkReplaceMigration);
+if (!registeredSchemaMigrations().has(20261102193912)) registerSchemaMigrations(mapPropsFromMigration);
 
 // ../config/dist/capture/node-ops.js
 var DEFAULT_WIDTH = 1600;