@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/native/values.d.ts

@@ -1,7 +0,0 @@
-import { OperatingSystemInput, OperatingSystemValue } from "./types.js";
-
-//#region src/native/values.d.ts
-declare function operatingSystem(input: OperatingSystemInput): OperatingSystemValue;
-declare function isOperatingSystemValue(value: unknown): value is OperatingSystemValue;
-//#endregion
-export { isOperatingSystemValue, operatingSystem };

package/dist/native/values.js

@@ -1,15 +0,0 @@
-//#region src/native/values.ts
-function operatingSystem(input) {
-	if (input.default === void 0 && (input.ios === void 0 || input.android === void 0)) throw new Error("operatingSystem() requires a default value or explicit ios and android values.");
-	return {
-		__kind: "operatingSystem",
-		...input.default !== void 0 ? { default: input.default } : {},
-		...input.ios !== void 0 ? { ios: input.ios } : {},
-		...input.android !== void 0 ? { android: input.android } : {}
-	};
-}
-function isOperatingSystemValue(value) {
-	return typeof value === "object" && value !== null && value.__kind === "operatingSystem";
-}
-//#endregion
-export { isOperatingSystemValue, operatingSystem };

package/dist/native.d.ts

@@ -1,12 +0,0 @@
-import { AssetRef, TokenRef, asset, token } from "./refs.js";
-import { ColorSpace, MixExpr, alpha, mix } from "./colorExpressions.js";
-import { SystemLink, TokenType } from "./types.js";
-import { NativeComponentBuilder, NativeComponentDefinition, NativeComponentGroupDefinition, NativeComponentProps, NativeComponentStyleHelpers, NativeComponentStyledBuilder, NativeComponentStyles, NativeLayerDefinition, NativeLayerKind, NativeLayerStyle, NativeLayerStyles, NativeRenderProps, NativeStyleValue, RegisteredNativeComponent, SerializedNativeComponentGroup, defineNativeComponent, defineNativeComponentGroup, nativeLayer } from "./native/components.js";
-import { ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupDefinition, NativeBuildOptions, NativeColorExpression, NativeDefaultModes, NativeDependencyPolicy, NativeDependencyPolicyEntry, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeSelectableValue, NativeStyleEngine, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig } from "./native/types.js";
-import { NativeAssetGroupBuilder, NativeFontAssetGroupConfig, defineAssetGroup } from "./native/assets.js";
-import { defineMode } from "./native/modes.js";
-import { NativeConfigDiagnostic, NativeConfigDiagnosticCode, validateSerializedNativeConfig } from "./native/validation.js";
-import { NativeConfig, NativeConfigValidationError } from "./native/NativeConfig.js";
-import { isOperatingSystemValue, operatingSystem } from "./native/values.js";
-import { DefinedNativeTokenGroup, defineTokenGroup } from "./native/index.js";
-export { AssetRef, ColorSpace, DefinedNativeTokenGroup, MixExpr, ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupBuilder, NativeAssetGroupDefinition, NativeBuildOptions, NativeColorExpression, NativeComponentBuilder, NativeComponentDefinition, NativeComponentGroupDefinition, NativeComponentProps, NativeComponentStyleHelpers, NativeComponentStyledBuilder, NativeComponentStyles, NativeConfig, NativeConfigDiagnostic, NativeConfigDiagnosticCode, NativeConfigValidationError, NativeDefaultModes, NativeDependencyPolicy, NativeDependencyPolicyEntry, NativeFontAssetGroupConfig, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLayerDefinition, NativeLayerKind, NativeLayerStyle, NativeLayerStyles, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeRenderProps, NativeSelectableValue, NativeStyleEngine, NativeStyleValue, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, RegisteredNativeComponent, SerializedNativeComponentGroup, SerializedNativeConfig, SystemLink, TokenRef, TokenType, alpha, asset, defineAssetGroup, defineMode, defineNativeComponent, defineNativeComponentGroup, defineTokenGroup, isOperatingSystemValue, mix, nativeLayer, operatingSystem, token, validateSerializedNativeConfig };

package/dist/native.js

