@yahoo/uds-create-config 1.1.1

package/dist/jsx/jsx-runtime.js

@@ -0,0 +1,305 @@
+import { foreignComponentName } from "../foreign-component-name.js";
+//#region src/jsx/jsx-runtime.ts
+const Fragment = Symbol.for("react.fragment");
+let configContext = null;
+function setConfigContext(config) {
+	configContext = config;
+}
+function getConfigContext() {
+	return configContext;
+}
+let counter = 0;
+function nextKey() {
+	return `el${counter++}`;
+}
+const pendingRefs = /* @__PURE__ */ new Map();
+let refCounter = 0;
+function nextRefId() {
+	return `__udsRef_${refCounter++}`;
+}
+let renderScope = null;
+let wrapperCounter = 0;
+const TRANSPARENT_WRAPPERS = new Set([
+	"AnimatePresence",
+	"MotionConfig",
+	"LazyMotion"
+]);
+/**
+* Scope subsequent wrapper-type resolution to `componentName` (or clear it
+* with `null`). Resets the per-component wrapper index so stamped names are
+* stable across runs regardless of global element-key state.
+*/
+function setRenderExtractionContext(componentName) {
+	renderScope = componentName;
+	wrapperCounter = 0;
+}
+/**
+* Reset all module-level state — element key counter, pending-ref
+* registry, ref counter, and render-extraction scope. Called by tests
+* asserting specific keys and by the extractor before each top-level
+* evaluation.
+*/
+function __resetKeyCounterForTesting() {
+	counter = 0;
+	pendingRefs.clear();
+	refCounter = 0;
+	renderScope = null;
+	wrapperCounter = 0;
+}
+/**
+* Drain and return the pending-ref registry. Called by the extractor
+* after `import()`-ing a bundle to rewrite `__udsRef_N` placeholders to
+* the component names that `registerComponents` has now stamped onto
+* each builder.
+*/
+function __drainPendingRefs() {
+	const drained = new Map(pendingRefs);
+	pendingRefs.clear();
+	refCounter = 0;
+	return drained;
+}
+/**
+* JSX automatic-runtime entry for a single static child. Compilers pick
+* this signature when the JSX expression has zero or one child.
+*/
+function jsx(type, props) {
+	return buildSpec(type, props);
+}
+/**
+* JSX automatic-runtime entry for static children — same semantics as
+* `jsx`, the distinction is purely a compiler hint that `props.children`
+* is an array literal.
+*/
+function jsxs(type, props) {
+	return buildSpec(type, props);
+}
+function collectChildren(childList, parentTypeName) {
+	const mergedElements = {};
+	const childKeys = [];
+	let textBuffer = "";
+	let hasText = false;
+	let hasElementChildren = false;
+	for (const child of childList) {
+		if (child === null || child === void 0 || typeof child === "boolean") continue;
+		if (typeof child === "string") {
+			textBuffer += child;
+			hasText = true;
+		} else if (typeof child === "number") {
+			textBuffer += String(child);
+			hasText = true;
+		} else if (isSpec(child)) {
+			const inlineText = parentTypeName === "Text" ? plainTextContent(child) : null;
+			if (inlineText !== null) {
+				textBuffer += inlineText;
+				hasText = true;
+			} else {
+				for (const [k, el] of Object.entries(child.elements)) mergedElements[k] = el;
+				childKeys.push(child.root);
+				hasElementChildren = true;
+			}
+		}
+	}
+	return {
+		mergedElements,
+		childKeys,
+		textBuffer,
+		hasText,
+		hasElementChildren
+	};
+}
+/**
+* True when `type` is a third-party composition wrapper to elide from a
+* captured render spec. A UDS component (carries `__componentName`), a
+* `Fragment`, and an intrinsic tag (passed as a string) are real anatomy and
+* never elided. Among the rest, a node with a `render` target (the
+* ariakit/Radix `asChild` pattern) or with meaningful children is plumbing
+* that wraps real content; a node with neither is a genuine visual leaf (an
+* icon) and stays. Caller gates this on render-extraction scope.
+*/
+function isElidableWrapper(type, restProps, childList) {
+	if (type === Fragment) return false;
+	if (typeof type !== "object" && typeof type !== "function") return false;
+	if (typeof type.__componentName === "string") return false;
+	const hasRenderTarget = isSpec(restProps.render);
+	const hasMeaningfulChildren = childList.some((c) => c !== null && c !== void 0 && typeof c !== "boolean");
+	return hasRenderTarget || hasMeaningfulChildren;
+}
+/**
+* Collapse an elided wrapper into its real content. With a `render` target
+* (ariakit/Radix `asChild`), the wrapper renders *as* that UDS element, so we
+* surface the target as the node and fold the wrapper's own children into it —
+* faithful to how those libraries compose. Without one (a pure context
+* provider like ariakit's `MenuProvider`), it collapses to a `Fragment` so its
+* children render through. Either way no foreign type reaches the spec.
+*/
+function elideWrapper(renderValue, childList) {
+	const { mergedElements, childKeys, textBuffer, hasText, hasElementChildren } = collectChildren(childList, "");
+	if (isSpec(renderValue)) {
+		const elements = {
+			...renderValue.elements,
+			...mergedElements
+		};
+		const target = elements[renderValue.root];
+		const foldedChildren = [...target.children ?? [], ...childKeys];
+		const updated = { ...target };
+		if (foldedChildren.length > 0) updated.children = foldedChildren;
+		if (hasText && !hasElementChildren) updated.props = {
+			...target.props,
+			children: textBuffer
+		};
+		elements[renderValue.root] = updated;
+		return {
+			root: renderValue.root,
+			elements
+		};
+	}
+	const element = {
+		type: "Fragment",
+		props: {}
+	};
+	if (hasElementChildren) element.children = childKeys;
+	if (hasText && !hasElementChildren) element.props = { children: textBuffer };
+	const key = nextKey();
+	mergedElements[key] = element;
+	return {
+		root: key,
+		elements: mergedElements
+	};
+}
+/**
+* Inline a dynamically-resolved leaf component into a captured render spec.
+* Icon's `.render()` picks a glyph by name (`const Glyph = UdsIcons[name]`) and
+* mounts `<Glyph .../>`; the glyph is a plain function component, so it would
+* otherwise be stamped a synthetic `<scope>:<base>:<n>` type nothing resolves —
+* it isn't registered, and a dynamic namespace lookup can't be traced to a
+* `foreign:` import. Invoking it here (it returns a `Spec` through this same
+* runtime, since the captured module is compiled against it) splices its real
+* output — the `<path>` subtree — into the spec, so the Internals view paints
+* the actual glyph instead of a blank node.
+*
+* Render-extraction only (gated by the caller on `renderScope`), and
+* best-effort: a function that throws when invoked outside React (hooks,
+* context) or returns a non-`Spec` (a context provider returning `null`, a
+* glyph with no matching variant) yields `null`, and the caller falls back to
+* the synthetic type — no worse than today.
+*/
+function tryInlineDynamicLeaf(type, props) {
+	if (typeof type !== "function") return null;
+	const named = type;
+	if (typeof named.__componentName === "string") return null;
+	let base = "";
+	if (typeof named.displayName === "string" && named.displayName.length > 0) base = named.displayName;
+	else if (typeof named.name === "string" && named.name.length > 0) base = named.name;
+	if (TRANSPARENT_WRAPPERS.has(base)) return null;
+	try {
+		const result = type(props);
+		return isSpec(result) ? result : null;
+	} catch {
+		return null;
+	}
+}
+function buildSpec(type, props) {
+	const { children, ...restProps } = props;
+	const childList = normalizeChildren(children);
+	if (renderScope !== null && isElidableWrapper(type, restProps, childList)) return elideWrapper(restProps.render, childList);
+	if (renderScope !== null) {
+		const inlined = tryInlineDynamicLeaf(type, props);
+		if (inlined) return inlined;
+	}
+	const typeName = resolveTypeName(type);
+	const collected = collectChildren(childList, typeName);
+	const { mergedElements } = collected;
+	const { childKeys, textBuffer, hasText } = collected;
+	let { hasElementChildren } = collected;
+	const elementProps = { ...restProps };
+	if (hasText && !hasElementChildren) elementProps.children = textBuffer;
+	for (const [propName, value] of Object.entries(elementProps)) {
+		if (isSpec(value)) {
+			for (const [k, el] of Object.entries(value.elements)) mergedElements[k] = el;
+			childKeys.push(value.root);
+			hasElementChildren = true;
+			elementProps[propName] = { $slot: value.root };
+			continue;
+		}
+		if (Array.isArray(value) && value.length > 0 && value.every(isSpec)) {
+			const refs = [];
+			for (const spec of value) {
+				for (const [k, el] of Object.entries(spec.elements)) mergedElements[k] = el;
+				childKeys.push(spec.root);
+				refs.push(spec.root);
+			}
+			hasElementChildren = true;
+			elementProps[propName] = { $slot: refs };
+		}
+	}
+	if (childKeys.length === 1 && mergedElements[childKeys[0]]?.type === "Slot") elementProps.children = { $slot: childKeys[0] };
+	const element = {
+		type: typeName,
+		props: elementProps
+	};
+	if (hasElementChildren) element.children = childKeys;
+	const key = nextKey();
+	mergedElements[key] = element;
+	return {
+		root: key,
+		elements: mergedElements
+	};
+}
+function normalizeChildren(children) {
+	if (children === void 0 || children === null) return [];
+	if (Array.isArray(children)) return children.flat(Number.POSITIVE_INFINITY);
+	return [children];
+}
+function resolveTypeName(type) {
+	if (type === Fragment) return "Fragment";
+	if (typeof type === "string") return type;
+	const isObjectOrFn = type !== null && (typeof type === "object" || typeof type === "function");
+	if (isObjectOrFn) {
+		const named = type;
+		if (typeof named.__componentName === "string") return named.__componentName;
+	}
+	const foreign = foreignComponentName(type);
+	if (foreign !== null) return `foreign:${foreign}`;
+	if (typeof type === "function") {
+		const fn = type;
+		let base = null;
+		if (typeof fn.displayName === "string" && fn.displayName.length > 0) base = fn.displayName;
+		else if (typeof fn.name === "string" && fn.name.length > 0) base = fn.name;
+		if (base !== null) {
+			if (TRANSPARENT_WRAPPERS.has(base)) return "Fragment";
+			if (renderScope === null) return base;
+			return `${renderScope}:${base}:${wrapperCounter++}`;
+		}
+	}
+	if (isObjectOrFn) {
+		const id = nextRefId();
+		pendingRefs.set(id, type);
+		return id;
+	}
+	return "Unknown";
+}
+function isSpec(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.root === "string" && typeof candidate.elements === "object" && candidate.elements !== null;
+}
+/**
+* If `spec` is a self-contained `Text` node carrying only string content,
+* return that string; otherwise `null`. This is the shape the extractor
+* synthesises for a string/number slot default. A real authored text layer
+* carries `data-uds-layer` (and is never collapsed); the synthetic slot node
+* never does, so absence of that marker — plus a single element whose only
+* prop is the string `children` — identifies it precisely.
+*/
+function plainTextContent(spec) {
+	if (Object.keys(spec.elements).length !== 1) return null;
+	const el = spec.elements[spec.root];
+	if (!el || el.type !== "Text") return null;
+	if (el.children && el.children.length > 0) return null;
+	const props = el.props ?? {};
+	if (typeof props.children !== "string") return null;
+	if (Object.keys(props).some((k) => k !== "children")) return null;
+	return props.children;
+}
+//#endregion
+export { Fragment, __drainPendingRefs, __resetKeyCounterForTesting, getConfigContext, jsx, jsxs, setConfigContext, setRenderExtractionContext };

