@yahoo/uds-create-config 4.36.0 → 4.36.1

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,7 +409,6 @@ 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) {

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

@@ -79,6 +79,8 @@ 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. */

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

@@ -758,6 +758,7 @@ 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,
 			shared,

package/dist/entities/system/style-bag.d.ts

@@ -1,3 +1,6 @@
+import { SubEntityClass } from "../../framework/defineSubEntity.js";
+import { RegisteredModifiers, RegisteredStyleProps } from "../../framework/registered.js";
+import { Named } from "../../framework/named.js";
 import { ComposedValue } from "./composed-values.js";
 import { z } from "zod";
 
@@ -16,5 +19,28 @@ type StyleValue = string | number | boolean | {
 } | ComposedValue | {
   readonly [key: string]: StyleValue;
 };
+/**
+ * A style bag as a keyed COLLECTION — style-prop key → {@link styleValue}, with each key a member
+ * in its own right.
+ *
+ * Being a sub-entity is what makes a per-declaration edit addressable: setting `boxShadow` names
+ * `boxShadow`, rather than being an update of the whole bag that first has to read the current one
+ * to avoid erasing its siblings. It also gives the bag a rename that keeps a key's position, which
+ * matters because key order is declaration order in the emitted rule — for a shorthand/longhand
+ * pair, moving one changes what gets painted.
+ */
+declare const StyleDefinition: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
+interface StyleClass extends Named<typeof StyleDefinition> {}
+/** The style props the system registers, each taking any value a bag stores. */
+type RegisteredStyleBag = { [K in keyof RegisteredStyleProps]?: StyleValue };
+/**
+ * A bag as a config file writes one when nothing but style props and modifiers may key it: the style
+ * props the system registers, and a `_modifier` block of the same. Open until the build has filled
+ * `RegisteredStyleProps`, since before that no key can be told from a style prop.
+ */
+type AuthoredStyleBag = [keyof RegisteredStyleProps] extends [never] ? Record<string, StyleValue> : RegisteredStyleBag & { [M in keyof RegisteredModifiers]?: RegisteredStyleBag };
+/** {@link Style} as a field whose authored input is an {@link AuthoredStyleBag}. The stored value is
+ *  unchanged. */
+type AuthoredStyleField = z.ZodType<z.output<StyleClass>, AuthoredStyleBag>;
 //#endregion
-export { StyleValue };
+export { AuthoredStyleBag, AuthoredStyleField, RegisteredStyleBag, StyleClass, StyleValue };

package/dist/entities/system/style-bag.js

@@ -32,16 +32,6 @@ const anatomyPropValue = z.lazy(() => z.union([
 	])),
 	z.record(z.string(), anatomyPropValue)
 ]));