@@ -1,10 +0,0 @@
-import { asset, token } from "./refs.js";
-import { alpha, mix } from "./colorExpressions.js";
-import { defineAssetGroup } from "./native/assets.js";
-import { defineNativeComponent, defineNativeComponentGroup, nativeLayer } from "./native/components.js";
-import { defineMode } from "./native/modes.js";
-import { isOperatingSystemValue, operatingSystem } from "./native/values.js";
-import { validateSerializedNativeConfig } from "./native/validation.js";
-import { NativeConfig, NativeConfigValidationError } from "./native/NativeConfig.js";
-import { defineTokenGroup } from "./native/index.js";
-export { NativeConfig, NativeConfigValidationError, alpha, asset, defineAssetGroup, defineMode, defineNativeComponent, defineNativeComponentGroup, defineTokenGroup, isOperatingSystemValue, mix, nativeLayer, operatingSystem, token, validateSerializedNativeConfig };

package/dist/refs.d.ts

@@ -1,204 +0,0 @@
-//#region src/refs.d.ts
-/**
- * Cross-reference markers — the `{ __kind, ref }` shapes that appear in
- * authored values and in the wire format. Each one represents "this
- * position holds a pointer to another resource, not a literal."
- *
- * Naming:
- *
- *  - `<X>Name` — the string-side identifier (`'color/brand'`, `'Box'`).
- *    Narrowed when the matching `Registered*` interface is augmented;
- *    falls open to `string` otherwise.
- *  - `<X>Ref` — the boxed marker shape `{ __kind, ref }` carrying an
- *    `<X>Name`. Distinguishes a pointer from a literal at every position
- *    that can hold either.
- *  - `<x>()` — the helper that constructs an `<X>Ref` from an `<X>Name`.
- *  - `is<X>Ref(value)` — type guard for use by the resolver and patch
- *    system.
- *
- * # Augmented refs
- *
- * The `Registered*` interfaces below are augmentation seams that
- * consumer codegen populates via `declare module '@yahoo/uds-create-config' {
- * interface Registered* { ... } }`. When augmented, each ref's `ref`
- * field narrows to only valid references — `token('color/brand')` is OK
- * but `token('color/nope')` is a compile error. When un-augmented (this
- * package's own tests, fresh consumers before first build), the ref
- * accepts any string — codegen narrows it later.
- */
-interface RegisteredTokenGroups {}
-interface RegisteredModifiers<T> {}
-interface RegisteredModes {}
-interface RegisteredCompositeStyles {}
-interface RegisteredStyleProps {}
-interface RegisteredComponents {}
-interface RegisteredMotion {}
-interface RegisteredAssetGroups {}
-interface TokenRawNameRegistry {}
-/** `<groupName>/<tokenName>` for every registered token. */
-type TokenName = [keyof RegisteredTokenGroups] extends [never] ? string : { [G in keyof RegisteredTokenGroups & string]: `${G}/${keyof RegisteredTokenGroups[G] & string}` }[keyof RegisteredTokenGroups & string];
-/** Bare group names — `'color'`, `'spacing'`. */
-type TokenGroupName = [keyof RegisteredTokenGroups] extends [never] ? string : keyof RegisteredTokenGroups & string;
-/**
- * Bare composite name (`'elevation'`) or `<name>/<variant>`
- * (`'elevation/1'`).
- *
- * Indexes straight into `['styles']` rather than routing each member
- * through an `extends { styles: infer V } ? … : never` conditional, for
- * the same reason as `ModeName` — same resulting union, but no per-member
- * conditional check + `infer`, and one consistent shape across every
- * `*Name` union.
- */
-type CompositeName = [keyof RegisteredCompositeStyles] extends [never] ? `${string}/${string}` : (keyof RegisteredCompositeStyles & string) | { [C in keyof RegisteredCompositeStyles & string]: `${C}/${keyof RegisteredCompositeStyles[C]['styles'] & string}` }[keyof RegisteredCompositeStyles & string];
-/**
- * `<modeName>/<optionName>` for every registered mode option.
- *
- * Indexes straight into `['options']` rather than routing each member
- * through an `extends { options: infer O } ? … : never` conditional.
- * Both yield the same union, but the indexed access skips a per-member
- * conditional assignability check + `infer`, so it's cheaper for the
- * checker and keeps every `*Name` union on the one shape `TokenName`
- * uses.
- */
-type ModeName = [keyof RegisteredModes] extends [never] ? `${string}/${string}` : { [M in keyof RegisteredModes & string]: `${M}/${keyof RegisteredModes[M]['options'] & string}` }[keyof RegisteredModes & string];
-/** Style-prop names — `'bg'`, `'padding'`. */
-type StylePropName = [keyof RegisteredStyleProps] extends [never] ? string : keyof RegisteredStyleProps & string;
-/** Registered component names — `'Box'`, `'Alert'`. */
-type ComponentName = [keyof RegisteredComponents] extends [never] ? string : keyof RegisteredComponents & string;
-/** Registered `registerMotion({...})` preset names — `'fadeIn'`, `'slideUp'`.
- *  Falls open to `string` when the registry isn't augmented (this package's
- *  own compilation), so a `motion()` prop still typechecks in isolation. */
-type MotionName = [keyof RegisteredMotion] extends [never] ? string : keyof RegisteredMotion & string;
-/** Bare asset-group slugs — `'icons'`, `'fonts'`. */
-type AssetGroupName = [keyof RegisteredAssetGroups] extends [never] ? string : keyof RegisteredAssetGroups & string;
-/**
- * Member-level asset name — `<slug>/<member>` (`'fonts/yas'`). Narrows the
- * group slug against the registered set; the member segment stays open
- * `string` for now (codegen doesn't yet emit per-group member keys into
- * `RegisteredAssetGroups`, so we can't narrow it without collapsing the
- * union to `never`). Falls fully open to `${string}/${string}` before any
- * asset group is registered.
- */
-type AssetName = [keyof RegisteredAssetGroups] extends [never] ? `${string}/${string}` : `${keyof RegisteredAssetGroups & string}/${string}`;
-/** HTML tag names — open string for now; could narrow against `keyof JSX.IntrinsicElements`. */
-type TagName = string;
-interface TokenRef<TName extends string = string> {
-  readonly __kind: 'token';
-  readonly ref: TName;
-  /**
-   * Namespace scope for refs authored in extension payloads. Absent on
-   * source-authored refs (they resolve in their own system's namespace).
-   * `'consumer'` is stamped by the extension merge on plain `token()` refs
-   * — a consumer-authored ref always means the consumer's own tokens.
-   */
-  readonly scope?: 'consumer';
-  /** Pinned-system scope from a registry barrel's `token()` utility. */
-  readonly system?: {
-    readonly id: string;
-    readonly version: string;
-  };
-}
-interface TokenGroupRef<TName extends string = string> {
-  readonly __kind: 'tokenGroup';
-  readonly ref: TName;
-}
-interface CompositeRef<TName extends string = string, TLayer extends string | undefined = string | undefined> {
-  readonly __kind: 'composite';
-  readonly ref: TName;
-  /**
-   * Layer the marker should land on when used as a `.config()` prop
-   * binding (set by `composite(ref).on(layer)`). Absent when the ref
-   * is used as a token value, modifier selector, or as a bare prop
-   * binding that defaults to the `'root'` layer downstream.
-   */
-  readonly layer?: TLayer;
-}
-interface ModeRef<TName extends string = string> {
-  readonly __kind: 'mode';
-  readonly ref: TName;
-}
-interface StylePropRef<TName extends string = string> {
-  readonly __kind: 'styleProp';
-  readonly ref: TName;
-  readonly layer?: string;
-  /**
-   * Bind the style-prop to a specific layer — `styleProp('bg').on('root')`
-   * routes the JSX prop into the named layer instead of the component's
-   * own layer. Codegen reads the `layer` field and emits a class on
-   * that layer. Mirrors the old `@yahoo/uds-create-config` `styleProp().on()` chain.
-   */
-  on(layer: string): StylePropRef<TName>;
-}
-interface TagRef<TName extends string = string> {
-  readonly __kind: 'tag';
-  readonly ref: TName;
-}
-interface ComponentRef<TName extends string = string> {
-  readonly __kind: 'component';
-  readonly ref: TName;
-}
-/**
- * Asset-group pointer. The same `{ __kind, ref }` tag is *embedded* on
- * the full group definition `defineAssetGroup(...)` returns (the
- * definition object doubles as its own ref), so `isAssetGroupRef()` accepts
- * both the bare marker and the live group object. The definition's
- * `ref` is late-bound at `registerAssetGroups` and throws when read
- * before registration; the guard only inspects `__kind`, so it is safe
- * on unregistered groups.
- */
-interface AssetGroupRef<TName extends string = string> {
-  readonly __kind: 'assetGroup';
-  readonly ref: TName;
-}
-/**
- * Member-level asset pointer used as a token value — `asset('fonts/yas')`.
- * Unlike `AssetGroupRef` (slug-only, late-bound, embedded on the live
- * `defineAssetGroup` object), this is a plain eager marker carrying a
- * `<slug>/<member>` ref. It only ever appears as a token value, so it
- * mirrors `TokenRef`, not `AssetGroupRef` — no `.on()`, no late binding.
- */
-interface AssetRef<TName extends string = string> {
-  readonly __kind: 'asset';
-  readonly ref: TName;
-}
-type AnyRef = TokenRef | TokenGroupRef | CompositeRef | ModeRef | StylePropRef | TagRef | ComponentRef | AssetGroupRef | AssetRef;
-/** Doc-alignment alias kept for ergonomic import. */
-type TokenQualifiedName = TokenName;
-declare function token<TName extends TokenName>(ref: TName): TokenRef<TName>;
-/**
- * Curried factory behind a registry barrel's `token()` utility —
- * `yahooOs.token('color/red-1')` names THAT system's token, letting a
- * consumer mix references across pinned systems unambiguously. The plain
- * `token()` import always means the consumer's own namespace.
- */
-declare function systemToken(systemId: string, version: string): <TName extends TokenName>(ref: TName) => TokenRef<TName>;
-declare function tokenGroup<TName extends TokenGroupName>(ref: TName): TokenGroupRef<TName>;
-/**
- * `composite(ref)` returns a bare `CompositeRef` plus an `.on(layer)`
- * method that produces the same shape with `layer` filled in — both
- * forms are `CompositeRef`. Codegen's marker probe in
- * `transformAuthoringSource.ts` reads `{ __kind, ref, layer? }`
- * uniformly, so the on-layer marker is just a `CompositeRef` with a
- * concrete `layer` field.
- */
-interface CompositeRefBuilder<TName extends string> extends CompositeRef<TName, undefined> {
-  on<TLayer extends string>(layer: TLayer): CompositeRef<TName, TLayer>;
-}
-declare function composite<TName extends CompositeName>(ref: TName): CompositeRefBuilder<TName>;
-declare function mode<TName extends ModeName>(ref: TName): ModeRef<TName>;
-declare function styleProp<TName extends StylePropName>(ref: TName): StylePropRef<TName>;
-declare function tag<TName extends TagName>(ref: TName): TagRef<TName>;
-declare function component<TName extends ComponentName>(ref: TName): ComponentRef<TName>;
-declare function assetGroup<TName extends AssetGroupName>(ref: TName): AssetGroupRef<TName>;
-declare function asset<TName extends AssetName>(ref: TName): AssetRef<TName>;
-declare function isTokenRef(value: unknown): value is TokenRef;
-declare function isTokenGroupRef(value: unknown): value is TokenGroupRef;
-declare function isCompositeRef(value: unknown): value is CompositeRef;
-declare function isModeRef(value: unknown): value is ModeRef;
-declare function isStylePropRef(value: unknown): value is StylePropRef;
-declare function isTagRef(value: unknown): value is TagRef;
-declare function isComponentRef(value: unknown): value is ComponentRef;
-declare function isAssetGroupRef(value: unknown): value is AssetGroupRef;
-declare function isAssetRef(value: unknown): value is AssetRef;
-//#endregion
-export { AnyRef, AssetGroupName, AssetGroupRef, AssetName, AssetRef, ComponentName, ComponentRef, CompositeName, CompositeRef, CompositeRefBuilder, ModeName, ModeRef, MotionName, RegisteredAssetGroups, RegisteredComponents, RegisteredCompositeStyles, RegisteredModes, RegisteredModifiers, RegisteredMotion, RegisteredStyleProps, RegisteredTokenGroups, StylePropName, StylePropRef, TagName, TagRef, TokenGroupName, TokenGroupRef, TokenName, TokenQualifiedName, TokenRawNameRegistry, TokenRef, asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, systemToken, tag, token, tokenGroup };

