@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/element-marker.js

@@ -1,113 +0,0 @@
-import { foreignRegistryKey } from "./foreign-component-name.js";
-//#region src/element-marker.ts
-const ELEMENT_MARKER_KIND = "element";
-function isElementMarker(value) {
-	return value !== null && typeof value === "object" && value.__kind === "element" && typeof value.type === "string";
-}
-/**
-* A live React element or its `$$typeof`-less husk. `Config.toJSON` runs on the
-* in-memory config, where preview elements are still live (carry `$$typeof`);
-* the husk shape (`_owner`/`_store`, no live `type`) only appears after a
-* structuredClone/JSON round-trip and is matched here defensively.
-*/
-function isElementLikeValue(value) {
-	return value !== null && typeof value === "object" && ("$$typeof" in value || "_owner" in value || "_store" in value);
-}
-/**
-* The registry key for a React element's `type`: a UDS component's stamped
-* `__componentName`, a `foreign:<Name>` for a `forwardRef`/`memo` leaf, an
-* intrinsic tag string, or a plain function component's display/name. Returns
-* `null` when the type can't be named (an anonymous wrapper) — the caller then
-* drops the value rather than emit an unresolvable marker.
-*/
-function elementTypeName(type) {
-	if (typeof type === "string") return type;
-	if (!(type !== null && (typeof type === "object" || typeof type === "function"))) return null;
-	const udsName = type.__componentName;
-	if (typeof udsName === "string") return udsName;
-	const foreign = foreignRegistryKey(type);
-	if (foreign !== null) return foreign;
-	if (typeof type === "function") {
-		const fn = type;
-		if (typeof fn.displayName === "string" && fn.displayName.length > 0) return fn.displayName;
-		if (typeof fn.name === "string" && fn.name.length > 0) return fn.name;
-	}
-	return null;
-}
-function elementToMarker(element) {
-	const el = element;
-	const type = elementTypeName(el.type);
-	if (type === null) return void 0;
-	const marker = {
-		__kind: ELEMENT_MARKER_KIND,
-		type
-	};
-	if (typeof el.key === "string") marker.key = el.key;
-	if (el.props !== null && typeof el.props === "object") {
-		const props = serializeElementsDeep(el.props);
-		if (Object.keys(props).length > 0) marker.props = props;
-	}
-	return marker;
-}
-/**
-* Deeply convert every React element value to an {@link ElementMarker},
-* preserving the surrounding plain data (axis markers, primitive props, nested
-* arrays/objects). A value that can't be named drops out (`undefined`), so an
-* anonymous wrapper or a clone-stripped husk is removed rather than serialized
-* into something unrenderable. Already-serialized markers carry none of the
-* element internals {@link isElementLikeValue} matches, so they pass through.
-*/
-function serializeElementsDeep(value) {
-	if (isElementLikeValue(value)) return elementToMarker(value);
-	if (Array.isArray(value)) return value.map(serializeElementsDeep).filter((entry) => entry !== void 0);
-	if (value !== null && typeof value === "object") {
-		const out = {};
-		for (const [key, entry] of Object.entries(value)) {
-			const cleaned = serializeElementsDeep(entry);
-			if (cleaned !== void 0) out[key] = cleaned;
-		}
-		return out;
-	}
-	return value;
-}
-/**
-* Does `value` hold an {@link ElementMarker} anywhere in its plain-data subtree?
-* Lets a caller skip the revive walk entirely (and keep prop references stable)
-* when there's nothing to revive.
-*/
-function hasElementMarkerDeep(value, isOpaqueLeaf = isElementLikeValue) {
-	if (isElementMarker(value)) return true;
-	if (Array.isArray(value)) return value.some((entry) => hasElementMarkerDeep(entry, isOpaqueLeaf));
-	if (value !== null && typeof value === "object") {
-		if (isOpaqueLeaf(value)) return false;
-		return Object.values(value).some((entry) => hasElementMarkerDeep(entry, isOpaqueLeaf));
-	}
-	return false;
-}
-/**
-* Inverse of {@link serializeElementsDeep}: deep-walk `value` and turn each
-* {@link ElementMarker} into a renderable node via `renderMarker`, preserving
-* the surrounding plain data (arrays, objects). A marker's OWN props are left
-* for `renderMarker` to handle — they are not pre-revived here, so a marker
-* nested inside another marker's props stays inert until its enclosing marker
-* renders. This mirrors how `$slot` resolution defers and avoids handing a live
-* element (circular `_owner`) back into a renderer that deep-walks props.
-*
-* `renderMarker` is the framework seam — studio renders each marker through its
-* preview `UdsRenderer`; the playground does the same with its bundled renderer.
-* Guard with {@link hasElementMarkerDeep} to preserve referential stability for
-* marker-free values (this walk always rebuilds the containers it descends).
-*/
-function reviveElementMarkersDeep(value, renderMarker, isOpaqueLeaf = isElementLikeValue) {
-	if (isElementMarker(value)) return renderMarker(value);
-	if (Array.isArray(value)) return value.map((entry) => reviveElementMarkersDeep(entry, renderMarker, isOpaqueLeaf));
-	if (value !== null && typeof value === "object") {
-		if (isOpaqueLeaf(value)) return value;
-		const out = {};
-		for (const [key, entry] of Object.entries(value)) out[key] = reviveElementMarkersDeep(entry, renderMarker, isOpaqueLeaf);
-		return out;
-	}
-	return value;
-}
-//#endregion
-export { ELEMENT_MARKER_KIND, hasElementMarkerDeep, isElementLikeValue, isElementMarker, reviveElementMarkersDeep, serializeElementsDeep };