-/**
-* A style bag as a keyed COLLECTION — style-prop key → {@link styleValue}, with each key a member
-* in its own right.
-*
-* Being a sub-entity is what makes a per-declaration edit addressable: setting `boxShadow` names
-* `boxShadow`, rather than being an update of the whole bag that first has to read the current one
-* to avoid erasing its siblings. It also gives the bag a rename that keeps a key's position, which
-* matters because key order is declaration order in the emitted rule — for a shorthand/longhand
-* pair, moving one changes what gets painted.
-*/
 const Style = defineSubEntity({
 	name: "style",
 	label: "Style",

package/dist/framework/Config.d.ts

@@ -2056,9 +2056,12 @@ declare class Config {
    */
   private computeSourceClosure;
   /**
-   * A refusal for a pin patch whose derive pass would retire a minted row that something authored
-   * here still points at. A minted row has no body of its own, so once it goes the referrer dangles;
+   * A refusal for a patch whose derive pass would retire a minted row that something authored here
+   * still points at. A minted row has no body of its own, so once it goes the referrer dangles;
    * copying what is used, or breaking the link with `keep`, is how the value stays.
+   *
+   * `action` names what is refused, after "Cannot": a pin patch removes the link, and any other patch
+   * that reaches derivation — a deleted extension whose source reached the row — says what it did.
    */
   private assertDerivedDropsUnreferenced;
   /**
@@ -2089,6 +2092,8 @@ declare class Config {
    * system's namespace, which this config has no `@slug` for and no claim on.
    */
   withDerivedRows(): this;
+  /** {@link withDerivedRows} for a derivation already in hand. */
+  private withRowsOf;
   /**
    * The rows an edit changes, derived inside that edit's own apply.
    *
@@ -2411,6 +2416,17 @@ declare class Config {
   /** Every `kind:path` whose definition references the given entity — the reverse
    *  dependency graph, harvested generically from refs in each item's data. */
   dependentsOf(kind: string, path: string, opts?: TraverseOptions): string[];
+  /**
+   * The dependents of `kind:path` that use it only through a source: rows here that point whole at a
+   * source entity which, in that source, points at `kind:path`. A rename's cascade can't rewrite
+   * them, since the body that names the path is the source's.
+   *
+   * A pointer row's body lives in its source, so the index here holds only the pointer. Each source's
+   * own index answers what its bodies name, and a source's bare ref means the path here, so each
+   * referrer there comes back as the rows here pointing at it: the row the link minted, or an
+   * extension of it. A source's pins are its own, so a pin here has none of these.
+   */
+  sourceDependentsOf(kind: string, path: string, opts?: TraverseOptions): string[];
   /** The inverse: what `kind:path` needs in order to resolve. `{ transitive: true }` returns the
    *  whole closure — what a sealed/exported copy would have to carry along with it. */
   dependenciesOf(kind: string, path: string, opts?: TraverseOptions): string[];

package/dist/framework/Config.js

@@ -564,6 +564,15 @@ function rekeyAt(node, path, from, to) {
 	};
 }
 /** Whether `ref` names a row or folder the build minted, at the item or group the snapshot holds. */
+/** What a refused edit of several patches is called. */
+const EDIT_ACTION = "make this edit";
+/** What an edit does, for a refusal that begins "Cannot": `delete component:Mine` for one patch. */
+function actionOf(patches) {
+	const list = Array.isArray(patches) ? patches : [patches];
+	const [only] = list;
+	if (list.length !== 1 || !only || !("path" in only)) return EDIT_ACTION;
+	return `${only.operation} ${only.kind}:${only.path}`;
+}
 function isMintedAt(snapshot, ref) {
 	const kind = kindOf(ref);
 	const path = pathOf(ref);
@@ -1218,7 +1227,7 @@ var Config = class Config {
 			deferred.reached = true;
 			return applied;
 		}
-		return applied.derivedForEdit();
+		return applied.derivedForEdit(actionOf(patch));
 	}
 	/**
 	* `run` with each kind's invariants judged once, on the config it returns, rather than after every
@@ -1245,7 +1254,8 @@ var Config = class Config {
 			deferred.open = false;
 			const settled = result.derive({ deferredInvariants: void 0 });
 			settled.assertInvariantsOf(settled.state.snapshot, deferred.kinds);
-			return deferred.reached ? settled.derivedForEdit() : settled;
+			if (!deferred.reached) return settled;
+			return settled.derivedForEdit(EDIT_ACTION);
 		} catch {
 			deferred.open = false;
 			return run(this);
@@ -1319,11 +1329,12 @@ var Config = class Config {
 			};
 			const landed = settled();
 			const edits = patches.filter((patch) => !this.entityOf(patch.kind)?.sourceIdentity);
-			return edits.length > 0 && this.reachesDerivation({
+			if (!(edits.length > 0 && this.reachesDerivation({
 				patches: edits,
 				before: this.state.snapshot,
 				after: landed.state.snapshot
-			}) ? landed.derivedForEdit() : landed;
+			}))) return landed;
+			return landed.derivedForEdit(actionOf(edits));
 		}
 		const land = (checked) => {
 			let config = checked ? this : this.derive({ snapshot: this.state.snapshot.drafting() });
@@ -1340,11 +1351,12 @@ var Config = class Config {
 			}
 		};
 		const config = settle().derive({ pending: [...this.state.pending, ...patches.map(stampOf)] });
-		return this.reachesDerivation({
+		if (!this.reachesDerivation({
 			patches,
 			before: this.state.snapshot,
 			after: config.state.snapshot
-		}) ? config.derivedForEdit() : config;
+		})) return config;
+		return config.derivedForEdit(actionOf(patches));
 	}
 	/**
 	* Whether patches on kinds that name no source can change the rows a derive mints between `before`
@@ -3932,20 +3944,23 @@ var Config = class Config {
 		return [...reached].sort();
 	}
 	/**
-	* A refusal for a pin patch whose derive pass would retire a minted row that something authored
-	* here still points at. A minted row has no body of its own, so once it goes the referrer dangles;
+	* A refusal for a patch whose derive pass would retire a minted row that something authored here
+	* still points at. A minted row has no body of its own, so once it goes the referrer dangles;
 	* copying what is used, or breaking the link with `keep`, is how the value stays.
+	*
+	* `action` names what is refused, after "Cannot": a pin patch removes the link, and any other patch
+	* that reaches derivation — a deleted extension whose source reached the row — says what it did.
 	*/
-	assertDerivedDropsUnreferenced() {
+	assertDerivedDropsUnreferenced({ action = "remove the link", derivation = this.rowDerivation() } = {}) {
 		const { snapshot } = this.state;
 		const stranded = [];
-		for (const change of this.rowDerivation().changes) {
+		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));
 			if (referrers.length > 0) stranded.push(`${change.kind}:${change.path} (used by ${referrers.join(", ")})`);
 		}
 		if (stranded.length === 0) return;
-		reject("REFERRERS_BLOCK", `Cannot remove the link — 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\`).`);
+		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\`).`);
 	}
 	/**
 	* This config with a row for every entity it inherits — the build's output. A pin patch runs this
@@ -3976,7 +3991,11 @@ var Config = class Config {
 	*/
 	withDerivedRows() {
 		if (derivedInEdit.has(this)) return this;
-		const moved = this.rowDerivation().changes.filter((change) => !this.holdsDerivedRow(change));
+		return this.withRowsOf(this.rowDerivation());
+	}
+	/** {@link withDerivedRows} for a derivation already in hand. */
+	withRowsOf(derived) {
+		const moved = derived.changes.filter((change) => !this.holdsDerivedRow(change));
 		if (moved.length === 0) return this;
 		return this.derive({ snapshot: this.state.snapshot.withChanges(moved) });
 	}