package/dist/refs.js

@@ -1,129 +0,0 @@
-//#region src/refs.ts
-function token(ref) {
-	return {
-		__kind: "token",
-		ref
-	};
-}
-/**
-* Curried factory behind a registry barrel's `token()` utility —
-* `yahooOs.token('color/red-1')` names THAT system's token, letting a
-* consumer mix references across pinned systems unambiguously. The plain
-* `token()` import always means the consumer's own namespace.
-*/
-function systemToken(systemId, version) {
-	return (ref) => ({
-		__kind: "token",
-		ref,
-		system: {
-			id: systemId,
-			version
-		}
-	});
-}
-function tokenGroup(ref) {
-	return {
-		__kind: "tokenGroup",
-		ref
-	};
-}
-function composite(ref) {
-	return Object.assign({
-		__kind: "composite",
-		ref
-	}, { on(layer) {
-		return {
-			__kind: "composite",
-			ref,
-			layer
-		};
-	} });
-}
-function mode(ref) {
-	return {
-		__kind: "mode",
-		ref
-	};
-}
-function styleProp(ref) {
-	const marker = {
-		__kind: "styleProp",
-		ref
-	};
-	Object.defineProperty(marker, "on", {
-		enumerable: false,
-		configurable: true,
-		writable: true,
-		value(layer) {
-			const next = {
-				__kind: "styleProp",
-				ref,
-				layer
-			};
-			Object.defineProperty(next, "on", {
-				enumerable: false,
-				configurable: true,
-				writable: true,
-				value: marker.on
-			});
-			return next;
-		}
-	});
-	return marker;
-}
-function tag(ref) {
-	return {
-		__kind: "tag",
-		ref
-	};
-}
-function component(ref) {
-	return {
-		__kind: "component",
-		ref
-	};
-}
-function assetGroup(ref) {
-	return {
-		__kind: "assetGroup",
-		ref
-	};
-}
-function asset(ref) {
-	return {
-		__kind: "asset",
-		ref
-	};
-}
-function isRefOf(value, kind) {
-	return typeof value === "object" && value !== null && value.__kind === kind;
-}
-function isTokenRef(value) {
-	return isRefOf(value, "token");
-}
-function isTokenGroupRef(value) {
-	return isRefOf(value, "tokenGroup");
-}
-function isCompositeRef(value) {
-	return isRefOf(value, "composite");
-}
-function isModeRef(value) {
-	return isRefOf(value, "mode");
-}
-function isStylePropRef(value) {
-	return isRefOf(value, "styleProp");
-}
-function isTagRef(value) {
-	return isRefOf(value, "tag");
-}
-function isComponentRef(value) {
-	return isRefOf(value, "component");
-}
-function isAssetGroupRef(value) {
-	return isRefOf(value, "assetGroup");
-}
-function isAssetRef(value) {
-	return isRefOf(value, "asset");
-}
-//#endregion
-export { asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, systemToken, tag, token, tokenGroup };

