@yahoo/uds-create-config 4.36.0 → 4.37.0

package/dist/entities/system/StyleProperty.d.ts

@@ -1,6 +1,7 @@
 import { Ref } from "../../framework/utils/ref-grammar.js";
 import { Ref as Ref$1 } from "../../framework/utils/refs.js";
 import { EntityClass } from "../../framework/defineEntity.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
 import { z } from "zod";
 
@@ -97,13 +98,9 @@ declare function classifyStylePropValue({
   config: Config;
   entry: StylePropValue;
 }): StylePropValueKind;
-/**
- * `StyleProperty.ref('bg')` keeps the path literal in its type, so a component prop declared as the
- * ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered `bg`
- * values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather than
- * the name's.
- */
-declare const StyleProperty: EntityClass<z.ZodObject<{
+/** StyleProperty (`flex/direction`) — a prop a component can expose, mapped to a CSS
+ *  property with an allowed value set. Grouping (`flex`) is emergent from the path. */
+declare const StylePropertyEntity: EntityClass<z.ZodObject<{
   properties: z.ZodArray<z.ZodString>;
   values: z.ZodOptional<z.ZodArray<z.ZodType<StylePropValue, unknown, z.core.$ZodTypeInternals<StylePropValue, unknown>>>>;
   responsive: z.ZodDefault<z.ZodBoolean>;
@@ -111,25 +108,15 @@ declare const StyleProperty: EntityClass<z.ZodObject<{
   arbitrary: z.ZodDefault<z.ZodBoolean>;
   negates: z.ZodDefault<z.ZodBoolean>;
   opacityOf: z.ZodOptional<z.ZodLazy<z.ZodType<Ref, unknown, z.core.$ZodTypeInternals<Ref, unknown>>>>;
-}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "style-property", {
-  readonly rename: {
-    readonly to: z.ZodString;
-  };
-  readonly create: {
-    readonly path: z.ZodString;
-    readonly description: `Create a style property \u2014 the prop a component exposes for one CSS effect. \`path\` is the prop's JSX name, camelCase (\`borderRadius\`), never a CSS name; the CSS goes in \`properties\`. \`values\` is a ref to a token GROUP (\`${string}\`), which offers every token in it and keeps the prop in step with modes and edits; \`{ "alias": "brand", "value": ${string} }\` offers one token under a name of the prop's own; a literal (\`"row"\`, \`{ "alias": "full", "value": "9999px" }\`) is for a keyword the system has no token for. Restating a token's value as a literal instead of referencing it is refused.`;
-    readonly example: ({
-      config
-    }: {
-      config: Config;
-      kind: string;
-      path: string;
-    }) => {
-      path: string;
-      data: Record<string, unknown>;
-    } | undefined;
-  };
-}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, z.ZodObject<Record<never, never>, z.core.$strip>, "style-property", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+/**
+ * `StyleProperty.ref('bg')` keeps the path literal in its type, so a component prop declared as the
+ * ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered `bg`
+ * values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather than
+ * the name's.
+ */
+interface StylePropertyClass extends Named<typeof StylePropertyEntity> {}
+declare const StyleProperty: StylePropertyClass;
 /** `flexDirection` → `flex-direction`. A name already spelled as CSS comes back unchanged. */
 declare function toCssPropertyName(property: string): string;
 /**
@@ -145,4 +132,4 @@ declare function cssPropertyNames(styleProp: {
   readonly properties: readonly string[];
 }): string[];
 //#endregion
-export { RefMember, STYLE_PROP_VALUE_FORMS, STYLE_PROP_VALUE_LEAVES, StylePropLeaf, StylePropValue, StylePropValueCtx, StylePropValueKind, StyleProperty, classifyStylePropValue, cssPropertyNames, leavesOfStylePropValue, stylePropValueFormOf, stylePropValueSchema, toCssPropertyName };
+export { RefMember, STYLE_PROP_VALUE_FORMS, STYLE_PROP_VALUE_LEAVES, StylePropLeaf, StylePropValue, StylePropValueCtx, StylePropValueKind, StyleProperty, StylePropertyClass, classifyStylePropValue, cssPropertyNames, leavesOfStylePropValue, stylePropValueFormOf, stylePropValueSchema, toCssPropertyName };

package/dist/entities/system/StyleProperty.js

@@ -417,12 +417,6 @@ function freePath(config, path) {
 	for (let n = 2; config.resolve("style-property", candidate); n += 1) candidate = `${path}${n}`;
 	return candidate;
 }
-/**
-* `StyleProperty.ref('bg')` keeps the path literal in its type, so a component prop declared as the
-* ref is typed by the property it points at: `bg: StyleProperty.ref('bg')` offers the registered `bg`
-* values, and `columns: StyleProperty.ref('gridTemplateColumns')` offers the target's rather than
-* the name's.
-*/
 const StyleProperty = defineEntity({
 	kind: "style-property",
 	label: "Style property",

package/dist/entities/system/Token.d.ts

@@ -61,11 +61,7 @@ declare const TokenEntity: EntityClass<z.ZodObject<{
   }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<{
   cssPrefix: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, "token", {
-  readonly create: {
-    readonly description: `Create a token at \`<group>/<name>\` \u2014 \`data.value\` is the CSS value. The first path segment is its group, and a style property takes a whole group as one ref (\`${string}\`), so put the tokens one prop should offer in one group rather than listing values on the prop.`;
-  };
-}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+}, z.core.$strip>, "token", {}, Record<never, never>, false, Record<never, never>, Record<never, never>>;
 /** A token ref as an authoring file holds it: the marker, `extend`, and the value readers. */
 type TokenReference<Path extends string> = KindRef<typeof tokenFields, 'token', Path> & TokenReaders<Path>;
 /**
@@ -73,9 +69,16 @@ type TokenReference<Path extends string> = KindRef<typeof tokenFields, 'token',
  * registered group — `` `spacing/${gutter}` `` — whose readers stay open since no one token is named.
  */
 type TokenRefPath = PathOf<'token'> | `${PathOf<'token'>}/${string}`;
-declare function tokenRef<const Path extends TokenRefPath>(path: Path): TokenReference<Path>;
-declare const Token: Omit<typeof TokenEntity, "ref"> & {
+/**
+ * `Path` when `Token.ref` should take it, else `never`. A completion under a registered path is only
+ * open when it is known at runtime alone: `` `spacing/${gutter}` `` passes, and a literal
+ * `'color/nope'` doesn't, since a literal names one token and that token has to be registered.
+ */
+type CheckedTokenRefPath<Path extends string> = Path extends PathOf<'token'> ? Path : Path extends `${PathOf<'token'>}/${infer Rest}` ? Record<never, never> extends Record<Rest, unknown> ? Path : never : never;
+declare function tokenRef<const Path extends TokenRefPath>(path: Path & CheckedTokenRefPath<Path>): TokenReference<Path>;
+declare const Token: TokenClass;
+interface TokenClass extends Omit<typeof TokenEntity, 'ref'> {
   readonly ref: typeof tokenRef;
-};
+}
 //#endregion
-export { OverrideCondition, Token, TokenBody, TokenRefPath, TokenReference, defineOverride, overrideCondition, overrideKey, overrideKeyModifiers, overrideModifiers };
+export { CheckedTokenRefPath, OverrideCondition, Token, TokenBody, TokenClass, TokenRefPath, TokenReference, defineOverride, overrideCondition, overrideKey, overrideKeyModifiers, overrideModifiers };

package/dist/entities/system/Tool.d.ts

@@ -1,98 +1,13 @@
 import { ComputedInput } from "../../framework/registry.js";
 import { DerivedEntityClass } from "../../framework/defineDerivedEntity.js";
+import { Named } from "../../framework/named.js";
 import { Config } from "../../framework/Config.js";
+import { OperationClass } from "./Operation.js";
 import { z } from "zod";
 
 //#region src/entities/system/Tool.d.ts
-declare const Tool: DerivedEntityClass<z.ZodObject<{
-  operation: DerivedEntityClass<z.ZodObject<{
-    kind: z.ZodString;
-    verb: z.ZodString;
-    readOnly: z.ZodBoolean;
-    label: z.ZodString;
-    description: z.ZodString;
-    scope: z.ZodString;
-    creates: z.ZodBoolean;
-    approval: z.ZodOptional<z.ZodEnum<{
-      destructive: "destructive";
-      "reference-change": "reference-change";
-    }>>;
-  }, z.core.$strip>, {
-    inputSchema: ({
-      member: op,
-      config
-    }: Omit<ComputedInput, "member"> & {
-      member: {
-        kind: string;
-        verb: string;
-        readOnly: boolean;
-        label: string;
-        description: string;
-        scope: string;
-        creates: boolean;
-        approval?: "destructive" | "reference-change" | undefined;
-      };
-    }) => z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
-    execute: ({
-      member: op,
-      config: declaring
-    }: Omit<ComputedInput, "member"> & {
-      member: {
-        kind: string;
-        verb: string;
-        readOnly: boolean;
-        label: string;
-        description: string;
-        scope: string;
-        creates: boolean;
-        approval?: "destructive" | "reference-change" | undefined;
-      };
-    }) => ((input: Record<string, unknown>, config: Config) => unknown) | undefined;
-    field: ({
-      member: op
-    }: Omit<ComputedInput, "member"> & {
-      member: {
-        kind: string;
-        verb: string;
-        readOnly: boolean;
-        label: string;
-        description: string;
-        scope: string;
-        creates: boolean;
-        approval?: "destructive" | "reference-change" | undefined;
-      };
-    }) => string | undefined;
-    title: ({
-      member: op,
-      config
-    }: Omit<ComputedInput, "member"> & {
-      member: {
-        kind: string;
-        verb: string;
-        readOnly: boolean;
-        label: string;
-        description: string;
-        scope: string;
-        creates: boolean;
-        approval?: "destructive" | "reference-change" | undefined;
-      };
-    }) => ((entity: string) => string) | undefined;
-    example: ({
-      member: op,
-      config
-    }: Omit<ComputedInput, "member"> & {
-      member: {
-        kind: string;
-        verb: string;
-        readOnly: boolean;
-        label: string;
-        description: string;
-        scope: string;
-        creates: boolean;
-        approval?: "destructive" | "reference-change" | undefined;
-      };
-    }) => Record<string, unknown> | undefined;
-  }>;
+declare const ToolDefinition: DerivedEntityClass<z.ZodObject<{
+  operation: OperationClass;
   name: z.ZodString;
   description: z.ZodString;
   enabled: z.ZodDefault<z.ZodBoolean>;
@@ -130,5 +45,7 @@ declare const Tool: DerivedEntityClass<z.ZodObject<{
   shortLabel: (input: ComputedInput) => string | undefined; /** Bound to a real entity in this config — built by the op from its own input shape. */
   example: (input: ComputedInput) => Record<string, unknown> | undefined;
 }>;
+interface ToolClass extends Named<typeof ToolDefinition> {}
+declare const Tool: ToolClass;
 //#endregion
-export { Tool };
+export { Tool, ToolClass };

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

@@ -1,5 +1,5 @@
-import { DerivedColor, Gradient } from "./color.js";
 import { Transition } from "./transition.js";
+import { DerivedColor, Gradient } from "./color.js";
 import { z } from "zod";
 
 //#region src/entities/system/composed-values.d.ts

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

@@ -42,8 +42,8 @@ interface CopyPlanRow {
   /** Where it lands here, which is also the path the source spells. */
   readonly path: string;
   /**
-   * `create` for a path nothing of yours holds, or one inherited by the pin's declaration; `replace`
-   * for a pointer stored at the path, which becomes the literal it stood for; `overwrite` for a row of
+   * `create` for a path nothing of yours holds; `replace` for a pointer at the path, authored or minted
+   * by the link, which becomes the literal it stood for; `overwrite` for a row of
    * yours, or one held through another pin, that the call asked to write over (`onConflict: 'replace'`).
    */
   readonly status: 'create' | 'replace' | 'overwrite';

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

@@ -98,6 +98,7 @@ function planCopy({ config, input }) {
 	const reused = [];
 	/** 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) => {
 		if (!folders.some((f) => f.kind === kind && f.path === path)) folders.push({
 			kind,
@@ -110,7 +111,7 @@ function planCopy({ config, input }) {
 	* about this source's values and neither is one of them. `replace` writes theirs over a row of
 	* yours, and over a row held through another pin when the call named it; a row reached only through
 	* a ref stays that pin's, since the person pointed at what named it. A pointer through this pin is
-	* replaced by the literal it stood for.
+	* replaced by the literal it stood for, and a row its declaration minted is reused unless named.
 	*/
 	const take = ({ kind, theirs, at, named }) => {
 		const key = `${kind}:${at}`;
@@ -151,13 +152,26 @@ function planCopy({ config, input }) {
 		});
 		if (!fit.ok) return fit;
 		const stored = held ? config.storedBody(kind, at) : void 0;
+		const minted = stored !== void 0 && isMintedRow(stored);
+		if (!named && minted && covers({
+			declared,
+			accessor: config.accessorOf(kind) ?? kind,
+			path: at
+		})) {
+			reused.push({
+				kind,
+				path: at
+			});
+			return { ok: true };
+		}
 		const extend = stored ? stored.extend : void 0;
 		taking.push({
 			kind,
 			theirs,
 			at,
 			named,
-			...stored ? { extend: extend ?? {} } : {}
+			...stored ? { extend: extend ?? {} } : {},
+			...minted ? { minted } : {}
 		});
 		return { ok: true };
 	};
@@ -244,9 +258,8 @@ function planCopy({ config, input }) {
 		}
 	}
 	if (taking.length === 0 && wholesale) rejectData(`"${slug}" has nothing to copy.`);
-	for (let index = 0; index < taking.length; index++) {
-		const row = taking[index];
-		const body = source.resolve(row.kind, row.theirs)?.toJSON();
+	/** Take what `body` points at by ref. */
+	const follow = (body) => {
 		for (const target of collectRefs(body)) {
 			if (sourceOf(target) !== void 0) continue;
 			const depKind = kindOf(target);
@@ -275,6 +288,17 @@ function planCopy({ config, input }) {
 			});
 			folder(depKind, depPath);
 		}
+	};
+	let walkedFolders = 0;
+	for (let index = 0; index < taking.length || walkedFolders < folders.length;) {
+		if (walkedFolders < folders.length) {
+			const { kind, path } = folders[walkedFolders++];
+			follow(ownMeta(source.groups(kind).find((group) => group.path === path)?.meta ?? {}));
+			continue;
+		}
+		const row = taking[index++];
+		const body = source.resolve(row.kind, row.theirs)?.toJSON();
+		follow(body);
 		for (const named of source.entityOf(row.kind)?.nameEdges?.(body) ?? []) {
 			const depKind = kindOf(named);
 			const dep = source.resolve(depKind, pathOf(named));
@@ -358,7 +382,7 @@ function planCopy({ config, input }) {
 		taking,
 		source
 	});
-	for (const { kind, theirs, at, extend } of ordered) {
+	for (const { kind, theirs, at, extend, minted } of ordered) {
 		const body = config.copyOf({
 			slug,
 			kind,
@@ -371,7 +395,7 @@ function planCopy({ config, input }) {
 			...body,
 			copiedFrom: `${theirs}@${slug}`
 		};
-		patches.push(extend === void 0 ? {
+		patches.push(extend === void 0 || minted ? {
 			kind,
 			operation: "create",
 			path: at,
@@ -385,13 +409,11 @@ function planCopy({ config, input }) {
 	}
 	for (const { kind, theirs, at } of taking) respell(`${kind}:${theirs}@${slug}`, `${kind}:${at}`);
 	for (const { kind, path } of folders) respell(`${kind}:${path}@${slug}`, `${kind}:${path}`);
-	const declared = declarationOf(config, slug);
 	if (declared !== void 0) {
 		const removal = /* @__PURE__ */ new Map();
 		for (const { kind, at, named } of taking) {
 			if (!named) continue;
-			const stored = config.storedBody(kind, at);
-			if (!stored || !isMintedRow(stored)) continue;
+			if (config.storedBody(kind, at) === void 0) continue;
 			if (config.resolve(kind, at)?.borrowedFrom !== slug) continue;
 			const accessor = config.accessorOf(kind) ?? kind;
 			if (!covers({

package/dist/entities/system/defineComponent.d.ts

@@ -777,4 +777,4 @@ interface DefineComponent {
 declare function definePropsFirst<const P extends PropMap<LayerPath>>(props: P & NoInfer<{ [K in keyof P]: Exact<P[K], AuthoredProp<LayerPath>> }>): ComponentBuilder<LayerMap, P>;
 declare const defineComponent: DefineComponent;
 //#endregion
-export { AsInput, AuthoredComponent, AuthoredProp, ComponentBuilder, ComponentPropsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StyleRuleInput, defineComponent };
+export { AsInput, AuthoredComponent, AuthoredProp, ComponentBuilder, ComponentPropsOf, DefaultsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StyleRuleInput, defineComponent };

package/dist/entities/system/icon-metadata.d.ts

@@ -1,5 +1,4 @@
-import { SubEntityClass } from "../../framework/defineSubEntity.js";
-import { EntityClass } from "../../framework/defineEntity.js";
+import { PackageClass } from "./Package.js";
 import { z } from "zod";
 
 //#region src/entities/system/icon-metadata.d.ts
@@ -41,10 +40,7 @@ type IconMemberMetadata = z.infer<typeof iconMemberMetadata>;
  * kind that exists; when `File`/`Url` land, `from` widens to a union — the shape stays.
  */
 declare const iconMetadataDeclaration: z.ZodObject<{
-  from: EntityClass<z.ZodObject<{
-    version: z.ZodOptional<z.ZodString>;
-    exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
-  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false, Record<never, never>, Record<never, never>>;
+  from: PackageClass;
   format: z.ZodEnum<{
     uds: "uds";
     phosphor: "phosphor";

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

@@ -6,10 +6,21 @@ import { Config, Patch, TreeNode } from "../../framework/Config.js";
 /** What one op names, keyed by accessor the way the pin's `link` is: every entry of the kind, or the
  *  source's paths, where a folder names its members. `'*'` alone is every kind the source offers. */
 type LinkPaths = '*' | Readonly<Record<string, '*' | readonly string[]>>;
+/** What a link does at a path held through another linked system: `'take'` makes the row follow this
+ *  source, `'keep'` leaves it with the system it comes from. */
+type OnLinked = 'keep' | 'take';
 interface LinkPlanInput {
   /** The pin's slug. */
   readonly path: string;
   readonly data: LinkPaths;
+  /** Planned as `'take'` when omitted; the `link` op refuses without it while `linked` is not empty. */
+  readonly onLinked?: OnLinked;
+}
+/** A path the link reaches that another linked system provides, or declares under a row of this
+ *  config's own. */
+interface LinkedElsewhere extends EntityAddress {
+  /** The slug of the pin it comes through. */
+  readonly from: 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. */
@@ -25,6 +36,8 @@ interface LinkPlan {
   readonly replaces: number;
   /** Rows of this config's own deleted so the source's row shows through at the path. */
   readonly addresses: readonly EntityAddress[];
+  /** Every path the link reaches that another linked system provides, whatever `onLinked` says. */
+  readonly linked: readonly LinkedElsewhere[];
   /** Rows held through another pin, turned into extensions through this one. */
   readonly extended: readonly EntityAddress[];
   /** Members already here from the source's own origin, left alone and kept out of the declaration. */
@@ -79,10 +92,17 @@ interface SourceRowState {
   readonly name: string;
   /** Members this config can hold. A folder counts its leaves, an item counts one. */
   readonly members: number;
+  /** Members held through this pin, whether linked by name or come along with another link. */
+  readonly held: number;
   /** Every member is held through this pin. */
   readonly linked: boolean;
   /** Rows of this config's own a `link` would write over. */
   readonly replaces: number;
+  /** Members another linked system provides or also declares, which a `link` asks about through
+   *  `onLinked`. */
+  readonly linkedElsewhere: number;
+  /** The slugs of the pins those come through. */
+  readonly linkedFrom: readonly string[];
   /** Members already here from the source's own origin, through another pin. */
   readonly shared: number;
   /** That origin's name, when `shared` is above zero. */
@@ -95,10 +115,11 @@ interface SourceRowState {
  * The declaration goes first. A row of this config's own that other rows point at can only be deleted
  * once the declaration covers the path, since the config refuses a delete that leaves a referrer
  * dangling. A row held through another pin is not deleted — that pin's declaration would mint it
- * again, and declaring one path on two pins is a collision nothing derives — so it becomes an
- * extension through this pin: a row of this config's own that shadows the other pin's and follows this
- * source. A member already here from the source's own origin is left alone and kept out of the
- * declaration, so a folder that holds one is declared by its other members.
+ * again, and declaring one path on two pins is a collision nothing derives. With `onLinked: 'take'` it
+ * becomes an extension through this pin: a row of this config's own that shadows the other pin's and
+ * follows this source. With `'keep'` it stays with the other pin and out of the declaration. A member
+ * already here from the source's own origin is left alone and kept out of the declaration, so a
+ * folder that holds one is declared by its other members.
  */
 declare function planLink({
   config,
@@ -157,4 +178,4 @@ declare function sourceRowStates({
   readonly slug: string;
 }): SourceRowState[];
 //#endregion
-export { BreakOutcome, BreakPlan, BreakPlanInput, BreakPlanRow, BreakReach, LinkArrival, LinkPaths, LinkPlan, LinkPlanInput, SourceRowState, UnlinkPlan, UnlinkPlanInput, planBreak, planLink, planUnlink, sourceRowStates };
+export { BreakOutcome, BreakPlan, BreakPlanInput, BreakPlanRow, BreakReach, LinkArrival, LinkPaths, LinkPlan, LinkPlanInput, LinkedElsewhere, OnLinked, SourceRowState, UnlinkPlan, UnlinkPlanInput, planBreak, planLink, planUnlink, sourceRowStates };

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

@@ -42,6 +42,20 @@ function sharedWithOrigin({ config, source, slug, kind, path }) {
 	if (!theirs || !mine || theirs.key !== mine.key) 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
+*  derive from if this config held nothing there. */
+function declaredElsewhere({ config, slug, kind, path }) {
+	const accessor = config.accessorOf(kind) ?? kind;
+	for (const pin of config.list(PIN_KIND)) {
+		if (pin.path === slug) continue;
+		if (!covers({
+			declared: declarationOf(config, pin.path),
+			accessor,
+			path
+		})) continue;
+		if (config.sourceFor(pin.path)?.resolve(kind, path)) return pin.path;
+	}
+}
 /**
 * Link paths of a source: the declaration that mints them, then the edits that let them show through
 * where this config already holds something.
@@ -49,10 +63,11 @@ function sharedWithOrigin({ config, source, slug, kind, path }) {
 * The declaration goes first. A row of this config's own that other rows point at can only be deleted
 * once the declaration covers the path, since the config refuses a delete that leaves a referrer
 * dangling. A row held through another pin is not deleted — that pin's declaration would mint it
-* again, and declaring one path on two pins is a collision nothing derives — so it becomes an
-* extension through this pin: a row of this config's own that shadows the other pin's and follows this
-* source. A member already here from the source's own origin is left alone and kept out of the
-* declaration, so a folder that holds one is declared by its other members.
+* again, and declaring one path on two pins is a collision nothing derives. With `onLinked: 'take'` it
+* becomes an extension through this pin: a row of this config's own that shadows the other pin's and
+* follows this source. With `'keep'` it stays with the other pin and out of the declaration. A member
+* already here from the source's own origin is left alone and kept out of the declaration, so a
+* folder that holds one is declared by its other members.
 */
 function planLink({ config, input }) {
 	const { path: slug } = input;
@@ -66,12 +81,13 @@ function planLink({ config, input }) {
 		verb: "link"
 	});
 	const addresses = [];
+	const linked = [];
 	const extended = [];
 	const shared = [];
 	const shadows = [];
 	/** Per accessor, what the declaration gains: the kind whole, or paths. */
 	const gains = /* @__PURE__ */ new Map();
-	let sharedAnywhere = false;
+	let leftAnywhere = false;
 	const shadow = (kind, path) => {
 		const held = config.resolve(kind, path);
 		if (!held || held.borrowedFrom === slug) return true;
@@ -86,10 +102,16 @@ function planLink({ config, input }) {
 				kind,
 				path
 			});
-			sharedAnywhere = true;
+			leftAnywhere = true;
 			return false;
 		}
-		if (held.borrowedFrom === void 0) {
+		const from = held.borrowedFrom ?? declaredElsewhere({
+			config,
+			slug,
+			kind,
+			path
+		});
+		if (from === void 0) {
 			addresses.push({
 				kind,
 				path
@@ -101,6 +123,20 @@ function planLink({ config, input }) {
 			});
 			return true;
 		}
+		linked.push({
+			kind,
+			path,
+			from
+		});
+		if (input.onLinked === "keep") {
+			if (held.borrowedFrom === void 0) shadows.push({
+				kind,
+				operation: "delete",
+				path
+			});
+			leftAnywhere = true;
+			return false;
+		}
 		const stored = config.storedBody(kind, path);
 		const minted = stored !== void 0 && isMintedRow(stored);
 		extended.push({
@@ -145,7 +181,7 @@ function planLink({ config, input }) {
 	}
 	const declares = [];
 	let declared = current;
-	if (current !== "*") if (input.data === "*" && !sharedAnywhere) {
+	if (current !== "*") if (input.data === "*" && !leftAnywhere) {
 		declared = "*";
 		declares.push({
 			kind: PIN_KIND,
@@ -192,6 +228,7 @@ function planLink({ config, input }) {
 		}),
 		replaces: addresses.length,
 		addresses,
+		linked,
 		extended,
 		shared,
 		patches
@@ -485,7 +522,7 @@ function planBreak({ config, input }) {
 	const pointing = /* @__PURE__ */ new Map();
 	/** Folders drawn through the pin by a pointer of this config's own, released once their members are copied. */
 	const pointedFolders = [];
-	const reach = ({ kind, path, reach }) => {
+	const reach = ({ kind, path, reach: how }) => {
 		const held = config.resolve(kind, path);
 		if (held?.borrowedFrom === slug) {
 			copying.path(kind, path);
@@ -495,7 +532,7 @@ function planBreak({ config, input }) {
 				folder: false,
 				refs: [ref(kind, path, slug).__ref],
 				outcome: "copied",
-				reach
+				reach: how
 			});
 			return;
 		}
@@ -516,9 +553,15 @@ function planBreak({ config, input }) {
 					folder: true,
 					refs: [ref(kind, path, slug).__ref],
 					outcome: "copied",
-					reach
+					reach: how
 				});
+				return;
 			}
+			for (const member of config.members(kind, path)) if (member.borrowedFrom === slug) reach({
+				kind,
+				path: member.path,
+				reach: "taken"
+			});
 			return;
 		}
 		const refs = drawnThroughPin({
@@ -534,7 +577,7 @@ function planBreak({ config, input }) {
 		}
 		pointing.set(`${kind}:${path}`, {
 			refs,
-			reach
+			reach: how
 		});
 	};
 	if (scoped) for (const { kind, accessor, paths } of wantedKinds({
@@ -730,6 +773,8 @@ function sourceRowStates({ config, slug }) {
 		if (members.length === 0) continue;
 		let linked = 0;
 		let local = 0;
+		let elsewhere = 0;
+		const linkedFrom = /* @__PURE__ */ new Set();
 		let shared = 0;
 		let sharedOrigin;
 		for (const leaf of members) {
@@ -739,7 +784,6 @@ function sourceRowStates({ config, slug }) {
 				linked += 1;
 				continue;
 			}
-			local += 1;
 			const origin = sharedWithOrigin({
 				config: derived,
 				source,
@@ -747,10 +791,19 @@ function sourceRowStates({ config, slug }) {
 				kind,
 				path: leaf.path
 			});
+			const from = origin === void 0 ? held.borrowedFrom ?? declaredElsewhere({
+				config: derived,
+				slug,
+				kind,
+				path: leaf.path
+			}) : void 0;
 			if (origin !== void 0) {
 				shared += 1;
 				sharedOrigin ??= origin;
-			}
+			} else if (from !== void 0) {
+				elsewhere += 1;
+				linkedFrom.add(from);
+			} else local += 1;
 		}
 		rows.push({
 			kind,
@@ -758,8 +811,11 @@ function sourceRowStates({ config, slug }) {
 			type: node.type,
 			name: node.item?.displayLabel ?? node.name,
 			members: members.length,
+			held: linked,
 			linked: linked === members.length,
-			replaces: local - shared,
+			replaces: local,
+			linkedElsewhere: elsewhere,
+			linkedFrom: [...linkedFrom],
 			shared,
 			...sharedOrigin === void 0 ? {} : { sharedOrigin }
 		});