package/dist/entity-utils.d.ts

@@ -1,56 +0,0 @@
-import { CssClassName, CssVar } from "./brands.js";
-
-//#region src/entity-utils.d.ts
-/**
- * Kebab-case a single identifier. Inserts a hyphen at each upper-case
- * boundary and lower-cases the result. Single-segment only — for slashed
- * `'namespace/name'` paths, kebab each segment separately.
- */
-declare function kebabCase(value: string): string;
-/**
- * Build a CSS variable name from a prefix + namespace + token name.
- * Each segment is kebab-cased; dots in the token name are mapped to
- * `_` and slashes to `-` since CSS custom-property identifiers reject
- * both `.` and `/` (so a `1.5` spacing token emits
- * `--<prefix>-spacing-1_5`, and a subpath token `1/2` or
- * `always/white` emits `--<prefix>-position-1-2` /
- * `--<prefix>-global-always-white` — both valid).
- */
-declare function buildCssVar(prefix: string, namespace: string, name: string): CssVar;
-/**
- * Build a `tokenRef → 'var(--<prefix>-<ns>-<name>)'` resolver — the callback
- * `resolveColorExpression` consumes to turn `token('ns/name')` refs into CSS var
- * references. Splits a ref on its FIRST slash into namespace + name; a ref with
- * no usable slash passes through unchanged (already a literal).
- *
- * The single source of truth shared by the config render-spec bake and codegen
- * (`tokenValue.ts`, `prepareCss.ts`), so config-baked and codegen-emitted CSS
- * stay byte-identical. The name segment uses the `@yahoo/uds-create-utils` `safeTokenName`
- * transform (dots→`_`, slashes→`-`) — NOT `cssSafeSegment` (which also
- * kebab-cases) — so multi-segment paths like `spectrum/carbon/0` resolve to a
- * valid `--<prefix>-spectrum-carbon-0`.
- */
-declare function makeTokenRefToCss(prefix: string | undefined): (ref: string) => string;
-/**
- * Build a composite style's CSS class name: `<prefix>-<name>-<variant>`.
- * Both name/variant segments are sanitized so subpath variants like
- * `ui5/emphasized` emit `.yos-text-variant-ui5-emphasized` instead of an
- * invalid `.text-variant-ui5/emphasized` (which the browser splits at `/`).
- *
- * The `prefix` namespaces the class the same way it namespaces CSS
- * variables and component classes (`componentClassNames`) — an empty
- * prefix yields the bare, unprefixed form.
- */
-declare function buildCompositeClassName(prefix: string, name: string, variant: string): CssClassName;
-/**
- * Token names that aren't valid CSS identifiers (`2xl`, `3xs`) get an
- * underscore prefix so they survive in CSS contexts. Dots are mapped
- * to `_` and slashes to `-` — `1.5` would otherwise produce a class
- * string the browser splits at the dot (`class="text-1.5"` parses as
- * `.text-1` and `.5`), and a subpath token like `1/2` would emit
- * `text-1/2` which the browser treats as `.text-1` followed by
- * `/2`. Mirrors `safeTokenName` from `@yahoo/uds-create-utils`.
- */
-declare function toCssSafeName(name: string): CssClassName;
-//#endregion
-export { buildCompositeClassName, buildCssVar, kebabCase, makeTokenRefToCss, toCssSafeName };

package/dist/entity-utils.js

