@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/StyleProp.js

@@ -1,239 +0,0 @@
-import { compact } from "./entity-utils.js";
-import { isTokenGroupRef } from "./refs.js";
-//#region src/StyleProp.ts
-/**
-* `StyleProp` — a JSX prop that emits CSS (`bg`, `padding`).
-*
-* Authored field set mirrors the `StylePropDefinition` shape. The
-* `derived.tokens` projection walks the `values` array (which may
-* carry `tokenGroup()` markers) and resolves it to a flat list of
-* `Token` instances. That walk reads the parent Config's tokens map,
-* which can grow after the StyleProp is constructed, so the derived
-* tokens list recomputes on each access.
-*/
-/**
-* Whether a raw CSS value is safe to feed through {@link StyleProp.classNameFor}
-* and get back a syntactically valid class-name body. `classNameFor`'s own
-* substitution only escapes `.` and `/` — anything else (parens, commas,
-* spaces) passes through unchanged and would produce an invalid CSS selector.
-*
-* Not every `{ alias, value }` entry's `value` is meant to be authored
-* directly at a JSX/spec site: a short alias (`in-out`) can resolve to a
-* multi-argument function expression (`transitionTiming`'s
-* `cubic-bezier(0.4, 0, 0.2, 1)`) that no one would ever type as a raw prop
-* value and that can never form a valid class name. A resolved keyword like
-* `justifyContent`'s `space-between`, by contrast, is exactly the kind of
-* value a design element can (and does) carry directly. Callers that derive
-* an *additional* class keyed by the resolved value (rather than the alias)
-* must gate on this first.
-*/
-function isSafeClassNameValue(value) {
-	return /^[\w./-]+$/.test(value);
-}
-var StyleProp = class StyleProp {
-	name;
-	cssProperty;
-	classPrefix;
-	values;
-	arbitrary;
-	/**
-	* When true, the prop emits its value negated (`calc(<value> * -1)`) — the
-	* single source of negativity, read by the emitter, the runtime injector,
-	* and the MCP/guidance/lint. See {@link StylePropDefinition.negative}.
-	*/
-	negative;
-	cssType;
-	metadata;
-	opacityPair;
-	/**
-	* Optional value→CSS adapter (`gridTemplateColumns`'s `4` →
-	* `repeat(4, minmax(0, 1fr))`). Applied to enumerated `values` when deriving
-	* the utility-class body, so the native emitter produces real CSS without a
-	* Tailwind built-in. Keyword strings (`'none'`) pass through unchanged.
-	*/
-	transform;
-	#tokenLookup;
-	/** Live getter for the owning Config's class-name prefix — mirrors the
-	*  lazy `prefixGetter` pattern on Component / CompositeStyle / TokenGroup
-	*  so the prop reflects `configure({ prefix })` regardless of chain
-	*  ordering. Defaults to `'uds'` when built without an owning Config. */
-	#prefixGetter;
-	#derived;
-	/**
-	* Build the utility-class name a style prop emits for a given
-	* JSX-level value. Single source of truth shared by codegen
-	* (`@utility` emission), loader (build-time class derivation), and
-	* the runtime renderer — all three must agree byte-for-byte.
-	*
-	* Conventions (the `prefix` namespaces the whole utility body the same
-	* way component classes and CSS variables are namespaced; empty prefix
-	* yields the bare form):
-	*  - `classPrefix === ''` → the value IS the class body (`display="block"`
-	*    → `.yos-block`).
-	*  - Boolean `true` → bare `classPrefix` body (`<Box border>` →
-	*    `.yos-border`, never `.border-true`). Falsy → `undefined` (caller
-	*    omits the class).
-	*  - Bracketed arbitrary values (`'[#abc]'`) pass through verbatim.
-	*  - Otherwise `${classPrefix}-${safeTokenName(value)}` where
-	*    safeTokenName maps `.` → `_` and `/` → `-`.
-	*
-	* Static so callers without a StyleProp instance (loader's
-	* className builder, codegen's safelist scanner) can derive a class
-	* from just the prefix + value pair. Instance callers reach
-	* `styleProp.classNameFor(value)`, which supplies the owning Config's
-	* prefix automatically.
-	*/
-	static classNameFor(styleProp, value, prefix = "") {
-		if (value === void 0 || value === null || value === false) return void 0;
-		let body;
-		if (value === true) body = styleProp.classPrefix;
-		else {
-			const stringValue = String(value);
-			const safeValue = stringValue.startsWith("[") && stringValue.endsWith("]") ? stringValue : stringValue.replace(/\./g, "_").replace(/\//g, "-");
-			body = styleProp.classPrefix === "" ? safeValue : `${styleProp.classPrefix}-${safeValue}`;
-		}
-		if (!body) return void 0;
-		return prefix ? `${prefix}-${body}` : body;
-	}
-	/** Instance form of {@link StyleProp.classNameFor} — supplies the owning
-	*  Config's class-name prefix, and canonicalizes a resolved CSS keyword back
-	*  to its authored alias ({@link canonicalKeyword}) so a spec that carries
-	*  either spelling resolves to the one class the alias declared. Without
-	*  this, a no-prefix prop's resolved spelling collides across props —
-	*  `textTransform: 'none'` (alias `normal-case`) and `display: 'none'` both
-	*  produced `.uds-none`, and whichever the CSS emitter wrote last silently
-	*  redefined the other's rule, leaving `display="none"` painting
-	*  `text-transform: none` (UDS-2708). */
-	classNameFor(value) {
-		return StyleProp.classNameFor(this, this.canonicalKeyword(value), this.#prefixGetter());
-	}
-	/**
-	* Map a resolved CSS keyword back to the alias that authors it, when the
-	* value isn't directly writable itself. A value that IS a keyword key
-	* (passthrough or alias key) is already canonical and passes through; only
-	* a value reachable solely as some alias's resolved form (`'none'` on a
-	* prop authored `{ alias: 'normal-case', value: 'none' }`) rewrites to that
-	* alias. Non-keyword values (tokens, brackets) pass through untouched.
-	*/
-	canonicalKeyword(value) {
-		if (typeof value !== "string") return value;
-		const keywords = this.derived.keywords;
-		if (keywords.size === 0 || keywords.has(value)) return value;
-		for (const [key, mapped] of keywords) if (typeof key === "string" && mapped === value) return key;
-		return value;
-	}
-	/** The `classPrefix` namespaced with the owning Config's prefix
-	*  (`bg` → `yos-bg`). The wildcard `@utility` emitter needs the
-	*  prefixed stem (`yos-bg-*`) since it has no concrete value to run
-	*  through {@link classNameFor}. Empty when this prop has no class
-	*  prefix (value-as-class props emit no wildcard utility). */
-	get prefixedClassPrefix() {
-		if (this.classPrefix === "") return "";
-		const prefix = this.#prefixGetter();
-		return prefix ? `${prefix}-${this.classPrefix}` : this.classPrefix;
-	}
-	constructor(args) {
-		this.#prefixGetter = args.prefixGetter ?? (() => "uds");
-		this.name = args.name;
-		this.cssProperty = args.definition.cssProperty;
-		this.classPrefix = args.definition.classPrefix;
-		this.values = args.definition.values ?? [];
-		const arbInput = args.definition.arbitrary;
-		if (arbInput === true) this.arbitrary = {};
-		else if (arbInput === false || arbInput === void 0) this.arbitrary = void 0;
-		else if (typeof arbInput === "string") this.arbitrary = { type: arbInput };
-		else this.arbitrary = arbInput;
-		this.negative = args.definition.negative === true;
-		this.cssType = args.definition.cssType;
-		this.metadata = args.definition.metadata ?? {};
-		this.opacityPair = args.definition.opacityPair;
-		this.transform = args.definition.transform;
-		this.#tokenLookup = args.tokenLookup;
-	}
-	get derived() {
-		if (!this.#derived) {
-			const values = this.values;
-			const lookup = this.#tokenLookup;
-			const keywords = /* @__PURE__ */ new Map();
-			for (const entry of values) if (typeof entry === "string") keywords.set(entry, this.transform ? this.transform(entry) : entry);
-			else if (typeof entry === "number") keywords.set(entry, this.transform ? this.transform(entry) : String(entry));
-			else if (typeof entry === "boolean") keywords.set(entry, String(entry));
-			else if (typeof entry === "object" && entry !== null && "alias" in entry && "value" in entry) keywords.set(entry.alias, entry.value);
-			this.#derived = {
-				keywords,
-				get tokens() {
-					const out = [];
-					for (const entry of values) if (isTokenGroupRef(entry)) for (const token of lookup(entry.ref)) out.push(token);
-					return out;
-				}
-			};
-		}
-		return this.#derived;
-	}
-	/**
-	* Token-group namespaces this prop consumes. Used by
-	* `TokenGroup.derived.styleProperties` to answer the reverse question.
-	*/
-	consumedTokenGroups() {
-		const out = [];
-		for (const entry of this.values) if (isTokenGroupRef(entry)) out.push(entry.ref);
-		return out;
-	}
-	/**
-	* The values this prop accepts, split by how each is written at the JSX site:
-	*  - `tokens` — token names from the prop's token groups (`gap="2"`).
-	*  - `keywords` — literal CSS keywords written verbatim (`display="flex"`).
-	*  - `aliases` — short keys resolving to a CSS keyword (`flexDirection="col"`
-	*    → `column`).
-	* A bracketed `[...]` arbitrary literal is governed by `this.arbitrary`, not
-	* enumerated here. Rendered by `uds_get_style_prop` / `uds_list_style_props`;
-	* `accepts()` validates against the same set.
-	*/
-	allowedValues() {
-		const keywords = [];
-		const aliases = [];
-		for (const [key, value] of this.derived.keywords) {
-			const alias = String(key);
-			if (typeof value === "string" && value !== alias) aliases.push({
-				alias,
-				value
-			});
-			else keywords.push(alias);
-		}
-		return {
-			tokens: this.derived.tokens.map((t) => t.name),
-			keywords,
-			aliases
-		};
-	}
-	/**
-	* Whether a JSX-site value is accepted: a token name, a literal keyword, an
-	* alias key, or a bracketed `[...]` literal when the prop enables `arbitrary`
-	* values. The validation primitive behind `uds_validate_props` — a non-token
-	* keyword prop (`display`) and an arbitrary-only prop (`fontSize`) both work,
-	* not just token-group props.
-	*/
-	accepts(value) {
-		if (value.startsWith("[") && value.endsWith("]")) return this.arbitrary !== void 0;
-		for (const key of this.derived.keywords.keys()) if (String(key) === value) return true;
-		for (const token of this.derived.tokens) if (token.name === value) return true;
-		return false;
-	}
-	toJSON() {
-		return {
-			name: this.name,
-			cssProperty: this.cssProperty,
-			classPrefix: this.classPrefix,
-			values: this.values,
-			...compact({
-				arbitrary: this.arbitrary,
-				negative: this.negative || void 0,
-				cssType: this.cssType,
-				metadata: Object.keys(this.metadata).length > 0 ? this.metadata : void 0,
-				opacityPair: this.opacityPair
-			})
-		};
-	}
-};
-//#endregion
-export { StyleProp, isSafeClassNameValue };

package/dist/Token.d.ts

@@ -1,76 +0,0 @@
-import { CssValueTypeName, CssVarRef } from "./types/css-values.js";
-import { SystemLink, TokenDefinition, TokenModifierKey, TokenModifierValue, TokenType, TokenValue } from "./types.js";
-import { CssClassName, CssVar } from "./brands.js";
-
-//#region src/Token.d.ts
-/**
- * Resolved literal value — `token()` refs chased; modifier nesting
- * flattened to the base value.
- */
-type ResolvedTokenLiteral = string | number | boolean | undefined;
-/**
- * Looks up another token by `namespace/name`. Injected by the parent
- * Config so `Token.derived.value` can chase `token()` aliases without
- * holding a back-ref to the whole config object.
- *
- * `context` is the provenance of the token the ref was authored on. A ref
- * inside a linked token is written against the SOURCE system's group names
- * (`token('base/carbon-5')` in a group linked from Yahoo OS means Yahoo OS's
- * `base` group, whatever the consumer renamed it to), so the lookup resolves
- * it through the link markers instead of the consumer's own keys. Local
- * tokens pass no context and resolve against the consumer's keys directly.
- */
-type TokenSiblingLookup = (qualifiedName: string, context?: SystemLink) => Token | undefined;
-/**
- * Fallback for system-scoped refs with NO consumer entry: the var reference
- * into the pinned system's regenerated node sheet (`var(--<nodePrefix>-…)`).
- * The node sheet emits all its tokens, so the reference always resolves on
- * the page — `undefined` only when the system isn't pinned.
- */
-type LinkedVarRefLookup = (system: {
-  id: string;
-  version: string;
-}, qualifiedName: string) => string | undefined;
-declare class Token {
-  #private;
-  readonly name: string;
-  readonly namespace: string;
-  readonly value: TokenValue;
-  readonly type?: TokenType;
-  readonly modifiers?: Record<TokenModifierKey, TokenModifierValue>;
-  /** Provenance when this token is linked from another system; `undefined` for
-   *  local tokens. Round-trips through `toJSON` so a stored config keeps it. */
-  readonly link?: SystemLink;
-  constructor(args: {
-    name: string;
-    namespace: string;
-    prefixGetter: () => string;
-    definition: TokenDefinition;
-    lookup: TokenSiblingLookup;
-    linkedVarRef?: LinkedVarRefLookup;
-    groupTypeGetter: () => TokenType | undefined;
-  });
-  /**
-   * Sniff a raw value to its best-guess CSS value type. Static so
-   * picker UIs (authoring a new token with no `Token` instance yet)
-   * can reach the same heuristic the class uses internally. Returns
-   * `undefined` when no confident match is possible (e.g. `var(...)`
-   * references).
-   */
-  static sniffValueType(value: string): TokenType | undefined;
-  get derived(): {
-    readonly namespace: string;
-    readonly qualifiedName: string;
-    readonly cssSafeName: CssClassName;
-    readonly cssVar: CssVar;
-    readonly cssVarRef: CssVarRef;
-    readonly value: ResolvedTokenLiteral;
-    readonly cssValueType: CssValueTypeName | undefined;
-    modifierValues(): Iterable<[TokenModifierKey, ResolvedTokenLiteral]>;
-  };
-  toJSON(): TokenDefinition & {
-    name: string;
-  };
-}
-//#endregion
-export { LinkedVarRefLookup, ResolvedTokenLiteral, Token, TokenSiblingLookup };

package/dist/Token.js

@@ -1,133 +0,0 @@
-import { buildCssVar, kebabCase, toCssSafeName } from "./entity-utils.js";
-import { isTokenRef } from "./refs.js";
-import { resolveTokenValueType, sniffTokenType } from "./tokenValueType.js";
-//#region src/Token.ts
-var Token = class {
-	name;
-	namespace;
-	value;
-	type;
-	modifiers;
-	/** Provenance when this token is linked from another system; `undefined` for
-	*  local tokens. Round-trips through `toJSON` so a stored config keeps it. */
-	link;
-	#prefixGetter;
-	#lookup;
-	#linkedVarRef;
-	#groupTypeGetter;
-	#derived;
-	constructor(args) {
-		this.name = args.name;
-		this.namespace = args.namespace;
-		this.value = args.definition.value;
-		this.type = args.definition.type;
-		this.modifiers = collectModifiers(args.definition);
-		this.link = args.definition.link;
-		this.#prefixGetter = args.prefixGetter;
-		this.#lookup = args.lookup;
-		this.#linkedVarRef = args.linkedVarRef;
-		this.#groupTypeGetter = args.groupTypeGetter;
-	}
-	/**
-	* Sniff a raw value to its best-guess CSS value type. Static so
-	* picker UIs (authoring a new token with no `Token` instance yet)
-	* can reach the same heuristic the class uses internally. Returns
-	* `undefined` when no confident match is possible (e.g. `var(...)`
-	* references).
-	*/
-	static sniffValueType(value) {
-		return sniffTokenType(value);
-	}
-	get derived() {
-		if (!this.#derived) {
-			const name = this.name;
-			const namespace = this.namespace;
-			const tokenValue = this.value;
-			const tokenType = this.type;
-			const modifiers = this.modifiers;
-			const link = this.link;
-			const prefixGetter = this.#prefixGetter;
-			const lookup = this.#lookup;
-			const linkedVarRef = this.#linkedVarRef;
-			const groupTypeGetter = this.#groupTypeGetter;
-			this.#derived = {
-				namespace,
-				qualifiedName: `${kebabCase(namespace)}/${kebabCase(name)}`,
-				cssSafeName: toCssSafeName(name),
-				get cssVar() {
-					return buildCssVar(prefixGetter(), namespace, name);
-				},
-				get cssVarRef() {
-					return `var(${buildCssVar(prefixGetter(), namespace, name)})`;
-				},
-				get value() {
-					return chaseLiteral(tokenValue, lookup, link, void 0, linkedVarRef);
-				},
-				get cssValueType() {
-					const literal = chaseLiteral(tokenValue, lookup, link, void 0, linkedVarRef);
-					return resolveTokenValueType({
-						value: typeof literal === "string" ? literal : String(tokenValue),
-						type: tokenType
-					}, groupTypeGetter());
-				},
-				*modifierValues() {
-					if (!modifiers) return;
-					for (const [key, value] of Object.entries(modifiers)) yield [key, resolveModifierLiteral(value, lookup, link, linkedVarRef)];
-				}
-			};
-		}
-		return this.#derived;
-	}
-	toJSON() {
-		const out = {
-			name: this.name,
-			value: this.value
-		};
-		if (this.type !== void 0) out.type = this.type;
-		if (this.link !== void 0) out.link = this.link;
-		if (this.modifiers) for (const [key, value] of Object.entries(this.modifiers)) out[key] = value;
-		return out;
-	}
-};
-/**
-* Scan a `TokenDefinition` for flat `_${string}` modifier keys and pack
-* them into a single `modifiers` map. Returns `undefined` when no
-* modifier keys are present so the class field can stay optional.
-*/
-function collectModifiers(definition) {
-	const modifiers = {};
-	let count = 0;
-	for (const [key, value] of Object.entries(definition)) if (key.startsWith("_")) {
-		modifiers[key] = value;
-		count++;
-	}
-	return count > 0 ? modifiers : void 0;
-}
-function chaseLiteral(value, lookup, context, seen = /* @__PURE__ */ new Set(), linkedVarRef) {
-	if (isTokenRef(value)) {
-		let refContext = context;
-		if (value.scope === "consumer") refContext = void 0;
-		else if (value.system) refContext = {
-			kind: "token",
-			systemId: value.system.id,
-			systemVersion: value.system.version,
-			sourceKey: value.ref
-		};
-		const seenKey = `${refContext?.systemId ?? ""}:${value.ref}`;
-		if (seen.has(seenKey)) return void 0;
-		seen.add(seenKey);
-		const next = lookup(value.ref, refContext);
-		if (!next) {
-			if (value.system && linkedVarRef) return linkedVarRef(value.system, value.ref);
-			return;
-		}
-		return chaseLiteral(next.value, lookup, next.link, seen, linkedVarRef);
-	}
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-}
-function resolveModifierLiteral(value, lookup, context, linkedVarRef) {
-	if (typeof value === "object" && value !== null && "value" in value) return chaseLiteral(value.value, lookup, context, void 0, linkedVarRef);
-	return chaseLiteral(value, lookup, context, void 0, linkedVarRef);
-}
-//#endregion
-export { Token };

