@yahoo/uds-create-config 5.56.4 → 5.57.1

package/dist/configs/system.js

@@ -30,6 +30,7 @@ import { directLayerCompositesMigration } from "../migrations/20261022124223_dir
 import { cssContentScriptsMigration } from "../migrations/20261022152120_css_content_scripts.js";
 import { linkTypeMigration } from "../migrations/20261022184639_link_type.js";
 import { conditionalDefaultsMigration } from "../migrations/20261023152030_conditional_defaults.js";
+import { timingValueMigration } from "../migrations/20261026125912_timing_value.js";
 import { CanvasRole } from "../entities/system/CanvasRole.js";
 import { GlobalStyle } from "../entities/system/GlobalStyle.js";
 import { Guidance } from "../entities/system/Guidance.js";
@@ -193,5 +194,6 @@ if (!registeredSchemaMigrations().has(20261020183330)) {
 if (!registeredSchemaMigrations().has(20261022152120)) registerSchemaMigrations(cssContentScriptsMigration);
 if (!registeredSchemaMigrations().has(20261022184639)) registerSchemaMigrations(linkTypeMigration);
 if (!registeredSchemaMigrations().has(20261023152030)) registerSchemaMigrations(conditionalDefaultsMigration);
+if (!registeredSchemaMigrations().has(20261026125912)) registerSchemaMigrations(timingValueMigration);
 //#endregion
 export { System };

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/Token.js

@@ -33,7 +33,7 @@ const tokenValue = z.union([
 	z.lazy(() => Token),
 	Font,
 	...composedValueSchemas
-], { error: "a token's `value` is one CSS value as a string (`#1DB954`, `4px`, `\"Circular\", sans-serif`), a number, a ref to another token or to a font (`{ \"__ref\": \"font:<name>\" }`), a derived color (`{ \"op\": \"darken\", \"color\": { \"__ref\": \"token:color/brand\" }, \"amount\": 10 }`), a gradient, or a transition (`{ \"transition\": [{ \"properties\": [\"background-color\"], \"timing\": { \"__ref\": \"token:motion/color\" } }] }`). It is required; a font family is a string value or a `font` entity, never a field of its own." });
+], { error: "a token's `value` is one CSS value as a string (`#1DB954`, `4px`, `\"Circular\", sans-serif`), a number, a ref to another token or to a font (`{ \"__ref\": \"font:<name>\" }`), a derived color (`{ \"op\": \"darken\", \"color\": { \"__ref\": \"token:color/brand\" }, \"amount\": 10 }`), a gradient, a transition (`{ \"transition\": [{ \"properties\": [\"background-color\"], \"timing\": { \"__ref\": \"token:motion/color\" } }] }`), or a timing (`{ \"timing\": { \"duration\": { \"__ref\": \"token:motionDuration/150\" }, \"easing\": { \"__ref\": \"token:motionEasing/linear\" } } }`). It is required; a font family is a string value or a `font` entity, never a field of its own." });
 /**
 * What an override applies under: one modifier, or several that all hold at once (`dark` and `lg`
 * together). Each is a ref, so the override is an ordinary edge: the dependency graph sees every

package/dist/entities/system/composed-values.d.ts

@@ -3,10 +3,11 @@ import { Add, Divide, Max, Min, Multiply, Subtract } from "./calc.js";
 import { DerivedColor, Gradient, OklchColor } from "./color.js";
 import { Shadow } from "./shadow.js";
 import { Transition } from "./transition.js";
+import { Timing } from "./timing.js";
 import { z } from "zod";
 
 //#region src/entities/system/composed-values.d.ts
-type ComposedValue = Multiply | Divide | Add | Subtract | Max | Min | OklchColor | DerivedColor | Gradient | Transition | Shadow;
+type ComposedValue = Multiply | Divide | Add | Subtract | Max | Min | OklchColor | DerivedColor | Gradient | Transition | Timing | Shadow;
 /** How the write engine spells a stored value: the helper's name and its positional arguments. */
 interface ComposedValueAuthoring {
   readonly helper: string;

package/dist/entities/system/composed-values.js

@@ -1,6 +1,7 @@
 import { addAuthoring, addValue, calcOperands, divideAuthoring, divideValue, evaluateCalc, isAdd, isCalc, isDivide, isMax, isMin, isMultiply, isSubtract, maxAuthoring, maxValue, minAuthoring, minValue, multiplyAuthoring, multiplyValue, renderCalc, subtractAuthoring, subtractValue } from "./calc.js";
 import { derivedColor, derivedColorAuthoring, gradient, gradientAuthoring, isDerivedColor, isGradient, isOklchColor, oklchAuthoring, oklchColor, renderDerivedColor, renderGradient, renderOklch } from "./color.js";
 import { isShadow, renderShadow, shadowAuthoring, shadowValue } from "./shadow.js";
+import { isTiming, renderTiming, timingAuthoring, timingValue } from "./timing.js";
 import { isTransition, renderTransition, transitionAuthoring, transitionValue } from "./transition.js";
 //#region src/entities/system/composed-values.ts
 /** Arithmetic as a formula: `spacing × 4`, `1.25 ÷ 0.875`, `gap + (spacing × 2)`. A term that is
@@ -102,6 +103,12 @@ const composedValueForms = [
 		render: renderTransition,
 		authoring: transitionAuthoring
 	}),
+	form({
+		schema: timingValue,
+		is: isTiming,
+		render: renderTiming,
+		authoring: timingAuthoring
+	}),
 	form({
 		schema: shadowValue,
 		is: isShadow,

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/entities/system/timing.d.ts

@@ -0,0 +1,28 @@
+import { TimingValue } from "./transition.js";
+import { z } from "zod";
+
+//#region src/entities/system/timing.d.ts
+/** Each part is a literal (`'150ms'`, `'ease-out'`) or a ref to the token that names it. */
+interface TimingParts {
+  readonly duration: TimingValue;
+  readonly easing: TimingValue;
+  readonly delay?: TimingValue;
+}
+interface Timing {
+  readonly timing: TimingParts;
+}
+/** Whether a value is a composed timing — the test the renderers branch on. A transition segment's
+ *  own `timing` field is a literal or a ref, so it is not one. */
+declare function isTiming(value: unknown): value is Timing;
+/** `timing({ duration: Token.ref('motionDuration/150'), easing: Token.ref('motionEasing/linear') })`. */
+declare function timing(parts: TimingParts): Timing;
+/**
+ * A timing as CSS — `var(--uds-motion-duration-150) var(--uds-motion-easing-linear)`, in the order
+ * the `transition` shorthand reads it: the first time is the duration and the second the delay.
+ *
+ * `render` resolves the parts. It is passed in rather than imported because resolving a ref to a
+ * `var()` is the projection layer's job and this module is the value's shape.
+ */
+declare function renderTiming(value: Timing, render: (part: TimingValue) => string): string;
+//#endregion
+export { Timing, TimingParts, isTiming, renderTiming, timing };

package/dist/entities/system/timing.js

@@ -0,0 +1,56 @@
+import { isRef, refSchema } from "../../framework/utils/refs.js";
+import { z } from "zod";
+//#region src/entities/system/timing.ts
+/**
+* A transition timing composed from a duration and an easing —
+* `timing({ duration: Token.ref('motionDuration/150'), easing: Token.ref('motionEasing/linear') })`.
+*
+* A motion role (`motion/color`) is a duration and an easing that a system names together, and each
+* is its own token. Spelled as one string, the pair is copied in, or names the variables as text,
+* which a link to a system with another prefix leaves pointing at nothing. Held as parts, each is a
+* ref, so it renders as that token's `var()` and the dependency graph sees it.
+*
+* Usable wherever a style value is, and as the `timing` a transition's segment refers to.
+*/
+const timingPart = z.union([z.string(), refSchema]);
+const timingValue = z.strictObject({ timing: z.strictObject({
+	duration: timingPart,
+	easing: timingPart,
+	delay: timingPart.optional()
+}) });
+const isPart = (part) => typeof part === "string" || isRef(part);
+/** Whether a value is a composed timing — the test the renderers branch on. A transition segment's
+*  own `timing` field is a literal or a ref, so it is not one. */
+function isTiming(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const parts = value.timing;
+	return typeof parts === "object" && parts !== null && isPart(parts.duration) && isPart(parts.easing) && (parts.delay === void 0 || isPart(parts.delay));
+}
+/** `timing({ duration: Token.ref('motionDuration/150'), easing: Token.ref('motionEasing/linear') })`. */
+function timing(parts) {
+	return { timing: parts };
+}
+/** The `timing(...)` call that authors a stored value: its parts are the argument. */
+function timingAuthoring(value) {
+	return {
+		helper: "timing",
+		args: [value.timing]
+	};
+}
+/**
+* A timing as CSS — `var(--uds-motion-duration-150) var(--uds-motion-easing-linear)`, in the order
+* the `transition` shorthand reads it: the first time is the duration and the second the delay.
+*
+* `render` resolves the parts. It is passed in rather than imported because resolving a ref to a
+* `var()` is the projection layer's job and this module is the value's shape.
+*/
+function renderTiming(value, render) {
+	const { duration, easing, delay } = value.timing;
+	return [
+		duration,
+		easing,
+		delay
+	].filter((part) => part !== void 0).map(render).join(" ");
+}
+//#endregion
+export { isTiming, renderTiming, timing, timingAuthoring, timingValue };

package/dist/framework/Config.d.ts

@@ -73,7 +73,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 = 20261023152030;
+declare const SERIALIZED_CONFIG_VERSION = 20261026125912;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;
@@ -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
@@ -6070,7 +6156,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 > 20261023152030) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20261026125912) 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.`);
 		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 = 20261023152030;
+declare const CURRENT_SCHEMA_VERSION = 20261026125912;
 /** 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 = 20261023152030;
+const CURRENT_SCHEMA_VERSION = 20261026125912;
 /** 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 > 20261023152030) 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 > 20261026125912) 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 ?? 20261023152030;
+	const target = options?.target ?? 20261026125912;
 	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 ?? 20261023152030;
+	const target = options?.target ?? 20261026125912;
 	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 ?? 20261023152030;
+	const target = options?.target ?? 20261026125912;
 	const entries = [];
 	const held = [];
 	const retired = [];