package/dist/registry-aliases.d.ts

@@ -1,33 +0,0 @@
-//#region src/registry-aliases.d.ts
-/**
- * Folder slugs for the linked-system registry (UDS-2771).
- * Each top-level linked dependency gets a stable folder slug — derived
- * from the entry's `name` in the consumer's own `registerLinkedSystems`
- * pin (stable across remote renames, fixable locally on collision). The
- * pull materializer names each system's data-barrel folder
- * (`<registryDir>/<slug>/index.ts`) with it, and the link patch applier
- * writes the matching relative import — both sides derive the slug from
- * the same pin set so they can never disagree.
- */
-/** One top-level declared dependency, as needed for alias building. */
-interface RegistryAliasSource {
-  systemId: string;
-  version: string;
-  /** Display name from the consumer's registerLinkedSystems pin. */
-  name: string;
-}
-/**
- * Slug for one linked system's import alias: lowercase, hyphen-separated,
- * ASCII-safe. Names that reduce to nothing get a generic fallback (the
- * collision suffix in {@link buildRegistryAliases} keeps them distinct).
- */
-declare function slugifyLinkedName(name: string): string;
-/**
- * Map top-level declared dependencies to `slug → {systemId}@{version}` (the
- * registry folder name). Colliding slugs keep declaration order: the first
- * wins the bare slug, later ones get a `-{systemId-prefix}` suffix — still
- * deterministic across machines.
- */
-declare function buildRegistryAliases(roots: RegistryAliasSource[]): Record<string, string>;
-//#endregion
-export { RegistryAliasSource, buildRegistryAliases, slugifyLinkedName };