package/dist/TokenGroup.d.ts

@@ -1,33 +0,0 @@
-import { SerializedTokenGroup, TokenGroupDefinition } from "./types.js";
-import { LinkedVarRefLookup, Token, TokenSiblingLookup } from "./Token.js";
-
-//#region src/TokenGroup.d.ts
-type StylePropertiesLookup = (namespace: string) => readonly string[];
-declare class TokenGroup {
-  #private;
-  readonly namespace: string;
-  readonly label?: string;
-  readonly description?: string;
-  readonly tokens: ReadonlyMap<string, Token>;
-  constructor(args: {
-    namespace: string;
-    prefixGetter: () => string;
-    definition: TokenGroupDefinition;
-    tokenLookup: TokenSiblingLookup;
-    linkedVarRef?: LinkedVarRefLookup;
-    stylePropertiesLookup: StylePropertiesLookup;
-  });
-  get derived(): {
-    readonly cssPrefix: string;
-    readonly styleProperties: readonly string[];
-  };
-  /**
-   * Wire shape: `{ tokens, label?, description? }`. Token entries live
-   * nested under `tokens` so meta keys can never collide with token
-   * names — a token named `'label'` is fine. The parent record's key
-   * carries the namespace, so it's omitted here.
-   */
-  toJSON(): SerializedTokenGroup;
-}
-//#endregion
-export { TokenGroup };