package/dist/markers.d.ts

@@ -0,0 +1,217 @@
+import { AssetGroupRef } from "./refs.js";
+import { ComponentDefinition } from "./types.js";
+
+//#region src/markers.d.ts
+/**
+ * A slot's `.accepts(...)` argument: a registered component definition, or a
+ * placeable asset group returned by `defineAssetGroup(...).config(...)` (it
+ * carries the `AssetGroupRef` tag). The two are kept distinct downstream —
+ * component names land on `SlotInfo.accepts`, the asset-group slug on
+ * `SlotInfo.acceptsAssetGroup` — so the designer panel can pick the right
+ * picker. Non-placeable groups (fonts) are admitted by the type but rejected
+ * at config load.
+ */
+type SlotAccepts = ComponentDefinition | AssetGroupRef;
+/**
+ * Brand applied to a marker by `.required()`. Lives alongside the
+ * marker interfaces so the slot factories (whose `.required()`
+ * implementation is co-located with `.accepts()` rather than going
+ * through `attachRequired`) can return the brand-narrowed type via
+ * the interface signature.
+ *
+ * `RenderPropsFromConfig` reads this brand to decide whether a render-
+ * fn destructure entry is optional (`T | undefined`) or non-optional
+ * (`T`). Distinct from `__required?: boolean` on the marker bodies —
+ * that field is the runtime flag codegen reads; the brand is the
+ * compile-time signal the render-arg type-flow keys on.
+ */
+type RequiredBrand = {
+  __required: true;
+};
+/**
+ * Author-declared slot value kind. A slot holds renderable content; the only
+ * explicit kind is text:
+ *
+ *   - `'string'` — plain text content (e.g. Button's `children` label).
+ *
+ * An open `slot()` is a node container (`ReactNode`) by default — it accepts
+ * dropped layers and is narrowed to specific components via `.accepts(...)`;
+ * `'string'` instead marks a text surface, so tools like the Studio canvas
+ * inline-edit it rather than treat it as a reparent target. Scalars like
+ * boolean and number are *not* slots — use the dedicated `bool()` / `number()`
+ * markers. (A `'string'` slot still *resolves* to `SlotValueKind: 'ReactNode'`,
+ * since a string is a valid `ReactNode`; `authoredType` records the intent.)
+ *
+ *   - `'component'` — the slot resolves to a `FunctionComponent`, not rendered
+ *     content. Used by the aliased `Icon` pattern (`name: slot({ type:
+ *     'component' }).accepts(icons)`), where the render fn receives the icon
+ *     component itself (`({ name: SvgIcon }) => <SvgIcon … />`) and the saved
+ *     value is the inline asset-name string (`"Trophy"`), not a `$slot` ref.
+ *     A `'component'` slot *requires* an asset-group `.accepts(...)` — config
+ *     load throws otherwise.
+ */
+type SlotValueType = 'string' | 'component';
+/**
+ * Open-slot marker — `slot()` with no arguments. Codegen treats it as
+ * `ReactNode` accepted at the component's own children. Carries no
+ * cross-reference; `__accepts` / `__required` may still be set via the
+ * chain methods to constrain the slot's children or mark it required.
+ * `__valueType` records an explicit `slot({ type })` override (absent ⇒
+ * the default `ReactNode`).
+ */
+interface SlotMarker {
+  readonly __kind: 'slot';
+  readonly __required?: boolean;
+  readonly __accepts?: readonly SlotAccepts[];
+  readonly __valueType?: SlotValueType;
+  /**
+   * Stamp `__required: true` on the marker. Codegen reads this per-prop
+   * and emits the JSX prop without a trailing `?`, so the slot becomes
+   * mandatory at call sites. The return type also intersects
+   * `RequiredBrand` so `RenderPropsFromConfig` narrows the render-fn
+   * destructure entry to non-optional.
+   */
+  required(): SlotMarker & RequiredBrand;
+  /**
+   * Constrain the slot's accepted children to one or more registered
+   * components, or to a placeable asset group (`slot().accepts(icons)`).
+   */
+  accepts(component: SlotAccepts | readonly SlotAccepts[]): SlotMarker;
+}
+/**
+ * A `slot({ type: 'component' })` marker — the aliased `Icon` pattern. Carries
+ * the literal `__valueType: 'component'` so `ResolveMarker` resolves the prop
+ * to a `ComponentType` (the render fn receives the icon component itself), and
+ * narrows `.accepts(...)` to asset groups only (a component-typed slot must
+ * accept an asset group). The chained `.accepts(...)` preserves this type so
+ * the literal survives to the render-fn inference.
+ */
+interface ComponentSlotMarker extends SlotMarker {
+  readonly __valueType: 'component';
+  accepts(group: AssetGroupRef | readonly AssetGroupRef[]): ComponentSlotMarker;
+}
+/**
+ * Layer-targeting slot ref — `slot('layer')`, `slot('layer/prop')`, or
+ * `slot('layer', { prop })`. Routes a JSX prop into the named layer's
+ * `layerProp` (defaults to `'children'` when only a layer is given).
+ * The `layer` field is the cross-reference — that's what makes this a
+ * Ref rather than a Marker.
+ */
+interface SlotRef<TLayer extends string = string, TAs extends string = string> {
+  readonly __kind: 'slot';
+  readonly layer: TLayer;
+  readonly layerProp: TAs;
+  readonly __required?: boolean;
+  readonly __accepts?: readonly SlotAccepts[];
+  /** Output adapter set via `.transform(fn)` — codegen wraps the
+   *  layer's prop so the consumer-facing handler receives `fn(arg)`
+   *  instead of the raw layer value (e.g. an input event → its
+   *  string value). Must be self-contained (no closure over outer
+   *  scope) since codegen lifts it into the generated module. */
+  readonly __transform?: (arg: never) => unknown;
+  readonly __valueType?: SlotValueType;
+  required(): SlotRef<TLayer, TAs> & RequiredBrand;
+  accepts(component: SlotAccepts | readonly SlotAccepts[]): SlotRef<TLayer, TAs>;
+  transform<Out>(fn: (arg: unknown) => Out): SlotRef<TLayer, TAs> & {
+    readonly __transformOut: Out;
+  };
+}
+/**
+ * Runtime guard for any slot binding (open marker or layered ref).
+ * Callers that need to distinguish the two forms narrow further by
+ * checking for the `layer` field — `'layer' in value`.
+ */
+declare function isSlotMarker(value: unknown): value is SlotMarker | SlotRef;
+interface BooleanMarker {
+  readonly __kind: 'boolean';
+  readonly __required?: boolean;
+  readonly values?: {
+    true?: Record<string, Record<string, unknown>>;
+    false?: Record<string, Record<string, unknown>>;
+  };
+}
+declare function isBoolMarker(value: unknown): value is BooleanMarker;
+interface VariantMarkerObject<V extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> {
+  readonly __kind: 'variant';
+  readonly __required?: boolean;
+  readonly values: V;
+  readonly default?: keyof V & string;
+}
+interface VariantMarkerArray<V extends readonly (string | number)[] = readonly (string | number)[]> {
+  readonly __kind: 'variant';
+  readonly __required?: boolean;
+  readonly values: V;
+  readonly default?: V[number];
+}
+type VariantMarker<V = unknown> = V extends readonly (string | number)[] ? VariantMarkerArray<V> : V extends Record<string, Record<string, unknown>> ? VariantMarkerObject<V> : VariantMarkerObject | VariantMarkerArray;
+declare function isVariantMarker(value: unknown): value is VariantMarker;
+/**
+ * Distinguish the two variant forms. `Array.isArray(marker.values)` is the
+ * single source of truth — every downstream consumer that branches on
+ * the form goes through this helper rather than duplicating the check.
+ */
+declare function isVariantArrayMarker(value: VariantMarker): value is VariantMarkerArray;
+interface StringMarker {
+  readonly __kind: 'string';
+  readonly __required?: boolean;
+}
+interface NumberMarker {
+  readonly __kind: 'number';
+  readonly __required?: boolean;
+}
+declare function isStringMarker(value: unknown): value is StringMarker;
+declare function isNumberMarker(value: unknown): value is NumberMarker;
+interface LayerMarker {
+  readonly __kind: 'layer';
+  readonly layer: string;
+  readonly styles: Record<string, unknown>;
+}
+declare function isLayerMarker(value: unknown): value is LayerMarker;
+/**
+ * One conditional override for a `props` axis: apply `props` to the cell
+ * when every key in `when` matches the cell's other-axis values. A rule
+ * with no `when` always applies (the base). Later matching rules win.
+ */
+interface PreviewPropsRule {
+  readonly when?: Readonly<Record<string, unknown>>;
+  readonly props: Readonly<Record<string, unknown>>;
+}
+/**
+ * Synthetic discriminator state a `props` axis compiles to, per axis side.
+ * The entry's label is the value. Codegen keys the merged spec's `$cond`
+ * on this, and the studio seeds it per cell — both derive it here so they
+ * never drift. (`columns`/`rows` entries are concatenated as sibling
+ * values of one dimension, so one key per side suffices.)
+ */
+declare const PREVIEW_SEED_KEY: {
+  readonly row: "__previewSeedRow";
+  readonly column: "__previewSeedCol";
+};
+/** True when every key in `when` equals the cell coordinate's value. */
+declare function matchesPreviewWhen(when: Readonly<Record<string, unknown>> | undefined, coord: Readonly<Record<string, unknown>>): boolean;
+/**
+ * Merge the `props` of every rule whose `when` matches `coord` (in order,
+ * so later matching rules win). Shared by codegen's combo enumeration and
+ * the studio's cell assembly so a `props` axis resolves identically.
+ */
+declare function resolvePreviewRules(rules: readonly PreviewPropsRule[], coord: Readonly<Record<string, unknown>>): Record<string, unknown>;
+interface PreviewAxisMarker {
+  readonly __kind: 'previewAxis';
+  /** Axis name — either a prop name or a `_${string}` modifier. */
+  readonly prop?: string;
+  readonly modifier?: string;
+  /**
+   * `props` axis rules — per-cell prop-override bags, optionally guarded
+   * by `when` against the other axes' values. Lets a preview vary
+   * render-extra data per cell (e.g. sample `value`) without declaring a
+   * config prop. Resolved against the cell coordinate by the studio and
+   * by codegen's combo enumeration.
+   */
+  readonly rules?: readonly PreviewPropsRule[];
+  readonly kind: 'prop' | 'modifier' | 'props';
+  readonly nested?: PreviewAxisMarker;
+  nest(child: PreviewAxisMarker): PreviewAxisMarker;
+}
+declare function isPreviewAxisMarker(value: unknown): value is PreviewAxisMarker;
+//#endregion
+export { BooleanMarker, ComponentSlotMarker, LayerMarker, NumberMarker, PREVIEW_SEED_KEY, PreviewAxisMarker, PreviewPropsRule, RequiredBrand, SlotMarker, SlotRef, SlotValueType, StringMarker, VariantMarker, VariantMarkerArray, VariantMarkerObject, isBoolMarker, isLayerMarker, isNumberMarker, isPreviewAxisMarker, isSlotMarker, isStringMarker, isVariantArrayMarker, isVariantMarker, matchesPreviewWhen, resolvePreviewRules };