@@ -3987,8 +4006,14 @@ var Config = class Config {
 	* derive passes: this one and the session's. The mark covers this instance only, and any later
 	* write is a new config, so each edit still gets exactly one pass, as it did from the session alone.
 	*/
-	derivedForEdit() {
-		const derived = this.withDerivedRows();
+	derivedForEdit(action) {
+		if (derivedInEdit.has(this)) return this;
+		const derivation = this.rowDerivation();
+		this.assertDerivedDropsUnreferenced({
+			action,
+			derivation
+		});
+		const derived = this.withRowsOf(derivation);
 		derivedInEdit.add(derived);
 		return derived;
 	}
@@ -4819,7 +4844,37 @@ var Config = class Config {
 	/** Every `kind:path` whose definition references the given entity — the reverse
 	*  dependency graph, harvested generically from refs in each item's data. */
 	dependentsOf(kind, path, opts) {
-		return this.referrersOf(this.state.snapshot, kind, path, opts);
+		const own = this.referrersOf(this.state.snapshot, kind, path, opts);
+		const drawn = this.sourceDependentsOf(kind, path, opts);
+		return drawn.length === 0 ? own : [...own, ...drawn];
+	}
+	/**
+	* The dependents of `kind:path` that use it only through a source: rows here that point whole at a
+	* source entity which, in that source, points at `kind:path`. A rename's cascade can't rewrite
+	* them, since the body that names the path is the source's.
+	*
+	* A pointer row's body lives in its source, so the index here holds only the pointer. Each source's
+	* own index answers what its bodies name, and a source's bare ref means the path here, so each
+	* referrer there comes back as the rows here pointing at it: the row the link minted, or an
+	* extension of it. A source's pins are its own, so a pin here has none of these.
+	*/
+	sourceDependentsOf(kind, path, opts) {
+		if (this.entityOf(kind)?.sourceIdentity !== void 0) return [];
+		const { snapshot } = this.state;
+		const own = new Set(this.referrersOf(snapshot, kind, path, opts));
+		const found = /* @__PURE__ */ new Set();
+		for (const slug of this.sourceSlugs()) {
+			const source = this.sourceFor(slug);
+			if (!source) continue;
+			for (const referrer of source.dependentsOf(kind, path, opts)) {
+				const pointer = ref(kindOf(referrer), pathOf(referrer), slug).__ref;
+				for (const row of snapshot.refs.dependents(pointer)) {
+					const body = snapshot.get(kindOf(row), pathOf(row))?.toJSON();
+					if (isRef(body) && body.__ref === pointer && !own.has(row)) found.add(row);
+				}
+			}
+		}
+		return [...found];
 	}
 	/** The inverse: what `kind:path` needs in order to resolve. `{ transitive: true }` returns the
 	*  whole closure — what a sealed/exported copy would have to carry along with it. */

package/dist/framework/class-names.js

@@ -529,6 +529,7 @@ function splitStyleProps({ config, bag, through }) {
 			}
 			continue;
 		}
+		if (key.startsWith("_")) continue;
 		const name = stylePropertyPathFor({
 			config,
 			through,

package/dist/framework/defineConfig.d.ts

@@ -44,7 +44,7 @@ type ConfigKind<C> = C extends {
  * elements describes no gesture anyone makes, and a caller replacing one writes the whole list.
  */
 type Matched = any;
-type PartialBodyOf<E> = E extends EntityClass<infer F extends FieldsSchema, FieldsSchema, infer _K, Matched, Matched, Matched> ? DeepPartial<CreateInput<F>> : never;
+type PartialBodyOf<E> = E extends Omit<EntityClass<infer F extends FieldsSchema, FieldsSchema, infer _K, Matched, Matched, Matched>, 'ref'> ? DeepPartial<CreateInput<F>> : never;
 /** Optional at every depth, stopping at refs, arrays and primitives. */
 type DeepPartial<T> = T extends Ref | readonly unknown[] ? T : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
 /**
@@ -68,7 +68,7 @@ declare function kindsOf<T extends readonly {
  *  mean. */
 type RecordFor<E> = E extends {
   readonly singleton: true;
-} ? E extends EntityClass<infer F, FieldsSchema, infer _K, Matched, Matched, true> ? Partial<z.input<F>> : never : E extends EntityClass<infer F, infer G, infer _K, Matched, Matched, Matched> ? Record<string, AuthoredEntry<F, G>> : never;
+} ? E extends Omit<EntityClass<infer F, FieldsSchema, infer _K, Matched, Matched, true>, 'ref'> ? Partial<z.input<F>> : never : E extends Omit<EntityClass<infer F, infer G, infer _K, Matched, Matched, Matched>, 'ref'> ? Record<string, AuthoredEntry<F, G>> : never;
 /**
  * What a config DRAWS ON — keyed by the accessor name of the kind whose items ARE the sources, valued
  * by a thunk yielding the config type each one resolves to.