package/dist/registry-aliases.js

@@ -1,35 +0,0 @@
-//#region src/registry-aliases.ts
-/**
-* Slug for one linked system's import alias: lowercase, hyphen-separated,
-* ASCII-safe. Names that reduce to nothing get a generic fallback (the
-* collision suffix in {@link buildRegistryAliases} keeps them distinct).
-*/
-function slugifyLinkedName(name) {
-	const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-	return slug === "" ? "linked-system" : slug;
-}
-/**
-* Map top-level declared dependencies to `slug → {systemId}@{version}` (the
-* registry folder name). Colliding slugs keep declaration order: the first
-* wins the bare slug, later ones get a `-{systemId-prefix}` suffix — still
-* deterministic across machines.
-*/
-function buildRegistryAliases(roots) {
-	const aliases = {};
-	for (const root of roots) {
-		let slug = slugifyLinkedName(root.name);
-		if (aliases[slug] !== void 0) {
-			const collisionBase = `${slug}-${root.systemId.slice(0, 8)}`;
-			slug = collisionBase;
-			let collisionIndex = 2;
-			while (aliases[slug] !== void 0) {
-				slug = `${collisionBase}-${collisionIndex}`;
-				collisionIndex++;
-			}
-		}
-		aliases[slug] = `${root.systemId}@${root.version}`;
-	}
-	return aliases;
-}
-//#endregion
-export { buildRegistryAliases, slugifyLinkedName };