package/dist/TokenGroup.js

@@ -1,69 +0,0 @@
-import { kebabCase } from "./entity-utils.js";
-import { Token } from "./Token.js";
-//#region src/TokenGroup.ts
-/**
-* `TokenGroup` — a namespace of tokens (`color`, `spacing`).
-*
-* Owns its tokens and exposes `.derived.styleProperties` — the
-* style-prop names whose `values` array references this group. The
-* `styleProperties` computation needs sibling style-props, supplied by
-* the parent `Config` via the `styleProperties` callable.
-*/
-var TokenGroup = class {
-	namespace;
-	label;
-	description;
-	tokens;
-	#stylePropertiesLookup;
-	#derived;
-	constructor(args) {
-		this.namespace = args.namespace;
-		const groupTypeGetter = () => void 0;
-		if (args.definition.label !== void 0) this.label = args.definition.label;
-		if (args.definition.description !== void 0) this.description = args.definition.description;
-		const tokens = /* @__PURE__ */ new Map();
-		for (const [name, tokenDef] of Object.entries(args.definition.tokens)) tokens.set(name, new Token({
-			name,
-			namespace: args.namespace,
-			prefixGetter: args.prefixGetter,
-			definition: tokenDef,
-			lookup: args.tokenLookup,
-			linkedVarRef: args.linkedVarRef,
-			groupTypeGetter
-		}));
-		this.tokens = tokens;
-		this.#stylePropertiesLookup = args.stylePropertiesLookup;
-	}
-	get derived() {
-		if (!this.#derived) {
-			const namespace = this.namespace;
-			const lookup = this.#stylePropertiesLookup;
-			this.#derived = {
-				cssPrefix: kebabCase(namespace),
-				get styleProperties() {
-					return lookup(namespace);
-				}
-			};
-		}
-		return this.#derived;
-	}
-	/**
-	* Wire shape: `{ tokens, label?, description? }`. Token entries live
-	* nested under `tokens` so meta keys can never collide with token
-	* names — a token named `'label'` is fine. The parent record's key
-	* carries the namespace, so it's omitted here.
-	*/
-	toJSON() {
-		const tokens = {};
-		for (const [name, token] of this.tokens) {
-			const { name: _omit, ...rest } = token.toJSON();
-			tokens[name] = rest;
-		}
-		const out = { tokens };
-		if (this.label !== void 0) out.label = this.label;
-		if (this.description !== void 0) out.description = this.description;
-		return out;
-	}
-};
-//#endregion
-export { TokenGroup };

