@yahoo/uds-create-config 5.57.1 → 5.59.0

package/dist/authoring/define-component.d.ts

@@ -17,6 +17,7 @@
  * The returned handle is a ref AND an `Authored`, so it composes into other components and
  * registers through the generic bridge.
  */
+import { type PropsOrRules } from '../entities/system/prop-rules';
 import type { Authored } from '../framework/authoring';
 import { type Ref } from '../framework/utils/refs';
 /** A component handle — a ref (import/reference it), an `Authored` (register it), and a
@@ -69,7 +70,7 @@ interface Body<L, SP extends string, MOD extends string, P extends Record<string
         when: Record<string, string>;
         layers: LayerOverrides<L, SP, MOD>;
     }>;
-    defaultProps?: Record<string, unknown>;
+    defaultProps?: PropsOrRules<Record<string, unknown>>;
     label?: string;
     description?: string;
 }

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

@@ -13,7 +13,8 @@ import { StoredDefaultCondition } from "../../framework/default-conditions.js";
 import { StoredPreviewCondition } from "../../framework/preview-store.js";
 import { RepeatSpec } from "../../framework/render-spec.js";
 import { ComponentSourceInput } from "./component-source-fields.js";
-import { AsInput, AuthoredDefaultsOf, LayerMap, PhantomCallProps, PhantomReadProps, PropMap, RenderArgs, StateMap, StyleRuleInput } from "./defineComponent.js";
+import { PropsOrRules } from "./prop-rules.js";
+import { AsInput, AuthoredDefaultsOf, LayerMap, PhantomCallProps, PhantomReadProps, PropMap, RenderArgs, StateMap, StyleRuleInput, UnconditionalDefaults } from "./defineComponent.js";
 import { listSlots, namedSlots, slotHostedBy, slotOf, slotsFor } from "../../spec/slot.js";
 import { cellAt } from "../../spec/cell.js";
 import { instanceAt } from "../../spec/instance.js";
@@ -871,7 +872,9 @@ declare const ComponentEntity: EntityClass<z.ZodObject<{
   }: ComputedInput) => string[];
 }, false, Record<never, never>, Record<never, never>>;
 /** Source extensions declare their structure through .render(). */
-type ComponentRefDelta = ComponentSourceInput<Partial<CreateInput<typeof componentFields>>>;
+type ComponentRefDelta = Omit<ComponentSourceInput<Partial<CreateInput<typeof componentFields>>>, 'defaultProps'> & {
+  /** A record, or `.defaultProps`'s rule list; checked against the props by `ExtensionDefaults`. */readonly defaultProps?: PropsOrRules<Record<string, unknown>>;
+};
 type ExactComponentDelta<Delta> = Delta & { [Key in Exclude<keyof Delta, keyof ComponentRefDelta>]: never };
 type ContractLayers<Contract> = Contract extends {
   layers: infer Layers;
@@ -908,7 +911,7 @@ type ResolvedDefaults<Contract, Delta> = Delta extends {
   readonly defaultProps: infer Defaults;
 } ? OverlayContract<Contract extends {
   defaultProps: infer Base;
-} ? Base : Record<never, never>, Defaults> : Contract extends {
+} ? Base : Record<never, never>, UnconditionalDefaults<Defaults>> : Contract extends {
   defaultProps: infer Defaults;
 } ? Defaults : Record<never, never>;
 type ResolvedForwards<Contract, Delta> = Delta extends {

package/dist/entities/system/Component.js

@@ -27,9 +27,9 @@ import { instanceAt } from "../../spec/instance.js";
 import { forwardOptions, forwardsWrite } from "./component-forwards.js";
 import { assertComponentSourceInput } from "./component-source-fields.js";
 import { checkStyleSet, styleSetEdits } from "./component-style-set.js";
-import { storedDefaults } from "./conditional-defaults.js";
 import { forwardRouteInvariants, refusedRoutes } from "./forward-route-invariants.js";
 import { iconDomainInvariants } from "./icon-domain-invariants.js";
+import { storedDefaults } from "./prop-rules.js";
 import { rootLayerInvariants } from "./root-layer-invariants.js";
 import { Token } from "./Token.js";
 import { z } from "zod";
@@ -1199,7 +1199,7 @@ const Preview = defineSubEntity({
 		});
 	}
 });
