@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/jsx/jsx-dev-runtime.d.ts

@@ -1,15 +0,0 @@
-import { Fragment, jsx } from "./jsx-runtime.js";
-import { Spec } from "@json-render/core";
-
-//#region src/jsx/jsx-dev-runtime.d.ts
-interface JsxDevProps {
-  readonly children?: unknown;
-  readonly [key: string]: unknown;
-}
-/**
- * Dev-variant of `jsx`. Accepts the React-style dev arguments but ignores
- * them — spec output is identical to the production runtime.
- */
-declare function jsxDEV(type: Parameters<typeof jsx>[0], props: JsxDevProps, _key?: unknown, _isStaticChildren?: boolean, _source?: unknown, _self?: unknown): Spec;
-//#endregion
-export { Fragment, jsxDEV };

package/dist/jsx/jsx-dev-runtime.js

@@ -1,11 +0,0 @@
-import { Fragment, jsx } from "./jsx-runtime.js";
-//#region src/jsx/jsx-dev-runtime.ts
-/**
-* Dev-variant of `jsx`. Accepts the React-style dev arguments but ignores
-* them — spec output is identical to the production runtime.
-*/
-function jsxDEV(type, props, _key, _isStaticChildren, _source, _self) {
-	return jsx(type, props);
-}
-//#endregion
-export { Fragment, jsxDEV };

package/dist/jsx/jsx-runtime.d.ts

@@ -1,48 +0,0 @@
-import { Spec } from "@json-render/core";
-
-//#region src/jsx/jsx-runtime.d.ts
-declare const Fragment: unique symbol;
-declare function setConfigContext(config: unknown): void;
-declare function getConfigContext(): unknown;
-type JsxType = string | symbol | {
-  readonly __componentName?: string;
-  readonly displayName?: string;
-  readonly name?: string;
-};
-interface JsxProps {
-  readonly children?: unknown;
-  readonly [key: string]: unknown;
-}
-/**
- * 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.
- */
-declare function setRenderExtractionContext(componentName: string | null): void;
-/**
- * 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.
- */
-declare function __resetKeyCounterForTesting(): void;
-/**
- * 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.
- */
-declare function __drainPendingRefs(): Map<string, unknown>;
-/**
- * JSX automatic-runtime entry for a single static child. Compilers pick
- * this signature when the JSX expression has zero or one child.
- */
-declare function jsx(type: JsxType, props: JsxProps): Spec;
-/**
- * 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.
- */
-declare function jsxs(type: JsxType, props: JsxProps): Spec;
-//#endregion
-export { Fragment, __drainPendingRefs, __resetKeyCounterForTesting, getConfigContext, jsx, jsxs, setConfigContext, setRenderExtractionContext };

package/dist/jsx/jsx-runtime.js

@@ -1,305 +0,0 @@
-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?.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/linked-system-pins.d.ts

@@ -1,30 +0,0 @@
-/**
- * Linked-system pin gates shared by the web `Config` and `NativeConfig`.
- * Both platforms pin source systems identically (`registerLinkedSystems`),
- * and both validate link-marked tokens against those pins at registration —
- * one implementation keeps the error contract byte-identical across
- * platforms.
- */
-import type { LinkedSystemPin, SystemLink } from './types';
-/** Canonical 8-4-4-4-12 hex UUID, case-insensitive. */
-export declare const UUID_RE: RegExp;
-/** Exact `major.minor.patch` with optional prerelease/build — no ranges. */
-export declare const EXACT_SEMVER_RE: RegExp;
-/**
- * Validate one `registerLinkedSystems` entry against the pins already
- * registered. `owner` names the throwing class in the error label.
- */
-export declare function validateLinkedSystemPin(systemId: string, pin: LinkedSystemPin, existing: ReadonlyMap<string, LinkedSystemPin>, owner?: string): void;
-/**
- * Pin-consistency gate for a link-marked value entering a registry.
- * Catches hand-forged markers (unpinned system), stale registry barrels
- * (version mismatch), and mis-kinded markers before they poison lookups.
- * `label` names the offending entry in the error (`Config.registerTokenGroups:
- * token "color/brand"`).
- */
-export declare function assertLinkedValuePinned(expectedKind: SystemLink['kind'], label: string, link: SystemLink | undefined, pins: ReadonlyMap<string, LinkedSystemPin>): void;
-/**
- * Token-kind gate — the historical entry point; delegates to
- * {@link assertLinkedValuePinned} with the token error contract.
- */
-export declare function assertLinkedTokenPinned(groupName: string, tokenName: string, link: SystemLink | undefined, pins: ReadonlyMap<string, LinkedSystemPin>, owner?: string): void;