@@ -1,105 +0,0 @@
-import { cssClassName, cssVar } from "./brands.js";
-//#region src/entity-utils.ts
-/**
-* Shared helpers used by entity `.derived` getters.
-*/
-/**
-* Kebab-case a single identifier. Inserts a hyphen at each upper-case
-* boundary and lower-cases the result. Single-segment only — for slashed
-* `'namespace/name'` paths, kebab each segment separately.
-*/
-function kebabCase(value) {
-	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
-}
-/**
-* Kebab-case + sanitize a single identifier for use inside a CSS custom
-* property name or class name. Dots become `_` and slashes become `-`
-* (so `1.5` → `1_5`, `1/2` → `1-2`, `ui5/emphasized` → `ui5-emphasized`).
-* Mirrors the `safeTokenName` transform used by the runtime styler in
-* `@yahoo/uds-create-utils`, so codegen-declared identifiers and runtime-referenced
-* identifiers stay in lockstep.
-*/
-function cssSafeSegment(value) {
-	return kebabCase(value).replace(/\./g, "_").replace(/\//g, "-");
-}
-/**
-* Build a CSS variable name from a prefix + namespace + token name.
-* Each segment is kebab-cased; dots in the token name are mapped to
-* `_` and slashes to `-` since CSS custom-property identifiers reject
-* both `.` and `/` (so a `1.5` spacing token emits
-* `--<prefix>-spacing-1_5`, and a subpath token `1/2` or
-* `always/white` emits `--<prefix>-position-1-2` /
-* `--<prefix>-global-always-white` — both valid).
-*/
-function buildCssVar(prefix, namespace, name) {
-	return cssVar(`--${prefix}-${kebabCase(namespace)}-${cssSafeSegment(name)}`);
-}
-/**
-* Build a `tokenRef → 'var(--<prefix>-<ns>-<name>)'` resolver — the callback
-* `resolveColorExpression` consumes to turn `token('ns/name')` refs into CSS var
-* references. Splits a ref on its FIRST slash into namespace + name; a ref with
-* no usable slash passes through unchanged (already a literal).
-*
-* The single source of truth shared by the config render-spec bake and codegen
-* (`tokenValue.ts`, `prepareCss.ts`), so config-baked and codegen-emitted CSS
-* stay byte-identical. The name segment uses the `@yahoo/uds-create-utils` `safeTokenName`
-* transform (dots→`_`, slashes→`-`) — NOT `cssSafeSegment` (which also
-* kebab-cases) — so multi-segment paths like `spectrum/carbon/0` resolve to a
-* valid `--<prefix>-spectrum-carbon-0`.
-*/
-function makeTokenRefToCss(prefix) {
-	return (ref) => {
-		const slashIdx = ref.indexOf("/");
-		if (slashIdx <= 0 || slashIdx >= ref.length - 1) return ref;
-		const namespace = kebabCase(ref.slice(0, slashIdx));
-		const name = ref.slice(slashIdx + 1).replace(/\./g, "_").replace(/\//g, "-");
-		return prefix ? `var(--${prefix}-${namespace}-${name})` : `var(--${namespace}-${name})`;
-	};
-}
-/**
-* Build a composite style's CSS class name: `<prefix>-<name>-<variant>`.
-* Both name/variant segments are sanitized so subpath variants like
-* `ui5/emphasized` emit `.yos-text-variant-ui5-emphasized` instead of an
-* invalid `.text-variant-ui5/emphasized` (which the browser splits at `/`).
-*
-* The `prefix` namespaces the class the same way it namespaces CSS
-* variables and component classes (`componentClassNames`) — an empty
-* prefix yields the bare, unprefixed form.
-*/
-function buildCompositeClassName(prefix, name, variant) {
-	const body = `${cssSafeSegment(name)}-${cssSafeSegment(variant)}`;
-	return cssClassName(prefix ? `${prefix}-${body}` : body);
-}
-/**
-* Build the marker custom-property name a composite group writes (and
-* its container style queries read): `--<prefix>-composite-<kebab-name>`.
-* Single source of truth — the setter emission and `@container style(...)`
-* query both consume this so they stay in lockstep.
-*/
-function buildCompositeMarkerVarName(prefix, name) {
-	return cssVar(`--${prefix}-composite-${kebabCase(name)}`);
-}
-/**
-* Token names that aren't valid CSS identifiers (`2xl`, `3xs`) get an
-* underscore prefix so they survive in CSS contexts. Dots are mapped
-* to `_` and slashes to `-` — `1.5` would otherwise produce a class
-* string the browser splits at the dot (`class="text-1.5"` parses as
-* `.text-1` and `.5`), and a subpath token like `1/2` would emit
-* `text-1/2` which the browser treats as `.text-1` followed by
-* `/2`. Mirrors `safeTokenName` from `@yahoo/uds-create-utils`.
-*/
-function toCssSafeName(name) {
-	return cssClassName(cssSafeSegment(/^[0-9]/.test(name) ? `_${name}` : name));
-}
-/**
-* Filter undefined fields out of a partial object literal so optional
-* authored properties don't show up as `key: undefined` in `toJSON()`
-* output. Mirrors the pattern used by `@yahoo/uds-create-config` `defineX` builders.
-*/
-function compact(input) {
-	const out = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0) out[key] = value;
-	return out;
-}
-//#endregion
-export { buildCompositeClassName, buildCompositeMarkerVarName, buildCssVar, compact, cssSafeSegment, kebabCase, makeTokenRefToCss, toCssSafeName };

package/dist/extension.d.ts

@@ -1,55 +0,0 @@
-import { ComponentDefinition, ComponentExtension, ComponentExtensionRecord } from "./types.js";
-
-//#region src/extension.d.ts
-/** Registry barrel component value: the definition plus the chained extender. */
-type LinkedComponentValue = ComponentDefinition & {
-  extend(patch: ComponentExtension): ComponentDefinition;
-};
-/**
- * Apply an authored extension payload (additive only — `null` anywhere
- * throws). Never mutates `def`; applying the returned `inverse` via
- * {@link applyComponentExtensionInverse} restores `def` exactly.
- */
-declare function applyComponentExtension(def: ComponentDefinition, patch: ComponentExtension): {
-  result: ComponentDefinition;
-  inverse: ComponentExtension;
-};
-/**
- * Apply an engine-generated inverse. Unlike payloads, inverses carry
- * removals (`null` reverts an added path), so removal is permitted here.
- * `lenient` skips stale paths (removals of keys that no longer exist,
- * children that left the family) instead of throwing — the extension
- * DELETE path uses it so a source-shape change can never trap a consumer
- * with an extension they cannot remove.
- */
-declare function applyComponentExtensionInverse(def: ComponentDefinition, inverse: ComponentExtension, options?: {
-  lenient?: boolean;
-}): {
-  result: ComponentDefinition;
-};
-/**
- * Apply an extension payload to one component inside a FLAT serialized
- * components record (the `SerializedConfig.components` shape, where compound
- * children are separate sibling entries named by the parent's wire
- * `subcomponents` list). This is the build-time re-bind hook: a consumer's
- * extension on a linked component is replayed onto the source node's sealed
- * config before the node's modules and CSS regenerate, so rendered output
- * reflects the extension.
- *
- * Reconstructs the compound-parent shape (`__subcomponents` from the wire
- * name list) so {@link applyComponentExtension}'s validation and merge
- * semantics apply unchanged, then flattens the merged children back to their
- * sibling entries. Pure — returns a new record; `components` is not mutated.
- */
-declare function extendSerializedComponents(components: Record<string, ComponentDefinition>, sourceKey: string, payload: ComponentExtension): {
-  components: Record<string, ComponentDefinition>;
-  record: ComponentExtensionRecord;
-};
-/**
- * Wrap a registry barrel component definition, attaching the non-enumerable
- * `.extend(patch)`. Non-enumerable keeps the barrel value JSON-clean, the
- * same convention as `defineComponent`'s chain methods.
- */
-declare function linkedComponent(def: ComponentDefinition): LinkedComponentValue;
-//#endregion
-export { LinkedComponentValue, applyComponentExtension, applyComponentExtensionInverse, extendSerializedComponents, linkedComponent };

package/dist/extension.js

@@ -1,214 +0,0 @@
-//#region src/extension.ts
-/**
-* The extendable surface — non-structural definition fields only, plus the
-* `subcomponents` block (child overrides, same per-child surface). Everything
-* else (composition: `layers`, `ref`; provenance: `link`, `extension`; any
-* future field) is closed until deliberately added here.
-*/
-const EXTENDABLE_FIELD_KEYS = [
-	"props",
-	"base",
-	"defaultProps",
-	"compoundProps",
-	"motion",
-	"metadata"
-];
-const EXTENDABLE_FIELDS = new Set(EXTENDABLE_FIELD_KEYS);
-const ALLOW_LIST_MESSAGE = `only ${[...EXTENDABLE_FIELD_KEYS, "subcomponents"].map((k) => `"${k}"`).join(", ")} are extendable; composition and provenance stay owned by the source system.`;
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-}
-/**
-* `__kind`-tagged objects (`token()` refs, color expressions, element
-* markers) are atomic values, not containers — recursing into one would
-* union keys across marker shapes and corrupt it.
-*/
-function isMarker(value) {
-	return isPlainObject(value) && "__kind" in value;
-}
-/** Mergeable container: a plain object that is not an atomic marker. */
-function isMergeable(value) {
-	return isPlainObject(value) && !isMarker(value);
-}
-/**
-* A consumer-authored `token()` ref means the CONSUMER's namespace — stamp
-* it so downstream resolution (consumer derived tables, node replay) never
-* mistakes it for a source-namespace ref riding a linked definition.
-* System-scoped refs (barrel `token()` utilities) and already-scoped refs
-* pass through unchanged. Applied to payload values only — inverses carry
-* values captured from the definition, whose scoping is already correct.
-*/
-function stampConsumerScope(value) {
-	if (!isPlainObject(value)) return value;
-	if (value.__kind === "token" && value.scope === void 0 && value.system === void 0) return {
-		...value,
-		scope: "consumer"
-	};
-	return value;
-}
-/**
-* Merge `patch` into `base` (copy-on-write) and collect the inverse patch.
-* Returns the merged node; writes each touched key's inverse into `inverse`.
-* `allowRemoval` is false for authored payloads (additive only) and true
-* when applying an engine-generated inverse, whose `null`s revert additions.
-*/
-function mergeNode(base, patch, inverse, path, allowRemoval, label = "Component extension", lenient = false) {
-	const result = { ...base };
-	for (const [key, patchValue] of Object.entries(patch)) {
-		if (patchValue === void 0) continue;
-		const keyPath = path === "" ? key : `${path}.${key}`;
-		const had = Object.hasOwn(base, key);
-		const baseValue = base[key];
-		if (patchValue === null) {
-			if (!allowRemoval) throw new Error(`${label}: "${keyPath}" is null — extensions add and override values but never remove them.`);
-			if (!had) {
-				if (lenient) continue;
-				throw new Error(`${label}: "${keyPath}" does not exist, so the inverse cannot remove it — the stored inverse is stale.`);
-			}
-			delete result[key];
-			inverse[key] = baseValue;
-			continue;
-		}
-		if (isMergeable(patchValue)) {
-			const childBase = isMergeable(baseValue) ? baseValue : {};
-			const childInverse = {};
-			result[key] = mergeNode(childBase, patchValue, childInverse, keyPath, allowRemoval, label, lenient);
-			if (!had) inverse[key] = null;
-			else if (!isMergeable(baseValue)) inverse[key] = baseValue;
-			else if (Object.keys(childInverse).length > 0) inverse[key] = childInverse;
-			continue;
-		}
-		result[key] = allowRemoval ? patchValue : stampConsumerScope(patchValue);
-		inverse[key] = had ? baseValue : null;
-	}
-	return result;
-}
-/** Reject any payload root key outside the allow list. */
-function assertExtendableRoots(patch) {
-	for (const key of Object.keys(patch)) if (key !== "subcomponents" && !EXTENDABLE_FIELDS.has(key)) throw new Error(`Component extension: "${key}" cannot be extended — ${ALLOW_LIST_MESSAGE}`);
-}
-/**
-* Shared core for payload and inverse application. Splits the patch into
-* definition fields (merged onto the parent) and the `subcomponents` block
-* (each entry merged onto the matching `__subcomponents` child).
-*/
-function applyPatch(def, patch, allowRemoval, lenient = false) {
-	assertExtendableRoots(patch);
-	const { subcomponents: subPatches, ...fieldPatch } = patch;
-	const inverse = {};
-	const result = mergeNode(def, fieldPatch, inverse, "", allowRemoval, void 0, lenient);
-	if (subPatches !== void 0) {
-		if (!isMergeable(subPatches)) throw new Error("Component extension: \"subcomponents\" must be an object mapping child component names to their overrides.");
-		const children = def.__subcomponents;
-		const subInverse = {};
-		const mergedChildren = { ...children };
-		for (const [childName, childPatch] of Object.entries(subPatches)) {
-			if (childPatch === void 0) continue;
-			const child = children?.[childName];
-			if (!child) {
-				if (lenient) continue;
-				const known = Object.keys(children ?? {});
-				const hint = known.length > 0 ? `known subcomponents are ${known.map((n) => `"${n}"`).join(", ")}.` : "this component has no subcomponents.";
-				throw new Error(`Component extension: subcomponent "${childName}" does not exist — ${hint}`);
-			}
-			if (!isMergeable(childPatch)) throw new Error(`Component extension: subcomponent "${childName}" override must be an object.`);
-			if (Object.hasOwn(childPatch, "subcomponents")) throw new Error(`Component extension: subcomponent "${childName}" cannot declare nested subcomponents.`);
-			assertExtendableRoots(childPatch);
-			const childInverse = {};
-			mergedChildren[childName] = mergeNode(child, childPatch, childInverse, `subcomponents.${childName}`, allowRemoval, void 0, lenient);
-			if (Object.keys(childInverse).length > 0) subInverse[childName] = childInverse;
-		}
-		result.__subcomponents = mergedChildren;
-		if (Object.keys(subInverse).length > 0) inverse.subcomponents = subInverse;
-	}
-	return {
-		result,
-		inverse
-	};
-}
-/**
-* Apply an authored extension payload (additive only — `null` anywhere
-* throws). Never mutates `def`; applying the returned `inverse` via
-* {@link applyComponentExtensionInverse} restores `def` exactly.
-*/
-function applyComponentExtension(def, patch) {
-	return applyPatch(def, patch, false);
-}
-/**
-* Apply an engine-generated inverse. Unlike payloads, inverses carry
-* removals (`null` reverts an added path), so removal is permitted here.
-* `lenient` skips stale paths (removals of keys that no longer exist,
-* children that left the family) instead of throwing — the extension
-* DELETE path uses it so a source-shape change can never trap a consumer
-* with an extension they cannot remove.
-*/
-function applyComponentExtensionInverse(def, inverse, options) {
-	return { result: applyPatch(def, inverse, true, options?.lenient ?? false).result };
-}
-/**
-* Apply an extension payload to one component inside a FLAT serialized
-* components record (the `SerializedConfig.components` shape, where compound
-* children are separate sibling entries named by the parent's wire
-* `subcomponents` list). This is the build-time re-bind hook: a consumer's
-* extension on a linked component is replayed onto the source node's sealed
-* config before the node's modules and CSS regenerate, so rendered output
-* reflects the extension.
-*
-* Reconstructs the compound-parent shape (`__subcomponents` from the wire
-* name list) so {@link applyComponentExtension}'s validation and merge
-* semantics apply unchanged, then flattens the merged children back to their
-* sibling entries. Pure — returns a new record; `components` is not mutated.
-*/
-function extendSerializedComponents(components, sourceKey, payload) {
-	const parent = components[sourceKey];
-	if (!parent) throw new Error(`Component extension: "${sourceKey}" is not in the components record — cannot apply the extension.`);
-	const seed = { ...parent };
-	const childNames = parent.subcomponents ?? [];
-	if (childNames.length > 0) {
-		const children = {};
-		for (const childName of childNames) {
-			const child = components[childName];
-			if (child) children[childName] = child;
-		}
-		seed.__subcomponents = children;
-	}
-	const { result, inverse } = applyComponentExtension(seed, payload);
-	const { __subcomponents: mergedChildren, ...parentDef } = result;
-	const next = {
-		...components,
-		[sourceKey]: parentDef
-	};
-	for (const [childName, child] of Object.entries(mergedChildren ?? {})) next[childName] = child;
-	return {
-		components: next,
-		record: {
-			payload,
-			inverse
-		}
-	};
-}
-/**
-* Wrap a registry barrel component definition, attaching the non-enumerable
-* `.extend(patch)`. Non-enumerable keeps the barrel value JSON-clean, the
-* same convention as `defineComponent`'s chain methods.
-*/
-function linkedComponent(def) {
-	Object.defineProperty(def, "extend", {
-		enumerable: false,
-		configurable: true,
-		writable: true,
-		value: function extend(patch) {
-			if (!def.link) throw new Error("Component extension: this component carries no link marker — .extend() only applies to components linked from another system.");
-			if (def.extension) throw new Error("Component extension: this component already carries an extension — edit the existing .extend({...}) payload instead of chaining a second one.");
-			const { result, inverse } = applyComponentExtension(def, patch);
-			result.extension = {
-				payload: patch,
-				inverse
-			};
-			return result;
-		}
-	});
-	return def;
-}
-//#endregion
-export { applyComponentExtension, applyComponentExtensionInverse, extendSerializedComponents, linkedComponent };