@yahoo/uds-create-config 5.58.0 → 5.59.1

package/dist/entities/system/LinkedSystem.js

@@ -303,8 +303,8 @@ const LinkedSystemDefinition = defineEntity({
 		* Draw entities from a linked system: the pin's `link` declaration grows to cover them and the
 		* build mints a pointer row per entity, in this one op. A row of this config's own at a covered
 		* path is deleted so theirs shows through; a row held through another pin becomes an extension
-		* through this one when `onLinked` is `'take'`. `link-plan` says what that replaces before anything
-		* is written.
+		* through this one when `onLinked` is `'take'`, and the other pin's `options` entry there goes with
+		* it. `link-plan` says what that replaces before anything is written.
 		*/
 		link: {
 			input: linkInput,
@@ -332,7 +332,7 @@ const LinkedSystemDefinition = defineEntity({
 			input: linkInput,
 			readOnly: true,
 			label: "Plan a link",
-			description: "What `link` with the same input replaces — rows of yours deleted so the source shows through, every path another linked system provides (`linked`, turned into extensions when `onLinked` says take), 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 — 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.",
 			scope: "item",
 			title: (entity) => `Plan a link from ${entity}`,
 			example: linkExample,

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

@@ -22,6 +22,13 @@ interface LinkedElsewhere extends EntityAddress {
   /** The slug of the pin it comes through. */
   readonly from: string;
 }
+/** An entry in another pin's `options` that a take leaves applying to nothing, and removes. */
+interface DroppedDirective extends EntityAddress {
+  /** The slug of the pin whose entry it was. */
+  readonly from: string;
+  /** The accessor the entry sits under in that pin's `options`. */
+  readonly accessor: string;
+}
 /** One row a link mints. `named` when a path the call named covers it; otherwise it comes along
  *  because something linked points at it. */
 interface LinkArrival extends EntityAddress {
@@ -40,6 +47,10 @@ interface LinkPlan {
   readonly linked: readonly LinkedElsewhere[];
   /** Rows held through another pin, turned into extensions through this one. */
   readonly extended: readonly EntityAddress[];
+  /** The other pins' `options` entries at what the take moves, removed with it: they adjust only the
+   *  rows their pin derives, and the row there follows this one now. Not carried onto the taken row,
+   *  since an entry corrects what that pin brings rather than stating a value of this config's own. */
+  readonly dropped: readonly DroppedDirective[];
   /** Members already here from the source's own origin, left alone and kept out of the declaration. */
   readonly shared: readonly EntityAddress[];
   /** Paths another pin offers that a `hybrid` link reaches as a different entity. The other pin's
@@ -193,4 +204,4 @@ declare function sourceRowStates({
   readonly slug: string;
 }): SourceRowState[];
 //#endregion
-export { BreakOutcome, BreakPlan, BreakPlanInput, BreakPlanRow, BreakReach, LinkArrival, LinkPaths, LinkPlan, LinkPlanInput, LinkedElsewhere, OnLinked, SourceRowState, UnlinkPlan, UnlinkPlanInput, planBreak, planLink, planUnlink, sourceRowStates };
+export { BreakOutcome, BreakPlan, BreakPlanInput, BreakPlanRow, BreakReach, DroppedDirective, LinkArrival, LinkPaths, LinkPlan, LinkPlanInput, LinkedElsewhere, OnLinked, SourceRowState, UnlinkPlan, UnlinkPlanInput, planBreak, planLink, planUnlink, sourceRowStates };

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

@@ -1,7 +1,8 @@
 import { collectRefs, isMintedRow, ref, sourceOf, splitRef } from "../../framework/utils/refs.js";
 import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { blockedBy } from "../../framework/plan.js";
-import { excludedCondition } from "../../framework/source-integrity.js";
+import { danglingDirectives, excludedCondition } from "../../framework/source-integrity.js";
+import { sameOrigin } from "../../framework/Config.js";
 import { PIN_KIND, covers, declarationOf, entriesFor, excludePaths, excludes, includePaths, narrowDeclaration } from "./link-declaration.js";
 import { planCopy, sourceEntries } from "./copy-plan.js";
 //#region src/entities/system/link-plan.ts
@@ -40,7 +41,7 @@ function sharedWithOrigin({ config, source, slug, kind, path }) {
 		kind,
 		path
 	});
-	if (!theirs || !mine || theirs.key !== mine.key) return void 0;
+	if (!theirs || !mine || !sameOrigin(theirs, mine)) return void 0;
 	return theirs.pin.displayName ?? theirs.key;
 }
 /** Another pin whose declaration covers the path and whose source has it: the pin the path would
@@ -237,11 +238,20 @@ function planLink({ config, input }) {
 		}
 		declared = Object.keys(next).length === 0 ? current : next;
 	}
-	const patches = [
+	const planned = [
 		...takes,
 		...declares,
 		...shadows
 	];
+	const { dropped, patches: drops } = takes.length > 0 ? directivesTakenFrom({
+		config,
+		slug,
+		patches: planned
+	}) : {
+		dropped: [],
+		patches: []
+	};
+	const patches = [...planned, ...drops];
 	return {
 		declared,
 		...outcome({
@@ -254,10 +264,74 @@ function planLink({ config, input }) {
 		addresses,
 		linked,
 		extended,
+		dropped,
 		shared,
 		patches
 	};
 }
+/**
+* The other pins' `options` entries a take leaves applying to nothing, and the pin edits that remove
+* them.
+*
+* An entry adjusts the rows its pin derives. A take writes this config's own row at the path, one that
+* follows `slug`, so the other pin's entry stays in its `options` reading as though it still applied,
+* and the build refuses it ({@link danglingDirectives}). Read off the config the take leaves, so a
+* folder whose members all moved counts the way the build will count it, and only what the take
+* itself left behind: an entry that already applied to nothing is the build's to report, not this
+* take's to remove.
+*
+* Nothing when the take is refused; `outcome` says why.
+*/
+function directivesTakenFrom({ config, slug, patches }) {
+	let after;
+	try {
+		after = config.applyAll(patches).withDerivedRows();
+	} catch (error) {
+		if (!isConfigRejection(error)) throw error;
+		return {
+			dropped: [],
+			patches: []
+		};
+	}
+	const key = (at) => `${at.slug}\u0000${at.accessor}\u0000${at.path}`;
+	const already = new Set(danglingDirectives(config).map(key));
+	const dropped = [];
+	for (const at of danglingDirectives(after)) {
+		if (at.missing !== "row" || at.heldBy !== slug || already.has(key(at))) continue;
+		dropped.push({
+			kind: config.accessors()[at.accessor]?.kind ?? at.accessor,
+			path: at.path,
+			from: at.slug,
+			accessor: at.accessor
+		});
+	}
+	const edits = [];
+	for (const pin of new Set(dropped.map((at) => at.from))) {
+		const options = config.storedBody("linked-system", pin).options ?? {};
+		const data = {};
+		let emptied = 0;
+		for (const [accessor, entries] of Object.entries(options)) {
+			const going = dropped.filter((at) => at.from === pin && at.accessor === accessor).map((at) => at.path);
+			if (going.length === 0) continue;
+			if (Object.keys(entries ?? {}).filter((path) => !going.includes(path)).length > 0) {
+				for (const path of going) data[`options.${accessor}.${path}`] = null;
+				continue;
+			}
+			data[`options.${accessor}`] = null;
+			emptied += 1;
+		}
+		edits.push({
+			kind: PIN_KIND,
+			operation: "update",
+			path: pin,
+			data: emptied === Object.keys(options).length ? { options: null } : data
+		});
+	}
+	return {
+		dropped,
+		patches: edits
+	};
+}
 /** What a plan reports of a refusal: its message, and the collisions when that's what it names. */
 function refusal(error) {
 	const collisions = error.issues.flatMap((issue) => issue.collisions ?? []);

package/dist/framework/Config.d.ts

@@ -1972,10 +1972,7 @@ declare class Config {
    * 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.
+   * The two pins match by {@link sameOriginFields}.
    */
   private directRoute;
   /**
@@ -2569,11 +2566,15 @@ declare class Config {
    * to a system linked to a foundation answers with the foundation. A row a materialized artifact
    * flattened to a literal has no pointer left, so the pin whose `link` declaration covers the path
    * stands in, provided the row still reads as the source's ({@link matchesSource}); one the
-   * publisher changed is its own. Two answers with one `key` are one entity reached by two routes,
-   * whatever versions the pins name: the key is the pin kind's `sourceOrigin`, not its identity.
+   * publisher changed is its own, and so is a linked row this config lays a value of its own over: the
+   * Bridge's `spectrum/blue/0` points at Yahoo OS's with the Bridge's colours on it, which is the
+   * Bridge's entity, not a second route to Yahoo OS's. Two answers that are {@link sameOrigin} are one
+   * entity reached by two routes, whatever versions the pins name: they compare the pin kind's
+   * `sourceOrigin`, not its identity.
    *
    * `pin` is the pin entity at the hop where the answer was found, for a surface that names the
-   * origin the way it names any source.
+   * origin the way it names any source. `key` is its origin fields joined, for a surface with no
+   * name to show.
    */
   originOf({
     kind,
@@ -2581,10 +2582,7 @@ declare class Config {
   }: {
     kind: string;
     path: string;
-  }): {
-    key: string;
-    pin: Entity;
-  } | undefined;
+  }): Origin | undefined;
   /**
    * The pin whose `link` declaration covers `kind:path` while the row there still reads as that
    * source's: how a row a materialized artifact flattened to a literal is traced back to the pin it
@@ -2899,5 +2897,14 @@ declare class Config {
    *  links from the provided sources. A declared `linkedKind` with no provided source throws. */
   protected hydrateFrom(stored: StoredConfig, options?: HydrationOptions): this;
 }
+/** Where an entity originates ({@link Config.originOf}): the pin at the hop that answered, and its origin fields. */
+interface Origin {
+  readonly key: string;
+  /** The pin kind's `sourceOrigin` fields as the pin reads them, `''` where unset. */
+  readonly fields: readonly string[];
+  readonly pin: Entity;
+}
+/** Whether two {@link Config.originOf} answers are one origin, by {@link sameOriginFields}. */
+declare function sameOrigin(a: Origin, b: Origin): boolean;
 //#endregion
-export { AppliedOp, AttachedSources, BatchReceipt, Config, CssGrammar, Edition, HydrationOptions, ListOptions, LiveConfig, Patch, RecordedSource, SERIALIZED_CONFIG_VERSION, SerializedConfig, SettledSource, SkippedOp, SourceCollision, SourcesBySlug, StoredConfig, SubPatch, TreeNode };
+export { AppliedOp, AttachedSources, BatchReceipt, Config, CssGrammar, Edition, HydrationOptions, ListOptions, LiveConfig, Origin, Patch, RecordedSource, SERIALIZED_CONFIG_VERSION, SerializedConfig, SettledSource, SkippedOp, SourceCollision, SourcesBySlug, StoredConfig, SubPatch, TreeNode, sameOrigin };

package/dist/framework/Config.js

@@ -3992,10 +3992,7 @@ var Config = class Config {
 	* 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.
+	* The two pins match by {@link sameOriginFields}.
 	*/
 	directRoute(source) {
 		const hops = sourceHops(source);
@@ -4009,8 +4006,7 @@ var Config = class Config {
 			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]);
+				return mine !== void 0 && sameOriginFields(theirs, mine);
 			});
 			if (direct !== void 0) return direct;
 		}
@@ -5142,6 +5138,40 @@ var Config = class Config {
 		const folders = [];
 		/** Folders this pass leaves as they stand — already held, over rows it still claims. */
 		const standing = /* @__PURE__ */ new Set();
+		const taken = [];
+		for (const kind of this.ownedKinds()) for (const [path, stored] of this.state.snapshot.slice(kind).items) {
+			const body = stored.toJSON();
+			if (!isExtendedRef(body) || isMintedRow(body)) continue;
+			if (pathOf(body) !== path) continue;
+			const slug = sourceOf(body);
+			if (slug !== void 0) taken.push({
+				kind,
+				path,
+				slug
+			});
+		}
+		/** Every folder a pin has a member under this pass, claimed or taken, as `slug kind path`. */
+		const occupied = /* @__PURE__ */ new Set();
+		const occupy = (slug, kind, path) => {
+			const segments = path.split("/");
+			for (let depth = 1; depth < segments.length; depth++) occupied.add(`${slug}\u0000${kind}\u0000${segments.slice(0, depth).join("/")}`);
+		};
+		for (const [target, slug] of claimedFrom) occupy(slug, kindOf(target), pathOf(target));
+		for (const { kind, path, slug } of taken) occupy(slug, kind, path);
+		/**
+		* Whether a folder already here stays as it is. One this config authored does, and so does one
+		* minted through a pin that still has a member under it. One minted through a pin that has none
+		* left there goes to the pin its members follow now: after a take, a `colorMode` whose modes all
+		* follow Yahoo OS kept pointing at the Bridge's, its fields read from a system none of it follows.
+		*/
+		const stands = (kind, path) => {
+			const held = this.state.snapshot.group(kind, path)?.toJSON();
+			if (held === void 0) return false;
+			if (!isMintedRow(held)) return true;
+			const pointer = held.ref;
+			const through = isRef(pointer) ? sourceOf(pointer) : void 0;
+			return through !== void 0 && occupied.has(`${through}\u0000${kind}\u0000${path}`);
+		};
 		for (const [slug, paths] of offeredBy) {
 			const source = this.sourceFor(slug);
 			if (!source) continue;
@@ -5153,7 +5183,7 @@ var Config = class Config {
 				for (const group of source.groups(kind)) {
 					const prefix = `${group.path}/`;
 					if (!under.some((path) => path.startsWith(prefix))) continue;
-					if (this.state.snapshot.group(kind, group.path)) {
+					if (stands(kind, group.path)) {
 						standing.add(`group:${kind}:${group.path}`);
 						continue;
 					}
@@ -5166,6 +5196,27 @@ var Config = class Config {
 				}
 			}
 		}
+		const derivedFolders = new Set(folders.map(({ kind, path }) => `${kind}:${path}`));
+		for (const { kind, path, slug } of taken) {
+			const source = this.sourceFor(slug);
+			if (!source || !this.entityOf(kind)) continue;
+			for (const group of source.groups(kind)) {
+				if (!path.startsWith(`${group.path}/`)) continue;
+				const target = `${kind}:${group.path}`;
+				if (derivedFolders.has(target) || standing.has(`group:${target}`)) continue;
+				if (stands(kind, group.path)) {
+					standing.add(`group:${target}`);
+					continue;
+				}
+				derivedFolders.add(target);
+				folders.push({
+					kind,
+					path: group.path,
+					slug
+				});
+				claimedFrom.set(target, slug);
+			}
+		}
 		for (const [target, slug] of claimedFrom) {
 			if (folders.some(({ kind, path }) => `${kind}:${path}` === target)) continue;
 			changes.push(derivedItemChange(kindOf(target), pathOf(target), ref(kindOf(target), pathOf(target), slug).__ref, overlayBody({
@@ -5328,7 +5379,22 @@ var Config = class Config {
 		const source = this.sourceFor(slug);
 		if (!source) return [];
 		const members = /* @__PURE__ */ new Set();
-		const walked = /* @__PURE__ */ new Set();
+		/**
+		* Every entity or folder visited, and whether a linked row reached it.
+		*
+		* A taken row is visited twice — first as an authored row, then as one its pin adopts — and only a
+		* linked visit lands the items a body points at. Remembering only THAT a target was visited let the
+		* unlinked pass claim the style properties and token folders it found, so the linked pass skipped
+		* them and a mode their tokens vary under never got a row. A target reached unlinked is visited
+		* again when a linked row reaches it; one reached linked is done.
+		*/
+		const reached = /* @__PURE__ */ new Map();
+		const reaching = (target, linked) => {
+			const prior = reached.get(target);
+			if (prior === true || prior === false && !linked) return false;
+			reached.set(target, linked);
+			return true;
+		};
 		/**
 		* A style bag's KEYS name style properties, and a borrowed bag's name the SOURCE's.
 		*
@@ -5346,11 +5412,11 @@ var Config = class Config {
 			if (!sites) return;
 			for (const { bag } of sites(body)) for (const prop of Object.keys(bag)) {
 				const target = `style-property:${prop}`;
-				if (members.has(target)) continue;
 				const local = this.storedBody("style-property", prop);
 				if (local && !isMintedRow(local)) continue;
 				const declared = source.resolve("style-property", prop);
 				if (!declared) continue;
+				if (!reaching(target, linked)) continue;
 				members.add(target);
 				visitEntity("style-property", declared.toJSON(), true, linked);
 			}
@@ -5381,19 +5447,19 @@ var Config = class Config {
 				const target = `${kind}:${path}`;
 				const item = source.resolve(kind, path);
 				if (item) {
-					if (!linked || members.has(target)) continue;
+					if (!linked || !reaching(target, true)) continue;
 					members.add(target);
 					visitEntity(kind, item.toJSON(), true, true);
 					continue;
 				}
-				if (walked.has(target)) continue;
-				walked.add(target);
+				if (!reaching(target, linked)) continue;
 				if (!source.groups(kind).some((node) => node.path === path)) continue;
 				const prefix = `${path}/`;
 				for (const member of source.list(kind)) {
 					if (!member.path.startsWith(prefix)) continue;
-					members.add(`${kind}:${member.path}`);
-					visitEntity(kind, member.toJSON(), true, linked);
+					const at = `${kind}:${member.path}`;
+					members.add(at);
+					if (reaching(at, linked)) visitEntity(kind, member.toJSON(), true, linked);
 				}
 			}
 		};
@@ -5519,15 +5585,21 @@ var Config = class Config {
 	* to a system linked to a foundation answers with the foundation. A row a materialized artifact
 	* flattened to a literal has no pointer left, so the pin whose `link` declaration covers the path
 	* stands in, provided the row still reads as the source's ({@link matchesSource}); one the
-	* publisher changed is its own. Two answers with one `key` are one entity reached by two routes,
-	* whatever versions the pins name: the key is the pin kind's `sourceOrigin`, not its identity.
+	* publisher changed is its own, and so is a linked row this config lays a value of its own over: the
+	* Bridge's `spectrum/blue/0` points at Yahoo OS's with the Bridge's colours on it, which is the
+	* Bridge's entity, not a second route to Yahoo OS's. Two answers that are {@link sameOrigin} are one
+	* entity reached by two routes, whatever versions the pins name: they compare the pin kind's
+	* `sourceOrigin`, not its identity.
 	*
 	* `pin` is the pin entity at the hop where the answer was found, for a surface that names the
-	* origin the way it names any source.
+	* origin the way it names any source. `key` is its origin fields joined, for a surface with no
+	* name to show.
 	*/
 	originOf({ kind, path }) {
 		const held = this.resolve(kind, path);
 		if (!held) return void 0;
+		const stored = this.storedBody(kind, path);
+		if (isExtendedRef(stored) && Object.keys(stored.extend).length > 0) return;
 		let through = held.borrowedFrom;
 		if (through === void 0 && held.copiedThrough !== void 0) {
 			if (this.copyDiffers({
@@ -5543,11 +5615,12 @@ var Config = class Config {
 		});
 		if (upstream) return upstream;
 		for (const sourceKind of this.sourceKinds()) {
-			const key = this.sourceKey(sourceKind, through, "sourceOrigin");
+			const fields = this.sourceFields(sourceKind, through, "sourceOrigin");
 			const pin = this.resolve(sourceKind, through);
-			if (key === void 0 || !pin) continue;
+			if (fields === void 0 || !pin) continue;
 			return {
-				key,
+				key: fields.join("\0"),
+				fields,
 				pin
 			};
 		}
@@ -6325,6 +6398,21 @@ function extendBody(base, delta) {
 /** The paths each config is reading through a re-pointed link, for {@link Config.laidLinkedBody} to
 *  find a loop by. Keyed on the config's state, which every read of one config shares. */
 const redirecting = /* @__PURE__ */ new WeakMap();
+/** Whether two {@link Config.originOf} answers are one origin, by {@link sameOriginFields}. */
+function sameOrigin(a, b) {
+	return sameOriginFields(a.fields, b.fields);
+}
+/**
+* Whether two pins' `sourceOrigin` fields name one system: they agree on every field both set, and
+* share at least one. Not 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 a pin to the same system by id
+* names only the id — and a `configPath` is relative to the config holding it, so it can't be compared
+* across two.
+*/
+function sameOriginFields(theirs, mine) {
+	const shared = theirs.flatMap((value, field) => value !== "" && mine[field] ? [field] : []);
+	return shared.length > 0 && shared.every((field) => theirs[field] === mine[field]);
+}
 /**
 * The entity an `extend` re-points its path to, and the rest of it: a link's `override` written as a
 * ref lands in the stored `extend` as its `__ref`, beside whatever the `extend` verb adds.
@@ -6539,4 +6627,4 @@ function loadGroupChange(meta, kind, path, raw, phase = "author") {
 	};
 }
 //#endregion
-export { Config, SERIALIZED_CONFIG_VERSION };
+export { Config, SERIALIZED_CONFIG_VERSION, sameOrigin };

package/dist/framework/source-integrity.d.ts

@@ -239,12 +239,17 @@ interface DanglingDirective {
   /** The accessor as written — this config may have no kind under it. */
   accessor: string;
   path: string;
-  /** `accessor` when no kind is registered under that name, `path` when the source has no such entity. */
-  missing: 'accessor' | 'path';
+  /**
+   * `accessor` when no kind is registered under that name, `path` when the source has no such entity,
+   * `row` when the source has it but the row here isn't one the pin derives.
+   */
+  missing: 'accessor' | 'path' | 'row';
+  /** With `row`: the pin the row there follows instead, absent when it is this config's own. */
+  heldBy?: string;
 }
 /**
- * Every directive aimed at nothing — an accessor this config has no kind for, or a path the source
- * does not have.
+ * Every directive aimed at nothing — an accessor this config has no kind for, a path the source
+ * does not have, or a path where the row here isn't one the pin derives.
  *
  * The one mistake the other checks structurally cannot see. Each of them answers for a path it is
  * already holding, so it asks "does the declaration mention this one" — and a name nobody has is
@@ -254,6 +259,10 @@ interface DanglingDirective {
  * Also what notices the source dropping a path. A directive written against an entity a later version
  * removed keeps parsing and keeps doing nothing, which is the same failure the declared verb exists to
  * catch one level down.
+ *
+ * And what notices a path leaving the pin. A row taken through another pin (`linked-system/link` with
+ * `onLinked: 'take'`), or authored here, stands where the pin's row stood, and the entry the pin
+ * still carries for it applies to nothing.
  */
 declare function danglingDirectives(config: Config): DanglingDirective[];
 /** A borrowed token whose condition is missing or has a different category here. */

package/dist/framework/source-integrity.js

@@ -489,8 +489,25 @@ function unadoptedDirectives(config) {
 	return found;
 }
 /**
-* Every directive aimed at nothing — an accessor this config has no kind for, or a path the source
-* does not have.
+* Who holds the row at a path a directive names, when it isn't the directive's own pin: the slug of
+* the pin the row follows instead, `null` for a row of this config's own, `undefined` when the pin's
+* row is there or nothing is.
+*
+* A pin's `options` lay over the rows its declaration derives, and nothing else. A row taken through
+* another pin, or authored here, stands at the path in its place, so the entry applies to nothing.
+*/
+function heldElsewhere(config, { slug, kind, path }) {
+	const item = config.storedBody(kind, path);
+	const group = item === void 0 ? config.groupMeta(kind, path) : void 0;
+	if (item === void 0 && group === void 0) return void 0;
+	const pointer = item ?? group?.ref;
+	const through = isRef(pointer) ? sourceOf(pointer) : void 0;
+	if (through === slug) return void 0;
+	return through ?? null;
+}
+/**
+* Every directive aimed at nothing — an accessor this config has no kind for, a path the source
+* does not have, or a path where the row here isn't one the pin derives.
 *
 * The one mistake the other checks structurally cannot see. Each of them answers for a path it is
 * already holding, so it asks "does the declaration mention this one" — and a name nobody has is
@@ -500,6 +517,10 @@ function unadoptedDirectives(config) {
 * Also what notices the source dropping a path. A directive written against an entity a later version
 * removed keeps parsing and keeps doing nothing, which is the same failure the declared verb exists to
 * catch one level down.
+*
+* And what notices a path leaving the pin. A row taken through another pin (`linked-system/link` with
+* `onLinked: 'take'`), or authored here, stands where the pin's row stood, and the entry the pin
+* still carries for it applies to nothing.
 */
 function danglingDirectives(config) {
 	const found = [];
@@ -516,7 +537,23 @@ function danglingDirectives(config) {
 				});
 				continue;
 			}
-			if (source.resolve(kind, path) || source.members(kind, path).length > 0) continue;
+			if (source.resolve(kind, path) || source.members(kind, path).length > 0) {
+				if (config.sourceOverlay(slug, kind, path)?.hidden === true) continue;
+				const heldBy = heldElsewhere(config, {
+					slug,
+					kind,
+					path
+				});
+				if (heldBy === void 0) continue;
+				found.push({
+					slug,
+					accessor,
+					path,
+					missing: "row",
+					...heldBy === null ? {} : { heldBy }
+				});
+				continue;
+			}
 			found.push({
 				slug,
 				accessor,