package/dist/linked-system-pins.js

@@ -1,45 +0,0 @@
-//#region src/linked-system-pins.ts
-/** Canonical 8-4-4-4-12 hex UUID, case-insensitive. */
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Exact `major.minor.patch` with optional prerelease/build — no ranges. */
-const EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-/**
-* Validate one `registerLinkedSystems` entry against the pins already
-* registered. `owner` names the throwing class in the error label.
-*/
-function validateLinkedSystemPin(systemId, pin, existing, owner = "Config") {
-	const label = `${owner}.registerLinkedSystems: system id "${systemId}"`;
-	if (!UUID_RE.test(systemId)) throw new Error(`${label} must be a UUID — pins are keyed by the source system's database id, not its slug or name.`);
-	if (existing.has(systemId)) {
-		const prior = existing.get(systemId);
-		throw new Error(`${label} is already pinned ("${prior?.name}" @ ${prior?.version}) — a config pins one version per system; update the existing pin instead of re-pinning.`);
-	}
-	if (pin.name.trim().length === 0) throw new Error(`${label}: name must be non-empty — it's the system's display-name snapshot at link time and feeds the registry folder slug.`);
-	if (!EXACT_SEMVER_RE.test(pin.version)) throw new Error(`${label}: version "${pin.version}" must be an exact semver literal (e.g. "1.3.1") — ranges and tags are not supported.`);
-}
-/**
-* Pin-consistency gate for a link-marked value entering a registry.
-* Catches hand-forged markers (unpinned system), stale registry barrels
-* (version mismatch), and mis-kinded markers before they poison lookups.
-* `label` names the offending entry in the error (`Config.registerTokenGroups:
-* token "color/brand"`).
-*/
-function assertLinkedValuePinned(expectedKind, label, link, pins) {
-	if (!link) return;
-	if (link.kind !== expectedKind) {
-		const spread = expectedKind === "token" ? " (a token-group link spreads to per-token markers)" : "";
-		throw new Error(`${label} carries a "${link.kind}" link marker — this entry can only carry kind "${expectedKind}"${spread}.`);
-	}
-	const pin = pins.get(link.systemId);
-	if (!pin) throw new Error(`${label} is linked from system "${link.systemId}", which has no registerLinkedSystems pin — pin the system (name + exact version) before registering values linked from it.`);
-	if (pin.version !== link.systemVersion) throw new Error(`${label} is linked at version "${link.systemVersion}" but system "${pin.name}" is pinned at "${pin.version}" — the registry barrel is stale; re-run \`uds pull\`.`);
-}
-/**
-* Token-kind gate — the historical entry point; delegates to
-* {@link assertLinkedValuePinned} with the token error contract.
-*/
-function assertLinkedTokenPinned(groupName, tokenName, link, pins, owner = "Config") {
-	assertLinkedValuePinned("token", `${owner}.registerTokenGroups: token "${groupName}/${tokenName}"`, link, pins);
-}
-//#endregion
-export { EXACT_SEMVER_RE, UUID_RE, assertLinkedTokenPinned, assertLinkedValuePinned, validateLinkedSystemPin };

package/dist/linkedNodePrefixes.d.ts

