@yahoo/uds-create-config 5.57.0 → 5.57.1

package/dist/entities/system/LinkedSystem.js

@@ -352,7 +352,7 @@ const LinkedSystemDefinition = defineEntity({
 			input: unlinkInput,
 			readOnly: false,
 			label: "Unlink from",
-			description: "Stop following a linked system's entities, in `link`'s shape or everything when `data` is omitted. The rows the declaration minted go with it, and so do the linked rows that point at them, since left linked they would bring them back; nothing of yours moves. A row of yours pointing at one of theirs refuses this — `copy` what is used first, or `break` with `keep: true`. `unlink-plan` names everything that goes.",
+			description: "Stop following a linked system's entities, in `link`'s shape or everything when `data` is omitted. The rows the declaration minted go with it, and so do the linked rows that point at them, since left linked they would bring them back, and the pin's `options` entries left with no row to adjust; nothing of yours moves. A row of yours pointing at one of theirs refuses this — `copy` what is used first, or `break` with `keep: true`. `unlink-plan` names everything that goes.",
 			scope: "item",
 			approval: "reference-change",
 			title: (entity) => `Unlink from ${entity}`,
@@ -374,7 +374,7 @@ const LinkedSystemDefinition = defineEntity({
 			input: unlinkInput,
 			readOnly: true,
 			label: "Plan an unlink",
-			description: "What `unlink` with the same input removes — the minted rows the narrower declaration no longer reaches, with the linked rows taken along because they point at them named in `cascade` — and why the config would refuse it, a collision it would leave among them. Writes nothing.",
+			description: "What `unlink` with the same input removes — the minted rows the narrower declaration no longer reaches, with the linked rows taken along because they point at them named in `cascade`, and the `options` entries of the pin that go with them in `dropped` — and why the config would refuse it, a collision it would leave among them. Writes nothing.",
 			scope: "item",
 			title: (entity) => `Plan unlinking from ${entity}`,
 			example: pinExample,

package/dist/entities/system/copy-plan.js

@@ -96,10 +96,20 @@ function planCopy({ config, input }) {
 	const taking = [];
 	const folders = [];
 	const reused = [];
+	/** Folders this config draws through another pin, which a copied ref binds to as it does a reused row. */
+	const heldFolders = /* @__PURE__ */ new Set();
 	/** Every `kind:path` `take` has answered, whichever way, so the walk below visits each once. */
 	const seen = /* @__PURE__ */ new Set();
 	const declared = declarationOf(config, slug);
 	const folder = (kind, path) => {
+		const through = config.groupBorrowedFrom({
+			kind,
+			groupPath: path
+		});
+		if (through !== void 0 && through !== slug && input.onConflict !== "replace") {
+			heldFolders.add(`${kind}:${path}`);
+			return;
+		}
 		if (!folders.some((f) => f.kind === kind && f.path === path)) folders.push({
 			kind,
 			path
@@ -258,6 +268,32 @@ function planCopy({ config, input }) {
 		}
 	}
 	if (taking.length === 0 && wholesale) rejectData(`"${slug}" has nothing to copy.`);
+	/**
+	* The files of a sibling a copied render imports, when the sibling itself isn't copied — this config
+	* holds that path already, through another pin or as its own. The render imports the source's
+	* module, not whatever answers the path here, so that module lands without the component, and so do
+	* the files of the siblings it imports in turn. A copied sibling brings its own files.
+	*/
+	const siblingFiles = ({ sibling, component }) => {
+		const key = `files:${sibling}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (taking.some((row) => row.kind === "component" && row.at === sibling)) return;
+		for (const path of renderSourceFiles({
+			source,
+			path: sibling
+		})) takeFile({
+			path,
+			component
+		});
+		for (const next of renderImportedComponents({
+			source,
+			path: sibling
+		})) siblingFiles({
+			sibling: next,
+			component
+		});
+	};
 	/** Take what `body` points at by ref. */
 	const follow = (body) => {
 		for (const target of collectRefs(body)) {
@@ -318,12 +354,18 @@ function planCopy({ config, input }) {
 			for (const sibling of renderImportedComponents({
 				source,
 				path: row.theirs
-			})) take({
-				kind: "component",
-				theirs: sibling,
-				at: sibling,
-				named: false
-			});
+			})) {
+				take({
+					kind: "component",
+					theirs: sibling,
+					at: sibling,
+					named: false
+				});
+				siblingFiles({
+					sibling,
+					component: row.theirs
+				});
+			}
 			for (const path of renderSourceFiles({
 				source,
 				path: row.theirs
@@ -336,11 +378,17 @@ function planCopy({ config, input }) {
 	const arriving = new Set([
 		...taking.map((row) => `${row.kind}:${row.at}`),
 		...reused.map((row) => `${row.kind}:${row.path}`),
+		...heldFolders,
 		...folders.map((folder) => `${folder.kind}:${folder.path}`)
 	]);
 	const patches = [];
 	for (const { kind, path } of folders) {
-		const meta = ownMeta(source.groups(kind).find((group) => group.path === path)?.meta ?? {});
+		const meta = ownMeta(config.copyOfGroup({
+			slug,
+			kind,
+			path,
+			alongside: arriving
+		}) ?? {});
 		const pointed = config.groupBorrowedFrom({
 			kind,
 			groupPath: path

package/dist/entities/system/link-plan.d.ts

@@ -64,6 +64,9 @@ interface UnlinkPlan {
   /** Linked rows unlinked with the named ones because they point at them: left linked, they would
    *  bring the named rows back on the next derive. */
   readonly cascade: readonly EntityAddress[];
+  /** The pin's `options` entries that go with the unlink: one on a path that stops deriving, and one
+   *  on a path drawn from elsewhere that names a row that goes. Neither has a row to adjust. */
+  readonly dropped: readonly EntityAddress[];
   /** Why the config would refuse. `undefined` when it would go through. */
   readonly blocked?: string;
   /** The paths the unlink would leave two linked systems offering as different entities, when that

package/dist/entities/system/link-plan.js

@@ -329,6 +329,7 @@ function planUnlink({ config, input }) {
 		declared: void 0,
 		removed: [],
 		cascade: [],
+		dropped: [],
 		patches: []
 	};
 	let declared;
@@ -397,16 +398,39 @@ function planUnlink({ config, input }) {
 		}
 		if (input.data !== void 0 && removed.length === 0) blocked = stillReached({ slug });
 	}
+	const dropped = after ? deadDirectives({
+		config,
+		after,
+		slug,
+		removed
+	}) : [];
+	if (dropped.length > 0) {
+		const update = patches[patches.length - 1];
+		if (dropped.length === config.sourceDirectives(slug).length) update.data.options = null;
+		else for (const { accessor, path } of dropped) update.data[`options.${accessor}.${path}`] = null;
+	}
 	return {
 		declared,
 		removed,
 		cascade,
+		dropped: dropped.map(({ kind, path }) => ({
+			kind,
+			path
+		})),
 		...blocked === void 0 ? {} : { blocked },
 		...refused.collisions ? { collisions: refused.collisions } : {},
 		patches
 	};
 }
 /**
+* The pin's directives an unlink leaves with nothing to do: on a path that no longer derives through
+* the pin, and either on a row the unlink retires or naming one.
+*/
+function deadDirectives({ config, after, slug, removed }) {
+	const gone = new Set(removed.map(({ kind, path }) => `${kind}:${path}`));
+	return config.sourceDirectives(slug).filter((directive) => directive.kind !== void 0 && after.resolve(directive.kind, directive.path)?.borrowedFrom !== slug && (gone.has(`${directive.kind}:${directive.path}`) || collectRefs(config.sourceOverlay(slug, directive.kind, directive.path)).some((target) => gone.has(target))));
+}
+/**
 * Leave paths of a linked system out, with a `!` entry each in the pin's `link`. Stronger than
 * `unlink`: nothing derives there however the link reaches it, a linked token naming it included,
 * and the linked tokens' overrides under an excluded modifier are left out of the build. `link` with

package/dist/framework/Config.d.ts

@@ -1942,6 +1942,42 @@ declare class Config {
     alongside?: ReadonlySet<string>;
     extend?: Record<string, unknown>;
   }): Record<string, unknown> | undefined;
+  /**
+   * One of a source's folders' meta as a copy stores it — its refs spelled from here as
+   * {@link copyOf} spells a body's. The meta as the source holds it names its own pins by their slugs
+   * there: the Bridge's `icons` folder names `package:@yahoo/uds-icons@yos`, and stored as it was that
+   * names a pin this config doesn't have. `undefined` when the source has no folder there.
+   */
+  copyOfGroup({
+    slug,
+    kind,
+    path,
+    alongside
+  }: {
+    slug: string;
+    kind: string;
+    path: string; /** `kind:path` targets landing as this config's own in the same edit. */
+    alongside?: ReadonlySet<string>;
+  }): Record<string, unknown> | undefined;
+  /**
+   * `body` with each ref routed through another system's pin (`@yos-v3~yos`) respelled through this
+   * config's own pin to the same system, where that pin's source holds the target too: a copy then
+   * names what this config reaches directly rather than keeping the pin it came through referenced.
+   * Bare when this config already holds the target as a pointer through that pin.
+   */
+  private throughDirectPins;
+  /**
+   * The pin of this config's own that reaches the system a routed source ends at — `yahoo-os` for
+   * `yos-v3~yos`, when this config pins directly what `yos-v3` pins as `yos`. Matched on the pin
+   * kind's `sourceOrigin`, so the two pins may name different versions. `undefined` for a source of
+   * one hop, or one whose system no pin here reaches.
+   *
+   * The two pins match when they agree on every origin field both set, and share at least one. Not on
+   * the whole key: a pin by path is stamped with its sibling's id when it's pushed, so the Bridge's
+   * `yos` reads `configPath` and `systemId` where this config's pin to the same system names only the
+   * id — and a `configPath` is relative to the config holding it, so it can't be compared across two.
+   */
+  private directRoute;
   /**
    * Whether a copied row no longer matches what its source offers at the path it was copied from.
    *
@@ -2255,6 +2291,16 @@ declare class Config {
    * that reaches derivation — a deleted extension whose source reached the row — says what it did.
    */
   private assertDerivedDropsUnreferenced;
+  /**
+   * Whether every directive of `pin` that names `target` sits on a path that no longer derives through
+   * it — retired by this derivation, or drawn from another source already. Such a directive lays its
+   * value over no row, so it goes with the link rather than being stranded by it: a pin's own
+   * `options` never refuse removing its link. A directive on a row the pin still mints does, since
+   * that row would be left pointing at nothing.
+   *
+   * `false` when `pin` is not a source, or names `target` somewhere other than a directive.
+   */
+  private directivesGoWith;
   /**
    * This config with a row for every entity it inherits — the build's output. A pin patch runs this
    * inside {@link apply}; a source attaching runs it through the session.
@@ -2513,6 +2559,8 @@ declare class Config {
    */
   sourceIdentityKey(kind: string, path: string): string | undefined;
   private sourceKey;
+  /** Each of a pin's `of` fields as it reads, `''` where unset, in the kind's order. */
+  private sourceFields;
   /**
    * Where what this config shows at `path` originates: the system it was first authored in, followed
    * through however many pins it took to get here. `undefined` for a row this config authored itself.

package/dist/framework/Config.js

@@ -3935,25 +3935,85 @@ var Config = class Config {
 			path,
 			derives
 		});
-		if (!theirs || !extend) return theirs;
-		const laid = overlayBody({
+		if (!theirs) return void 0;
+		const laid = extend ? overlayBody({
 			overlay: {
 				extend,
 				hidden: false
 			},
 			theirs
-		});
-		if (laid && redirectOf(laid).target !== void 0) return this.laidLinkedBody({
+		}) : void 0;
+		return this.throughDirectPins(laid ? this.laidLinkedBody({
 			kind,
 			path,
 			body: theirs,
 			extend: laid,
 			source: this.sourceFor(slug)
-		});
-		return laid ? {
-			...theirs,
-			...laid
-		} : theirs;
+		}) : theirs);
+	}
+	/**
+	* One of a source's folders' meta as a copy stores it — its refs spelled from here as
+	* {@link copyOf} spells a body's. The meta as the source holds it names its own pins by their slugs
+	* there: the Bridge's `icons` folder names `package:@yahoo/uds-icons@yos`, and stored as it was that
+	* names a pin this config doesn't have. `undefined` when the source has no folder there.
+	*/
+	copyOfGroup({ slug, kind, path, alongside }) {
+		const source = this.sourceFor(slug);
+		const meta = source?.groups(kind).find((group) => group.path === path)?.meta;
+		if (!source || !meta) return void 0;
+		return this.throughDirectPins(qualifyRefs({
+			value: meta,
+			source: slug,
+			owns: (kindName) => source.ownedKinds().includes(kindName),
+			namesItAlready: (target) => alongside?.has(`${kindOf(target)}:${pathOf(target)}`) === true || this.borrowsExactly(target, slug)
+		}));
+	}
+	/**
+	* `body` with each ref routed through another system's pin (`@yos-v3~yos`) respelled through this
+	* config's own pin to the same system, where that pin's source holds the target too: a copy then
+	* names what this config reaches directly rather than keeping the pin it came through referenced.
+	* Bare when this config already holds the target as a pointer through that pin.
+	*/
+	throughDirectPins(body) {
+		let respelled = body;
+		for (const target of new Set(collectRefs(body))) {
+			const { kind, path, source } = splitRef(target);
+			if (source === void 0) continue;
+			const direct = this.directRoute(source);
+			if (direct === void 0 || !this.sourceFor(direct)?.resolve(kind, path)) continue;
+			const through = ref(kind, path, direct);
+			respelled = rewriteRefs(respelled, `${kind}:${path}@${source}`, this.borrowsExactly(through, direct) ? `${kind}:${path}` : through.__ref);
+		}
+		return respelled;
+	}
+	/**
+	* The pin of this config's own that reaches the system a routed source ends at — `yahoo-os` for
+	* `yos-v3~yos`, when this config pins directly what `yos-v3` pins as `yos`. Matched on the pin
+	* kind's `sourceOrigin`, so the two pins may name different versions. `undefined` for a source of
+	* one hop, or one whose system no pin here reaches.
+	*
+	* The two pins match when they agree on every origin field both set, and share at least one. Not on
+	* the whole key: a pin by path is stamped with its sibling's id when it's pushed, so the Bridge's
+	* `yos` reads `configPath` and `systemId` where this config's pin to the same system names only the
+	* id — and a `configPath` is relative to the config holding it, so it can't be compared across two.
+	*/
+	directRoute(source) {
+		const hops = sourceHops(source);
+		const last = hops.pop();
+		if (last === void 0 || hops.length === 0) return void 0;
+		let through = this;
+		for (const hop of hops) through = through?.sourceFor(hop);
+		if (!through) return void 0;
+		for (const sourceKind of through.sourceKinds()) {
+			const theirs = through.sourceFields(sourceKind, last, "sourceOrigin");
+			if (theirs === void 0) continue;
+			const direct = this.sourceSlugs().find((slug) => {
+				const mine = this.sourceFields(sourceKind, slug, "sourceOrigin");
+				const shared = theirs.flatMap((value, field) => value !== "" && mine?.[field] ? [field] : []);
+				return shared.length > 0 && shared.every((field) => theirs[field] === mine?.[field]);
+			});
+			if (direct !== void 0) return direct;
+		}
 	}
 	/**
 	* Whether a copied row no longer matches what its source offers at the path it was copied from.
@@ -4584,11 +4644,16 @@ var Config = class Config {
 	assertDerivedDropsUnreferenced({ action = "remove the link", derivation = this.rowDerivation() } = {}) {
 		const { snapshot } = this.state;
 		const contested = new Set(derivation.collisions.map(({ kind, path }) => `${kind}:${path}`));
+		const retired = new Set(derivation.changes.filter((change) => change.value === void 0).map(({ kind, path }) => `${kind}:${path}`));
 		const stranded = [];
 		let collides = false;
 		for (const change of derivation.changes) {
 			if (change.value !== void 0) continue;
-			const referrers = this.referrersOf(snapshot, change.kind, change.path).filter((referrer) => !isMintedAt(snapshot, referrer));
+			const referrers = this.referrersOf(snapshot, change.kind, change.path).filter((referrer) => !isMintedAt(snapshot, referrer) && !this.directivesGoWith({
+				pin: referrer,
+				target: change,
+				retired
+			}));
 			if (referrers.length === 0) continue;
 			if (contested.has(`${change.kind}:${change.path}`)) collides = true;
 			stranded.push(`${change.kind}:${change.path} (used by ${referrers.join(", ")})`);
@@ -4598,6 +4663,23 @@ var Config = class Config {
 		reject("REFERRERS_BLOCK", `Cannot ${action} — it would take away ${stranded.join("; ")}. Copy what is used first (\`linked-system/copy\`), or break the link keeping its values (\`linked-system/break\` with \`keep: true\`).`);
 	}
 	/**
+	* Whether every directive of `pin` that names `target` sits on a path that no longer derives through
+	* it — retired by this derivation, or drawn from another source already. Such a directive lays its
+	* value over no row, so it goes with the link rather than being stranded by it: a pin's own
+	* `options` never refuse removing its link. A directive on a row the pin still mints does, since
+	* that row would be left pointing at nothing.
+	*
+	* `false` when `pin` is not a source, or names `target` somewhere other than a directive.
+	*/
+	directivesGoWith({ pin, target, retired }) {
+		if (!this.entityOf(kindOf(pin))?.sourceIdentity) return false;
+		const slug = pathOf(pin);
+		const aliases = new Set(this.refAliases(target.kind, target.path));
+		const naming = this.sourceDirectives(slug).filter((directive) => directive.kind !== void 0 && collectRefs(this.sourceOverlay(slug, directive.kind, directive.path)).some((ref) => aliases.has(ref)));
+		if (naming.length === 0) return false;
+		return naming.every(({ kind, path }) => retired.has(`${kind}:${path}`) || this.resolve(kind, path)?.borrowedFrom !== slug);
+	}
+	/**
 	* This config with a row for every entity it inherits — the build's output. A pin patch runs this
 	* inside {@link apply}; a source attaching runs it through the session.
 	*
@@ -5415,6 +5497,10 @@ var Config = class Config {
 		return this.sourceKey(kind, path, "sourceIdentity");
 	}
 	sourceKey(kind, path, of) {
+		return this.sourceFields(kind, path, of)?.join("\0");
+	}
+	/** Each of a pin's `of` fields as it reads, `''` where unset, in the kind's order. */
+	sourceFields(kind, path, of) {
 		const entry = this.entityOf(kind);
 		const fields = entry?.[of] ?? entry?.sourceIdentity;
 		if (!fields) return void 0;
@@ -5423,7 +5509,7 @@ var Config = class Config {
 		return fields.map((field) => {
 			const value = body[field];
 			return value === void 0 ? "" : String(value);
-		}).join("\0");
+		});
 	}
 	/**
 	* Where what this config shows at `path` originates: the system it was first authored in, followed