package/dist/registry-dir.d.ts

@@ -1,22 +0,0 @@
-//#region src/registry-dir.d.ts
-/**
- * Where a project's linked-system registry lives, relative to the project
- * root. One resolution rule shared by every consumer — `uds pull` (writes the
- * registry), `uds build` (regenerates linked CSS from it), the bundler
- * loaders (skip its files), and the push seal (excludes its files from a
- * consumer's own sealed sources):
- *
- *   1. `buildOptions.registryDir` when the consumer sets one;
- *   2. `<componentsDir>/registry` — the default, keeping the registry inside
- *      the design system's own subtree;
- *   3. `registry` at the project root, for configs that declare no
- *      `componentsDir`.
- */
-interface RegistryDirOptions {
-  componentsDir?: string;
-  registryDir?: string;
-}
-/** Project-root-relative POSIX path of the linked-system registry. */
-declare function resolveRegistryDir(buildOptions: RegistryDirOptions | undefined): string;
-//#endregion
-export { resolveRegistryDir };

package/dist/registry-dir.js

@@ -1,10 +0,0 @@
-//#region src/registry-dir.ts
-const normalize = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
-/** Project-root-relative POSIX path of the linked-system registry. */
-function resolveRegistryDir(buildOptions) {
-	if (buildOptions?.registryDir) return normalize(buildOptions.registryDir);
-	if (buildOptions?.componentsDir) return `${normalize(buildOptions.componentsDir)}/registry`;
-	return "registry";
-}
-//#endregion
-export { resolveRegistryDir };