@@ -1,73 +0,0 @@
-//#region src/linkedNodePrefixes.d.ts
-/**
- * Node-scoped CSS-prefix assignment for materialized linked systems.
- *
- * Every linked node (`{systemId}@{version}`) regenerates its CSS at consumer
- * build time from its sealed `config.json`, with its `prefix` overridden to a
- * composed, collision-free identity: `<consumerPrefix>-linked-<slug>`. One
- * prefix per NODE (not per link path) — the module graph resolves each node's
- * files once, so its lowered class names can only carry one prefix; sharing a
- * node between parents shares byte-identical sealed content, so sharing the
- * prefix is correct.
- *
- * The assignment must be identical everywhere it's consumed (pull-time shim
- * generation, `uds build` CSS regeneration, the bundler loaders), so every
- * consumer derives it from the same inputs with the same pure functions:
- * node identities from the registry tree, display names from the declaring
- * configs' `registerLinkedSystems` entries ({@link resolveDeclaredNames}),
- * and the consumer's own prefix. Nothing is persisted — the registry tree is
- * the source of truth.
- */
-/** Identity of one linked node, as pulled from the server closure. */
-interface LinkedNodeIdentity {
-  systemId: string;
-  version: string;
-  /** Display-name snapshot captured at link time (from the consumer's
-   *  `registerLinkedSystems` entry / the server's system record). */
-  name: string;
-}
-/** Assigned naming for one node. */
-interface LinkedNodePrefix {
-  /** Filesystem/import-safe slug of the node's display name. */
-  slug: string;
-  /** The node's composed CSS identity — every var and class name of its
-   *  regenerated CSS derives from this. */
-  cssPrefix: string;
-}
-/**
- * Assign each node in a linked closure its slug + composed CSS prefix,
- * keyed by `{systemId}@{version}`.
- *
- * Deterministic and input-order independent: nodes are processed sorted by
- * `(systemId, version)`. Within a slug-collision group the first sorted node
- * keeps the bare slug; a different system appends `-x<systemId[0..8]>`; the
- * same system at another version appends `-v<version>` — so every node in
- * the closure gets a unique, stable prefix.
- *
- * `consumerPrefix` is the consuming system's own `Config.prefix`. An empty
- * prefix is disallowed as a base (a bare `linked-…` could collide with the
- * consumer's unprefixed classes) — the node's own uuid fragment substitutes.
- */
-declare function assignLinkedNodePrefixes(nodes: LinkedNodeIdentity[], consumerPrefix: string): Map<string, LinkedNodePrefix>;
-/** One `registerLinkedSystems` declaration observed while walking a
- *  closure: `declarerKey` is the declaring node's `{systemId}@{version}` pair
- *  (empty string for the consumer's own config). */
-interface LinkedNameDeclaration {
-  /** The declared child's `{systemId}@{version}` pair key. */
-  key: string;
-  /** The declarer's display-name snapshot for the child. */
-  name: string;
-  /** The declaring node's pair key; `''` = the consumer root config. */
-  declarerKey: string;
-}
-/**
- * Resolve each node's display name from the closure's declarations. A node
- * can be declared by several parents under different name snapshots; the
- * winner is the declaration with the lowest `declarerKey` in sort order (the
- * consumer's own declarations sort first as `''`), so every tool that walks
- * the same closure derives the same names — and therefore the same slugs and
- * CSS prefixes — without any persisted mapping.
- */
-declare function resolveDeclaredNames(declarations: LinkedNameDeclaration[]): Map<string, string>;
-//#endregion
-export { LinkedNameDeclaration, LinkedNodeIdentity, LinkedNodePrefix, assignLinkedNodePrefixes, resolveDeclaredNames };

package/dist/linkedNodePrefixes.js