package/dist/asset-kind.d.ts

@@ -1,55 +0,0 @@
-//#region src/asset-kind.d.ts
-/**
- * `assetKind` — what class of asset a group holds (icons, fonts, …).
- *
- * Every asset group picks one of these labels when it's defined (via
- * `.config({ type })`), and we store it on the group as `assetKind`.
- *
- * Why `assetKind` and not just `kind`? Asset groups already carry a
- * separate tag, `__kind: 'assetGroup'`, that marks them as asset-group
- * refs. That tag is the same for every group regardless of class, and
- * the check that relies on it (`isAssetGroupRef()`) must stay that way.
- * If we also called this field `kind`, the two would collide and blur
- * the distinction between "is this an asset group?" and "what kind of
- * asset is in it?". So this field gets its own name: `__kind` answers
- * the first question, `assetKind` answers the second.
- *
- * Behavior differences between classes live in one table below and are
- * read through small helpers like `isPlaceable()`. That keeps callers
- * from branching on the class directly (no "is this a font?" checks
- * scattered around), and adding a new class means adding one row here
- * plus its member contract — not new branches everywhere.
- */
-type AssetKind = 'icon' | 'font';
-/**
- * Per-class capability record. `placeable` — whether members of this
- * class become canvas nodes (icons do; fonts are consumed via
- * `font-family` token refs and never placed). Both hard guards read
- * this through `isPlaceable()`: the `makeRegistry` asset loop and the
- * `.accepts()` config-load throw.
- *
- * Classes we expect to add later (each is one new row here plus its
- * member contract — and likely `placeable: true`):
- * - images — bitmap assets (PNG/JPEG/WebP) dropped onto the canvas
- * - illustrations — vector artwork (SVG) placed as canvas nodes
- * - logos — brand marks, a constrained flavor of image/vector asset
- * - videos — playable media placed as canvas nodes
- */
-declare const ASSET_CLASS_CAPABILITIES: {
-  readonly icon: {
-    readonly placeable: true;
-  };
-  readonly font: {
-    readonly placeable: false;
-  };
-};
-/**
- * Whether a group's members can fill slots and become canvas nodes.
- * Accepts anything carrying the stamped `assetKind` — both the
- * authored `AssetGroupDefinition` and the registered `AssetGroup`.
- */
-declare function isPlaceable(group: {
-  readonly assetKind: AssetKind;
-}): boolean;
-//#endregion
-export { ASSET_CLASS_CAPABILITIES, AssetKind, isPlaceable };