package/dist/renderer/makeRegistry.d.ts

@@ -1,34 +0,0 @@
-import { AssetGroup } from "../AssetGroup.js";
-import { AssetRenderProps } from "./assetRenderable.js";
-import { RegistryDescriptor } from "./wrapRegistry.js";
-import React from "react";
-import { ComponentRegistry } from "@json-render/react";
-
-//#region src/renderer/makeRegistry.d.ts
-/** Plain, provider-free asset renderables indexed `slug → name → component`.
- *  Each is `makeAssetRenderable(SystemComponent, member, name)` — the SAME
- *  component identity the registry keys under the namespaced asset type, but
- *  surfaced directly so callers (e.g. the icon picker) can render a single
- *  glyph without standing up a json-render engine per cell. */
-type AssetMembers = ReadonlyMap<string, ReadonlyMap<string, React.ComponentType<AssetRenderProps>>>;
-interface MakeRegistryResult {
-  registry: ComponentRegistry;
-  /** @see AssetMembers — empty when the config registers no placeable assets. */
-  assetMembers: AssetMembers;
-}
-/**
- * Compose a complete json-render `ComponentRegistry` from a project's
- * UDS components. Wraps each component with a uniform prop-forwarding
- * + error-boundary `ComponentFn` (`makeUdsRenderer`), routes through
- * `defineRegistry` to adapt to the `ComponentRenderer` shape, then
- * applies the standard wrapper stack (`wrapRegistry`) so consumers
- * can render any Spec from any source (author-emitted, AI-emitted,
- * Figma import) without per-call normalisation.
- *
- * Replaces the per-project codegen that used to emit ~50 lines of
- * `${name}Renderer` function definitions plus a flat registry literal.
- * Codegen now emits a single `makeRegistry({...components})` call.
- */
-declare function makeRegistry(components: Record<string, React.ComponentType<any>>, foreignComponents?: readonly React.ComponentType<any>[], descriptor?: RegistryDescriptor, assetGroups?: Iterable<AssetGroup>): MakeRegistryResult;
-//#endregion
-export { AssetMembers, MakeRegistryResult, makeRegistry };

package/dist/renderer/makeRegistry.js

@@ -1,52 +0,0 @@
-import { isPlaceable } from "../asset-kind.js";
-import { foreignRegistryKey } from "../foreign-component-name.js";
-import { makeAssetRenderable } from "./assetRenderable.js";
-import { makeUdsRenderer } from "./makeUdsRenderer.js";
-import { wrapRegistry } from "./wrapRegistry.js";
-import { defineRegistry } from "@json-render/react";
-//#region src/renderer/makeRegistry.ts
-/**
-* Compose a complete json-render `ComponentRegistry` from a project's
-* UDS components. Wraps each component with a uniform prop-forwarding
-* + error-boundary `ComponentFn` (`makeUdsRenderer`), routes through
-* `defineRegistry` to adapt to the `ComponentRenderer` shape, then
-* applies the standard wrapper stack (`wrapRegistry`) so consumers
-* can render any Spec from any source (author-emitted, AI-emitted,
-* Figma import) without per-call normalisation.
-*
-* Replaces the per-project codegen that used to emit ~50 lines of
-* `${name}Renderer` function definitions plus a flat registry literal.
-* Codegen now emits a single `makeRegistry({...components})` call.
-*/
-function makeRegistry(components, foreignComponents = [], descriptor, assetGroups = []) {
-	const componentFns = {};
-	for (const [name, Comp] of Object.entries(components)) componentFns[name] = makeUdsRenderer(Comp, name);
-	for (const Comp of foreignComponents) {
-		const key = foreignRegistryKey(Comp);
-		if (key !== null) componentFns[key] = makeUdsRenderer(Comp, key);
-	}
-	const assetMembersBySlug = /* @__PURE__ */ new Map();
-	for (const group of assetGroups) {
-		if (!isPlaceable(group)) continue;
-		const members = group.members;
-		if (!members) continue;
-		const SystemComponent = group.component !== void 0 ? components[group.component] : void 0;
-		const bySlug = /* @__PURE__ */ new Map();
-		for (const name of group.assetNames) {
-			const member = members[name];
-			if (member === void 0) continue;
-			const key = group.assetType(name);
-			const Renderable = makeAssetRenderable(SystemComponent, member, name);
-			componentFns[key] = makeUdsRenderer(Renderable, key);
-			bySlug.set(name, Renderable);
-		}
-		assetMembersBySlug.set(group.name, bySlug);
-	}
-	const { registry } = defineRegistry(null, { components: componentFns });
-	return {
-		registry: wrapRegistry(registry, descriptor, assetMembersBySlug),
-		assetMembers: assetMembersBySlug
-	};
-}
-//#endregion
-export { makeRegistry };