@@ -1,99 +0,0 @@
-import { slugifyLinkedName } from "./registry-aliases.js";
-//#region src/linkedNodePrefixes.ts
-/**
-* Node-scoped CSS-prefix assignment for materialized linked systems.
-*
-* Every linked node (`{systemId}@{version}`) regenerates its CSS at consumer
-* build time from its sealed `config.json`, with its `prefix` overridden to a
-* composed, collision-free identity: `<consumerPrefix>-linked-<slug>`. One
-* prefix per NODE (not per link path) — the module graph resolves each node's
-* files once, so its lowered class names can only carry one prefix; sharing a
-* node between parents shares byte-identical sealed content, so sharing the
-* prefix is correct.
-*
-* The assignment must be identical everywhere it's consumed (pull-time shim
-* generation, `uds build` CSS regeneration, the bundler loaders), so every
-* consumer derives it from the same inputs with the same pure functions:
-* node identities from the registry tree, display names from the declaring
-* configs' `registerLinkedSystems` entries ({@link resolveDeclaredNames}),
-* and the consumer's own prefix. Nothing is persisted — the registry tree is
-* the source of truth.
-*/
-/** CSS identifiers can't start with a digit (or a hyphen-digit pair) —
-*  prepend a letter sentinel when a candidate would. */
-function ensureCssIdentStart(candidate) {
-	return /^[a-zA-Z_]/.test(candidate) ? candidate : `x${candidate}`;
-}
-/** `1.5.0` → `v1-5-0` — a CSS-safe version fragment. */
-function versionFragment(version) {
-	return `v${version.replace(/[^a-zA-Z0-9]+/g, "-")}`;
-}
-function nodeKey(node) {
-	return `${node.systemId}@${node.version}`;
-}
-/**
-* Assign each node in a linked closure its slug + composed CSS prefix,
-* keyed by `{systemId}@{version}`.
-*
-* Deterministic and input-order independent: nodes are processed sorted by
-* `(systemId, version)`. Within a slug-collision group the first sorted node
-* keeps the bare slug; a different system appends `-x<systemId[0..8]>`; the
-* same system at another version appends `-v<version>` — so every node in
-* the closure gets a unique, stable prefix.
-*
-* `consumerPrefix` is the consuming system's own `Config.prefix`. An empty
-* prefix is disallowed as a base (a bare `linked-…` could collide with the
-* consumer's unprefixed classes) — the node's own uuid fragment substitutes.
-*/
-function assignLinkedNodePrefixes(nodes, consumerPrefix) {
-	const sorted = [...nodes].sort((a, b) => a.systemId.localeCompare(b.systemId) || a.version.localeCompare(b.version));
-	const byslug = /* @__PURE__ */ new Map();
-	for (const node of sorted) {
-		const slug = slugifyLinkedName(node.name);
-		const group = byslug.get(slug);
-		if (group) group.push(node);
-		else byslug.set(slug, [node]);
-	}
-	const out = /* @__PURE__ */ new Map();
-	const usedSlugs = /* @__PURE__ */ new Set();
-	for (const [slug, group] of byslug) {
-		const systemsInOrder = [];
-		for (const node of group) if (!systemsInOrder.includes(node.systemId)) systemsInOrder.push(node.systemId);
-		for (const node of group) {
-			const systemRank = systemsInOrder.indexOf(node.systemId);
-			const versionsOfSystem = group.filter((n) => n.systemId === node.systemId);
-			let finalSlug = slug;
-			if (systemRank > 0) finalSlug += `-x${node.systemId.slice(0, 8)}`;
-			if (versionsOfSystem.length > 1 && versionsOfSystem.indexOf(node) > 0) finalSlug += `-${versionFragment(node.version)}`;
-			const collisionBase = finalSlug;
-			let collisionIndex = 2;
-			while (usedSlugs.has(finalSlug)) {
-				finalSlug = `${collisionBase}-${collisionIndex}`;
-				collisionIndex++;
-			}
-			usedSlugs.add(finalSlug);
-			const base = ensureCssIdentStart(consumerPrefix === "" ? `x${node.systemId.slice(0, 8)}` : consumerPrefix);
-			out.set(nodeKey(node), {
-				slug: finalSlug,
-				cssPrefix: `${base}-linked-${finalSlug}`
-			});
-		}
-	}
-	return out;
-}
-/**
-* Resolve each node's display name from the closure's declarations. A node
-* can be declared by several parents under different name snapshots; the
-* winner is the declaration with the lowest `declarerKey` in sort order (the
-* consumer's own declarations sort first as `''`), so every tool that walks
-* the same closure derives the same names — and therefore the same slugs and
-* CSS prefixes — without any persisted mapping.
-*/
-function resolveDeclaredNames(declarations) {
-	const sorted = [...declarations].sort((a, b) => a.key.localeCompare(b.key) || a.declarerKey.localeCompare(b.declarerKey));
-	const names = /* @__PURE__ */ new Map();
-	for (const decl of sorted) if (!names.has(decl.key)) names.set(decl.key, decl.name);
-	return names;
-}
-//#endregion
-export { assignLinkedNodePrefixes, resolveDeclaredNames };