package/dist/asset-kind.js

@@ -1,29 +0,0 @@
-//#region src/asset-kind.ts
-/**
-* Per-class capability record. `placeable` — whether members of this
-* class become canvas nodes (icons do; fonts are consumed via
-* `font-family` token refs and never placed). Both hard guards read
-* this through `isPlaceable()`: the `makeRegistry` asset loop and the
-* `.accepts()` config-load throw.
-*
-* Classes we expect to add later (each is one new row here plus its
-* member contract — and likely `placeable: true`):
-* - images — bitmap assets (PNG/JPEG/WebP) dropped onto the canvas
-* - illustrations — vector artwork (SVG) placed as canvas nodes
-* - logos — brand marks, a constrained flavor of image/vector asset
-* - videos — playable media placed as canvas nodes
-*/
-const ASSET_CLASS_CAPABILITIES = {
-	icon: { placeable: true },
-	font: { placeable: false }
-};
-/**
-* Whether a group's members can fill slots and become canvas nodes.
-* Accepts anything carrying the stamped `assetKind` — both the
-* authored `AssetGroupDefinition` and the registered `AssetGroup`.
-*/
-function isPlaceable(group) {
-	return ASSET_CLASS_CAPABILITIES[group.assetKind].placeable;
-}
-//#endregion
-export { ASSET_CLASS_CAPABILITIES, isPlaceable };

package/dist/asset-value.d.ts

@@ -1,23 +0,0 @@
-import { FontAssetMember } from "./types.js";
-import { AssetGroup } from "./AssetGroup.js";
-
-//#region src/asset-value.d.ts
-/**
- * Assemble a `font-family` CSS value from a font member — the primary
- * family (always double-quoted, so multi-word names are valid) followed by
- * its fallback stack. `fallback` rides `FontAssetMember`'s open index as
- * `unknown`, so read it defensively: a `string` is appended verbatim (it
- * may itself be a comma list), a `string[]` is joined, anything else is
- * ignored. Fallback entries are emitted verbatim — they're generic keywords
- * (`sans-serif`) or already-formatted names.
- */
-declare function resolveFontStack(member: FontAssetMember): string;
-/**
- * Resolve a `<slug>/<member>` asset ref to its `font-family` CSS stack.
- * Every failure is a named throw (no silent string fallthrough): a
- * malformed ref, an unregistered group, a non-font group, or a missing
- * member each name the offending ref so config load fails loudly.
- */
-declare function resolveAssetRefCss(ref: string, assetGroups: ReadonlyMap<string, AssetGroup>): string;
-//#endregion
-export { resolveAssetRefCss, resolveFontStack };