package/dist/renderer/makeUdsRenderer.d.ts

@@ -1,13 +0,0 @@
-import React from "react";
-import { BaseComponentProps } from "@json-render/react";
-
-//#region src/renderer/makeUdsRenderer.d.ts
-/**
- * Component-fn signature used in `defineRegistry`'s `components` map.
- * Matches `@json-render/react`'s `BaseComponentProps` so the registry
- * lookup hands us `{ props, children, emit, bindings, ... }` directly.
- */
-type UdsComponentFn = (ctx: BaseComponentProps<Record<string, unknown>>) => React.ReactElement;
-declare function makeUdsRenderer(Comp: React.ComponentType<any>, name: string): UdsComponentFn;
-//#endregion
-export { makeUdsRenderer };

package/dist/renderer/makeUdsRenderer.js

@@ -1,51 +0,0 @@
-import { RendererErrorBoundary } from "./RendererErrorBoundary.js";
-import React from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/renderer/makeUdsRenderer.tsx
-/**
-* Minimal pass-through `ComponentFn` for any UDS component. The
-* component's own `bindRender` (codegen-emitted FC) owns variant /
-* style-prop / modifier resolution at runtime — this wrapper just
-* forwards `props` + `children` inside an error boundary.
-*
-* Replaces the per-component wrapper functions codegen used to emit
-* as a dedent string (one `${name}Renderer` function per registered
-* component, all structurally identical). The new factory composes
-* once at runtime; codegen just calls `makeRegistry({ ...components })`.
-*
-* Returns a `ComponentFn` (hoisted-props shape) so it can flow through
-* `defineRegistry` the same way the original codegen-emitted wrappers
-* did — `defineRegistry` adapts it to a `ComponentRenderer` (element-
-* shape) before `wrapRegistry` runs.
-*/
-/**
-* An injected drop-target `Slot` placeholder (`withContainerChildSlots` /
-* `withEmptyNodeSlots` in `../spec/empty-node-slots.ts`) arrives here as a
-* rendered json-render element wrapper whose spec element is `Slot`-typed —
-* the same `props.element.type` detection child-enumerating render fns use.
-* It is editing scaffolding (a canvas insertion affordance), not content.
-*/
-function isSlotPlaceholder(child) {
-	return React.isValidElement(child) && child.props.element?.type === "Slot";
-}
-function makeUdsRenderer(Comp, name) {
-	return function UdsComponentRenderer({ props, children }) {
-		const { children: propChildren, ...rest } = props;
-		const childArray = React.Children.toArray(children);
-		const hasRealChildren = childArray.some((c) => !isSlotPlaceholder(c));
-		let finalChildren;
-		if (hasRealChildren) finalChildren = children;
-		else if (propChildren != null && childArray.length > 0) finalChildren = [propChildren, ...childArray];
-		else if (childArray.length > 0) finalChildren = children;
-		else finalChildren = propChildren;
-		return /* @__PURE__ */ jsx(RendererErrorBoundary, {
-			name,
-			children: finalChildren !== void 0 && finalChildren !== null ? /* @__PURE__ */ jsx(Comp, {
-				...rest,
-				children: finalChildren
-			}) : /* @__PURE__ */ jsx(Comp, { ...rest })
-		});
-	};
-}
-//#endregion
-export { makeUdsRenderer };