package/dist/markers.js

@@ -0,0 +1,67 @@
+//#region src/markers.ts
+/**
+* Runtime guard for any slot binding (open marker or layered ref).
+* Callers that need to distinguish the two forms narrow further by
+* checking for the `layer` field — `'layer' in value`.
+*/
+function isSlotMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "slot";
+}
+function isBoolMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "boolean";
+}
+function isVariantMarker(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	if (v.__kind !== "variant") return false;
+	return Array.isArray(v.values) || typeof v.values === "object";
+}
+/**
+* Distinguish the two variant forms. `Array.isArray(marker.values)` is the
+* single source of truth — every downstream consumer that branches on
+* the form goes through this helper rather than duplicating the check.
+*/
+function isVariantArrayMarker(value) {
+	return Array.isArray(value.values);
+}
+function isStringMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "string";
+}
+function isNumberMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "number";
+}
+function isLayerMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "layer";
+}
+/**
+* Synthetic discriminator state a `props` axis compiles to, per axis side.
+* The entry's label is the value. Codegen keys the merged spec's `$cond`
+* on this, and the studio seeds it per cell — both derive it here so they
+* never drift. (`columns`/`rows` entries are concatenated as sibling
+* values of one dimension, so one key per side suffices.)
+*/
+const PREVIEW_SEED_KEY = {
+	row: "__previewSeedRow",
+	column: "__previewSeedCol"
+};
+/** True when every key in `when` equals the cell coordinate's value. */
+function matchesPreviewWhen(when, coord) {
+	if (!when) return true;
+	for (const key of Object.keys(when)) if (coord[key] !== when[key]) return false;
+	return true;
+}
+/**
+* Merge the `props` of every rule whose `when` matches `coord` (in order,
+* so later matching rules win). Shared by codegen's combo enumeration and
+* the studio's cell assembly so a `props` axis resolves identically.
+*/
+function resolvePreviewRules(rules, coord) {
+	const out = {};
+	for (const rule of rules) if (matchesPreviewWhen(rule.when, coord)) Object.assign(out, rule.props);
+	return out;
+}
+function isPreviewAxisMarker(value) {
+	return typeof value === "object" && value !== null && value.__kind === "previewAxis";
+}
+//#endregion
+export { PREVIEW_SEED_KEY, isBoolMarker, isLayerMarker, isNumberMarker, isPreviewAxisMarker, isSlotMarker, isStringMarker, isVariantArrayMarker, isVariantMarker, matchesPreviewWhen, resolvePreviewRules };