-const DEFAULT_CONDITIONS_DESCRIPTION = "Defaults that hold only under a condition on this component's other props, laid over `defaultProps` the way a style rule is over the unconditional one: a list of entries, each identified by its condition. `{ \"when\": { \"modal\": false }, \"props\": { \"includeScrim\": false } }` defaults `includeScrim` to `false` while `modal` is `false`, and to its `defaultProps` value otherwise. When several entries hold, the later one wins on the prop it sets. Both sides name the component's own variant, string, number or boolean props, a prop set here is never part of a condition, and a value the call site passes always wins. Authored as `conditionalDefault(fallback, [{ when, value }])` inside `.defaultProps`.";
+const DEFAULT_CONDITIONS_DESCRIPTION = "Defaults that hold only under a condition on this component's other props, laid over `defaultProps` the way a style rule is over the unconditional one: a list of entries, each identified by its condition. `{ \"when\": { \"modal\": false }, \"props\": { \"includeScrim\": false } }` defaults `includeScrim` to `false` while `modal` is `false`, and to its `defaultProps` value otherwise. When several entries hold, the later one wins on the prop it sets. Both sides name the component's own variant, string, number or boolean props, a prop set here is never part of a condition, and a value the call site passes always wins. Authored as a rule in `.defaultProps([{ when, props }])`.";
 const defaultConditionShapeError = "a conditional default is `{ \"when\": { \"<prop>\": <value> }, \"props\": { \"<prop>\": <value> } }`: both name this component's own variant, string, number or boolean props (not `as`), `when` at one of their values.";
 const defaultConditionBase = z.object({
 	when: z.record(z.string(), z.unknown()),
@@ -1811,9 +1811,9 @@ const componentFields = z.strictObject({
 	anatomy: AnatomyNode.optional().describe("The tree of what this component renders, keyed by node. Each node names what it renders (a layer, for anything a style rule reaches) and lists its `children`; the node keyed `root` is the top. A one-layer component may omit it. Anatomy read from an extension's own source file replaces the inherited tree; edits to a borrowed render merge into its tree."),
 	defaultProps: Style.optional(),
 	/** The defaults that hold only under a condition on the component's other props — see
-	*  `conditionalDefault`. */
+	*  `.defaultProps([{ when, props }])`. */
 	defaultPropsWhen: orList(DefaultCondition).optional().describe(DEFAULT_CONDITIONS_DESCRIPTION),
-	/** What the tile and the matrix render with — see `preview({ defaultProps, when })`. Read off
+	/** What the tile and the matrix render with — see `.preview({ defaultProps })`. Read off
 	*  `.preview()` at build, and written per cell from the matrix. */
 	preview: orList(Preview).optional().describe(PREVIEW_DESCRIPTION),
 	/**
@@ -2989,7 +2989,7 @@ function componentRef(path) {
 		assertComponentSourceInput(delta);
 		const extended = base.extend({
 			...delta,
-			...storedDefaults(delta)
+			...delta.defaultProps === void 0 ? {} : storedDefaults(delta.defaultProps)
 		});
 		Object.defineProperty(extended, "render", {
 			enumerable: false,

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

@@ -3,7 +3,7 @@ import { RegisteredComponentHandles, RegisteredGroupPaths, RegisteredModifiers,
 import { Authored } from "../../framework/authoring.js";
 import { StyleValue } from "./style-bag.js";
 import { ComponentSourceInput } from "./component-source-fields.js";
-import { ConditionalDefault } from "./conditional-defaults.js";
+import { PropsOrRules } from "./prop-rules.js";
 import { VariantValues } from "./Component.js";
 import { AllHTMLAttributes, ComponentPropsWithRef, ComponentType, ElementType, JSX, ReactElement, ReactNode, Ref } from "react";
 
@@ -664,11 +664,17 @@ type ForwardedPropsOf<L extends LayerMap, F extends string> = [NonRootForward<L,
 type DefaultsOf<P extends PropMap> = Partial<DeclaredProps<P>> & {
   [key: string]: unknown;
 };
-/** {@link DefaultsOf} as `.defaultProps` takes it: a declared prop other than `as` may also default
- *  through {@link conditionalDefault}. */
-type AuthoredDefaultsOf<P extends PropMap> = { [K in keyof DeclaredProps<P>]?: K extends 'as' ? DeclaredProps<P>[K] : DeclaredProps<P>[K] | ConditionalDefault<DeclaredProps<P>[K]> } & {
-  [key: string]: unknown;
-};
+/** {@link DefaultsOf} as `.defaultProps` and `.extend({ defaultProps })` take it: the defaults, or
+ *  a list of rules giving them under conditions. */
+type AuthoredDefaultsOf<P extends PropMap> = PropsOrRules<DefaultsOf<P>>;
+/** The defaults a component applies with nothing set: a record as given, or its unconditional
+ *  rules folded together. */
+type UnconditionalDefaults<D> = D extends readonly (infer Rule)[] ? [UnconditionalProps<Rule>] extends [never] ? Record<never, never> : UnionToIntersection<UnconditionalProps<Rule>> : D;
+type UnconditionalProps<Rule> = Rule extends {
+  when: Readonly<Record<string, unknown>>;
+} ? never : Rule extends {
+  props: infer Props;
+} ? Props : never;
 /**
  * `T` without the keys in `K` — `Omit` that leaves an index signature alone.
  *
@@ -785,10 +791,11 @@ F extends string = never, /** The states `.states()` declared — what the rende
    * `const`, so an `as` keeps its literal type: without it `{ as: 'input' }` widens to `string` and
    * there's no tag left to resolve the element's props against.
    *
-   * A default that depends on another prop is a `conditionalDefault`:
-   * `includeScrim: conditionalDefault(true, [{ when: { modal: false }, value: false }])`.
+   * Defaults that depend on other props are rules, the way style rules are: a rule without `when`
+   * holds always, and a later rule wins on the props it sets.
+   * `[{ props: { includeScrim: true } }, { when: { modal: false }, props: { includeScrim: false } }]`.
    */
-  defaultProps<const D2 extends AuthoredDefaultsOf<P>>(defaults: D2): ComponentBuilder<L, P, E, D2, F, S>;
+  defaultProps<const D2 extends AuthoredDefaultsOf<P>>(defaults: D2): ComponentBuilder<L, P, E, UnconditionalDefaults<D2>, F, S>;
   /**
    * The layers whose element props this component ALSO exposes, keyed by layer.
    *
@@ -832,34 +839,23 @@ F extends string = never, /** The states `.states()` declared — what the rende
    */
   renderCanvas<E2 extends E = E>(fn: (args: Without<RenderArgs<L, P, S>, keyof E2> & E2) => unknown): ComponentBuilder<L, P, E, D, F, S>;
   /**
-   * What a preview of this component STARTS from — the props a single tile is rendered with.
+   * What a preview tile renders with. `defaultProps` takes what `.defaultProps` does: a record, or a
+   * list of rules.
    *
-   * Only `defaultProps`, because the grid itself is derived: every axis a matrix could sweep is
-   * already declared in `styles`, as the conditions the rules apply under, and the modifier columns
-   * are the `_hover`/`_active` blocks those rules contain. An authored matrix restated all of it and
-   * could disagree with it — a variant added to `styles` and forgotten in the matrix simply never
-   * appeared. See `previewMatrix`.
+   * Only content, because the grid itself is derived: every axis a matrix could sweep is declared in
+   * `styles`, as the conditions the rules apply under, and the modifier columns are the
+   * `_hover`/`_active` blocks those rules contain. See `previewMatrix`.
+   *
+   * A rule with `when` gives the content a cell needs at one point on an axis:
+   * `{ when: { type: 'image' }, props: { src } }` gives the image kind a photo. A condition naming a
+   * prop no rule styles makes that prop an axis too, with the value named.
    */
   preview(spec: {
-    defaultProps?: DefaultsOf<P>;
-    /**
-     * Preview props that hold only under a condition — the same `when` grammar a style rule uses.
-     * The grid is derived from the styles; what it cannot derive is the CONTENT a cell needs at a
-     * given point on an axis: `{ when: { type: 'image' }, props: { src } }` gives the image kind a
-     * photo, `{ when: { invalid: true }, props: { selected: true } }` shows the invalid state checked.
-     * A condition naming a prop no rule styles makes that prop an axis too, with the value named —
-     * so a preview can say a boolean is worth a column the way a rule would.
-     */
-    when?: readonly PreviewCondition<P>[];
+    defaultProps?: PropsOrRules<DefaultsOf<P>>;
   }): ComponentBuilder<L, P, E, D, F, S>;
   toStored(): Record<string, unknown>;
   assignPath(path: string): void;
 }
-/** Preview props that hold under a condition on the cell's props — see `preview({ when })`. */
-interface PreviewCondition<P extends PropMap = PropMap> {
-  readonly when: Partial<Record<keyof P & string, unknown>>;
-  readonly props: DefaultsOf<P>;
-}
 /** A component under authorship, with its declarations forgotten — what a registry holds. */
 type AuthoredComponent = ComponentBuilder<LayerMap, PropMap, unknown, unknown>;
 /**
@@ -901,4 +897,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, AuthoredDefaultsOf, AuthoredProp, ComponentBuilder, ComponentPropsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, LinkedHandle, ModifierProps, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StateMap, StyleProps, StyleRuleInput, defineComponent };
+export { AsInput, AuthoredComponent, AuthoredDefaultsOf, AuthoredProp, ComponentBuilder, ComponentPropsOf, GlyphComponent, GlyphValue, LayerElement, LayerMap, LinkedHandle, ModifierProps, PhantomCallProps, PhantomReadProps, PropCondition, PropDecl, PropMap, RegisteredMembers, RenderArgs, SlotCodeForm, SlotDecl, StateMap, StyleProps, StyleRuleInput, UnconditionalDefaults, defineComponent };

package/dist/entities/system/defineComponent.js

@@ -1,8 +1,7 @@
-import { canonicalCondition, isRef, kindOf, memberRef, pathOf } from "../../framework/utils/refs.js";
+import { isRef, kindOf, memberRef, pathOf } from "../../framework/utils/refs.js";
 import { glyphIdentityOf, glyphPackageRefOf, isComponentType } from "./glyph-identity.js";
-import "../../framework/preview-store.js";
 import { assertComponentSourceInput } from "./component-source-fields.js";
-import { isConditionalDefault, storedDefaults } from "./conditional-defaults.js";
+import { keyedPropRules, storedDefaults } from "./prop-rules.js";
 import { Component, layerRef, storedStyleRules } from "./Component.js";
 //#region src/entities/system/defineComponent.ts
 function build(body) {
@@ -25,10 +24,7 @@ function build(body) {
 		metadata: (meta) => next(meta),
 		render: () => handle,
 		renderCanvas: () => handle,
-		preview: (spec) => {
-			if (spec?.defaultProps === void 0 && !spec?.when?.length) return handle;
-			return next({ preview: spec });
-		},
+		preview: (spec) => spec?.defaultProps === void 0 ? handle : next({ preview: spec.defaultProps }),
 		toStored: () => toStored(body),
 		assignPath(path) {
 			handle.path = path;
@@ -146,7 +142,6 @@ function storableElement(value) {
 */
 function storableValue(value) {
 	if (value === null) return null;
-	if (isConditionalDefault(value)) throw new Error("`conditionalDefault` is a default, so it goes in `.defaultProps` or `.extend({ defaultProps })`. A preview conditions its props with `.preview({ when: [{ when, props }] })`.");
 	const type = typeof value;
 	if (type === "string" || type === "number" || type === "boolean") return value;
 	if (isComponentType(value)) return storableComponentRef(value);
@@ -376,21 +371,19 @@ function toStored(body) {
 	assertComponentSourceInput(body);
 	const stored = { ...body };
 	if (body.preview !== void 0) {
-		const authored = body.preview;
 		const keyed = {};
-		const defaults = authored.defaultProps !== void 0 ? storableProps(authored.defaultProps) : void 0;
-		if (defaults !== void 0) keyed["*"] = {
-			when: null,
-			props: defaults
-		};
-		for (const { when, props } of authored.when ?? []) keyed[canonicalCondition(when)] = {
-			when,
-			props: storableProps(props) ?? {}
-		};
+		for (const [key, { when, props }] of keyedPropRules(body.preview)) {
+			const storable = storableProps(props);
+			if (storable === void 0 && when === null) continue;
+			keyed[key] = {
+				when,
+				props: storable ?? {}
+			};
+		}
 		if (Object.keys(keyed).length === 0) delete stored.preview;
 		else stored.preview = keyed;
 	}
-	Object.assign(stored, storedDefaults(body));
+	if (body.defaultProps !== void 0) Object.assign(stored, storedDefaults(body.defaultProps));
 	if (body.props && typeof body.props === "object") {
 		const props = {};
 		for (const [name, decl] of Object.entries(body.props)) props[name] = storedProp(decl, body.layers);

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

@@ -2,6 +2,7 @@ import { collectRefs, isMintedRow, ref, sourceOf, splitRef } from "../../framewo
 import { isConfigRejection, rejectData } from "../../framework/rejection.js";
 import { blockedBy } from "../../framework/plan.js";
 import { 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

package/dist/entities/system/prop-rules.d.ts

@@ -0,0 +1,10 @@
+//#region src/entities/system/prop-rules.d.ts
+/** One rule: `props` hold while every prop `when` names has its value, or always with no `when`. */
+interface PropRule<Props = Record<string, unknown>> {
+  readonly when?: Readonly<Record<string, unknown>> | null;
+  readonly props: Props;
+}
+/** The props given unconditionally, or a list of rules. */
+type PropsOrRules<Props> = Props | readonly PropRule<Props>[];
+//#endregion
+export { PropRule, PropsOrRules };

package/dist/entities/system/prop-rules.js

@@ -0,0 +1,42 @@
+import { canonicalCondition } from "../../framework/utils/refs.js";
+//#region src/entities/system/prop-rules.ts
+/**
+* Rules keyed by condition, `*` for the unconditional one. Two rules with the same condition are
+* one: their props merge, the later value winning, and the merged rule takes the later one's place.
+*/
+function keyedPropRules(authored) {
+	const rules = Array.isArray(authored) ? authored : [{ props: authored }];
+	const keyed = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const key = canonicalCondition(rule.when);
+		const prior = keyed.get(key);
+		keyed.delete(key);
+		keyed.set(key, {
+			when: key === "*" ? null : { ...rule.when },
+			props: {
+				...prior?.props,
+				...rule.props
+			}
+		});
+	}
+	return keyed;
+}
+/**
+* Authored defaults as stored: the unconditional rule in `defaultProps`, each other in
+* `defaultPropsWhen`. A plain record stores as it was written, with no `defaultPropsWhen`.
+*/
+function storedDefaults(authored) {
+	if (!Array.isArray(authored)) return { defaultProps: { ...authored } };
+	const keyed = keyedPropRules(authored);
+	const defaultPropsWhen = {};
+	for (const [key, { when, props }] of keyed) if (when) defaultPropsWhen[key] = {
+		when,
+		props
+	};
+	return {
+		defaultProps: keyed.get("*")?.props ?? {},
+		...Object.keys(defaultPropsWhen).length > 0 ? { defaultPropsWhen } : {}
+	};
+}
+//#endregion
+export { keyedPropRules, storedDefaults };

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;
 		}
@@ -5519,15 +5515,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 +5545,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 +6328,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 +6557,4 @@ function loadGroupChange(meta, kind, path, raw, phase = "author") {
 	};
 }
 //#endregion
-export { Config, SERIALIZED_CONFIG_VERSION };
+export { Config, SERIALIZED_CONFIG_VERSION, sameOrigin };

package/dist/framework/default-conditions.d.ts

@@ -22,5 +22,32 @@ declare function defaultsFor({
   body: unknown;
   given: Readonly<Record<string, unknown>>;
 }): Record<string, unknown>;
+/** One condition a prop defaults under, seen from that prop: the value it takes while `when` holds. */
+interface PropDefaultCondition<V = unknown> {
+  readonly when: Readonly<Record<string, unknown>>;
+  readonly value: V;
+}
+/** The conditions one prop defaults under, in stored order, each with the value it gives the prop. */
+declare function propDefaultConditions({
+  defaultPropsWhen,
+  prop
+}: {
+  defaultPropsWhen: Readonly<Record<string, StoredDefaultCondition>> | undefined;
+  prop: string;
+}): PropDefaultCondition[];
+/**
+ * `defaultPropsWhen` with one prop's conditions replaced by `entries`: the prop leaves every entry it
+ * was in, an entry left setting nothing goes, and each new condition joins the entry already keyed
+ * by it or is added at the end. What a surface editing one prop's conditions writes back whole.
+ */
+declare function withPropDefaultConditions({
+  defaultPropsWhen,
+  prop,
+  entries
+}: {
+  defaultPropsWhen: Readonly<Record<string, StoredDefaultCondition>> | undefined;
+  prop: string;
+  entries: readonly PropDefaultCondition[];
+}): Record<string, StoredDefaultCondition>;
 //#endregion
-export { StoredDefaultCondition, defaultsFor, storedDefaultConditions };
+export { PropDefaultCondition, StoredDefaultCondition, defaultsFor, propDefaultConditions, storedDefaultConditions, withPropDefaultConditions };

package/dist/framework/default-conditions.js

@@ -1,5 +1,5 @@
 import { isPlainObject } from "./utils/field-path.js";
-import { refLeaf } from "./utils/refs.js";
+import { canonicalCondition, refLeaf } from "./utils/refs.js";
 //#region src/framework/default-conditions.ts
 /**
 * A component's stored `defaultPropsWhen` collection, read off a body with nothing else in scope:
@@ -31,5 +31,42 @@ function defaultsFor({ body, given }) {
 	})) Object.assign(out, props);
 	return out;
 }
+/** The conditions one prop defaults under, in stored order, each with the value it gives the prop. */
+function propDefaultConditions({ defaultPropsWhen, prop }) {
+	return Object.values(defaultPropsWhen ?? {}).flatMap(({ when, props }) => props && Object.hasOwn(props, prop) ? [{
+		when,
+		value: props[prop]
+	}] : []);
+}
+/**
+* `defaultPropsWhen` with one prop's conditions replaced by `entries`: the prop leaves every entry it
+* was in, an entry left setting nothing goes, and each new condition joins the entry already keyed
+* by it or is added at the end. What a surface editing one prop's conditions writes back whole.
+*/
+function withPropDefaultConditions({ defaultPropsWhen, prop, entries }) {
+	const out = {};
+	for (const [key, { when, props }] of Object.entries(defaultPropsWhen ?? {})) {
+		const { [prop]: _left, ...rest } = props ?? {};
+		if (Object.keys(rest).length > 0) out[key] = {
+			when,
+			props: rest
+		};
+	}
+	for (const entry of entries) {
+		const key = canonicalCondition(entry.when);
+		const existing = out[key];
+		out[key] = existing ? {
+			...existing,
+			props: {
+				...existing.props,
+				[prop]: entry.value
+			}
+		} : {
+			when: { ...entry.when },
+			props: { [prop]: entry.value }
+		};
+	}
+	return out;
+}
 //#endregion
-export { defaultsFor, storedDefaultConditions };
+export { defaultsFor, propDefaultConditions, storedDefaultConditions, withPropDefaultConditions };

package/dist/framework/projections.d.ts

@@ -788,7 +788,7 @@ declare function validateComponentProps(config: Config, componentPath: string, p
  * serialization is for storage and the wire.
  */
 declare function previewDefaults(config: Config, path: string,
-/** The cell's own prop values. Given, every `preview({ when })` entry that holds for the cell —
+/** The cell's own prop values. Given, every conditional preview rule that holds for the cell —
  *  tested against the defaults under these values, as a rule's `when` is — adds its props. */
 
 cell?: Record<string, unknown>,
@@ -799,7 +799,7 @@ options?: {
   readonly firstVariants?: boolean;
 }): Record<string, unknown>;
 /**
- * Only what the `preview({ when })` entries add for a cell — the props of every condition that holds
+ * Only what the conditional preview rules add for a cell — the props of every condition that holds
  * for the cell's values over the defaults, later entries over earlier. Nothing else: a caller that
  * merges these onto a cell's own props is adding the content the author tied to that coordinate,
  * without restating defaults that would shadow an edit.

package/dist/framework/projections.js

@@ -1996,7 +1996,7 @@ function firstVariantValues(props) {
 	return out;
 }
 /**
-* Only what the `preview({ when })` entries add for a cell — the props of every condition that holds
+* Only what the conditional preview rules add for a cell — the props of every condition that holds
 * for the cell's values over the defaults, later entries over earlier. Nothing else: a caller that
 * merges these onto a cell's own props is adding the content the author tied to that coordinate,
 * without restating defaults that would shadow an edit.