@dsai-io/tools 1.0.7 → 1.1.0

package/dist/index.cjs

@@ -1002,20 +1002,6 @@ var init_line_height = __esm({
   }
 });
 
-// src/tokens/style-dictionary/transforms/name.ts
-exports.nameKebab = void 0;
-var init_name = __esm({
-  "src/tokens/style-dictionary/transforms/name.ts"() {
-    exports.nameKebab = {
-      name: "name/kebab",
-      type: "name",
-      transform: (token) => {
-        return token.path.join("-").replace(/_/g, "-").toLowerCase();
-      }
-    };
-  }
-});
-
 // src/tokens/style-dictionary/transforms/name-js-identifier.ts
 function toPascalCaseSegment3(segment) {
   const needsNumericPrefix = /^\d/.test(segment);
@@ -1035,6 +1021,20 @@ var init_name_js_identifier = __esm({
   }
 });
 
+// src/tokens/style-dictionary/transforms/name.ts
+exports.nameKebab = void 0;
+var init_name = __esm({
+  "src/tokens/style-dictionary/transforms/name.ts"() {
+    exports.nameKebab = {
+      name: "name/kebab",
+      type: "name",
+      transform: (token) => {
+        return token.path.join("-").replace(/_/g, "-").toLowerCase();
+      }
+    };
+  }
+});
+
 // src/tokens/style-dictionary/transforms/index.ts
 var transforms_exports = {};
 __export(transforms_exports, {
@@ -1063,8 +1063,8 @@ var init_transforms = __esm({
     init_dimension();
     init_font_weight();
     init_line_height();
-    init_name();
     init_name_js_identifier();
+    init_name();
     init_font_weight();
     init_line_height();
     init_dimension();
@@ -1760,13 +1760,29 @@ var globalConfigSchema = zod.z.object({
   framework: frameworkSchema.optional(),
   build: buildConfigSchema.optional()
 });
+var aliasesConfigSchema = zod.z.object({
+  importAlias: zod.z.string().optional().default("@/"),
+  ui: zod.z.string().optional().default("src/components/ui"),
+  hooks: zod.z.string().optional().default("src/hooks"),
+  utils: zod.z.string().optional().default("src/lib/utils"),
+  components: zod.z.string().optional().default("src/components"),
+  lib: zod.z.string().optional().default("src/lib")
+});
+var componentsConfigSchema = zod.z.object({
+  enabled: zod.z.boolean().optional().default(true),
+  registryUrl: zod.z.string().optional().default("https://registry.dsai.dev"),
+  tsx: zod.z.boolean().optional().default(true),
+  overwrite: zod.z.boolean().optional().default(false)
+});
 var dsaiConfigSchema = zod.z.object({
   $schema: zod.z.string().optional(),
   extends: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
   global: globalConfigSchema.optional(),
   tokens: tokensConfigSchema.optional(),
   themes: themesConfigSchema.optional(),
-  icons: iconsConfigSchema.optional()
+  icons: iconsConfigSchema.optional(),
+  aliases: aliasesConfigSchema.optional(),
+  components: componentsConfigSchema.optional()
 });
 function formatValidationErrors(zodError) {
   return zodError.issues.map((err) => ({
@@ -1804,7 +1820,9 @@ function validateConfigSection(section, config) {
     global: globalConfigSchema,
     tokens: tokensConfigSchema,
     themes: themesConfigSchema,
-    icons: iconsConfigSchema
+    icons: iconsConfigSchema,
+    aliases: aliasesConfigSchema,
+    components: componentsConfigSchema
   };
   const schema = sectionSchemas[section];
   if (!schema) {
@@ -1916,6 +1934,20 @@ var defaultIconsConfig = {
   optimize: true,
   prefix: "Icon"
 };
+var defaultAliasesConfig = {
+  importAlias: "@/",
+  ui: "src/components/ui",
+  hooks: "src/hooks",
+  utils: "src/lib/utils",
+  components: "src/components",
+  lib: "src/lib"
+};
+var defaultComponentsConfig = {
+  enabled: true,
+  registryUrl: "https://registry.dsai.dev",
+  tsx: true,
+  overwrite: false
+};
 var defaultTokensConfig = {
   source: "theme",
   sourceDir: DEFAULT_SOURCE_DIR,
@@ -1950,6 +1982,8 @@ var defaultGlobalConfig = {
 var defaultConfig = {
   tokens: defaultTokensConfig,
   icons: defaultIconsConfig,
+  aliases: defaultAliasesConfig,
+  components: defaultComponentsConfig,
   global: defaultGlobalConfig,
   configDir: process.cwd()
 };
@@ -2213,10 +2247,32 @@ function resolveTokensConfig(config, options) {
     postprocess: config?.postprocess
   };
 }
+function resolveAliasesConfig(config) {
+  const base = defaultAliasesConfig;
+  return {
+    importAlias: config?.importAlias ?? base.importAlias,
+    ui: config?.ui ?? base.ui,
+    hooks: config?.hooks ?? base.hooks,
+    utils: config?.utils ?? base.utils,
+    components: config?.components ?? base.components,
+    lib: config?.lib ?? base.lib
+  };
+}
+function resolveComponentsConfig(config) {
+  const base = defaultComponentsConfig;
+  return {
+    enabled: config?.enabled ?? base.enabled,
+    registryUrl: config?.registryUrl ?? base.registryUrl,
+    tsx: config?.tsx ?? base.tsx,
+    overwrite: config?.overwrite ?? base.overwrite
+  };
+}
 function applyOverrides(config, overrides) {
   return {
     tokens: overrides.tokens ? { ...config.tokens, ...overrides.tokens } : config.tokens,
     icons: overrides.icons ? { ...config.icons, ...overrides.icons } : config.icons,
+    aliases: overrides.aliases ? { ...config.aliases, ...overrides.aliases } : config.aliases,
+    components: overrides.components ? { ...config.components, ...overrides.components } : config.components,
     global: overrides.global ? { ...config.global, ...overrides.global } : config.global
   };
 }
@@ -2227,6 +2283,8 @@ function resolveConfig(config = {}, options = {}) {
     global: resolveGlobalConfig(mergedConfig.global, options),
     tokens: resolveTokensConfig(mergedConfig.tokens, options),
     icons: resolveIconsConfig(mergedConfig.icons, options),
+    aliases: resolveAliasesConfig(mergedConfig.aliases),
+    components: resolveComponentsConfig(mergedConfig.components),
     configDir
   };
 }
@@ -2242,6 +2300,8 @@ function createResolvedConfig(partial = {}) {
     global: partial.global ?? defaultConfig.global,
     tokens: partial.tokens ?? defaultConfig.tokens,
     icons: partial.icons ?? defaultConfig.icons,
+    aliases: partial.aliases ?? defaultConfig.aliases,
+    components: partial.components ?? defaultConfig.components,
     configDir: partial.configDir ?? process.cwd(),
     configPath: partial.configPath
   };
@@ -9098,6 +9158,1156 @@ async function buildIcons(config, options = {}) {
   result.duration = Date.now() - startTime;
   return result;
 }
+var registryItemTypeSchema = zod.z.enum([
+  "registry:ui",
+  "registry:hook",
+  "registry:util",
+  "registry:lib",
+  "registry:component",
+  "registry:style",
+  "registry:type"
+]);
+var registryFileSchema = zod.z.object({
+  path: zod.z.string().min(1, "File path is required"),
+  type: registryItemTypeSchema,
+  content: zod.z.string(),
+  target: zod.z.string().optional()
+});
+var registryItemSchema = zod.z.object({
+  name: zod.z.string().min(1, "Registry item name is required"),
+  type: registryItemTypeSchema,
+  title: zod.z.string().min(1, "Title is required"),
+  description: zod.z.string().default(""),
+  dependencies: zod.z.array(zod.z.string()).default([]),
+  devDependencies: zod.z.array(zod.z.string()).default([]),
+  registryDependencies: zod.z.array(zod.z.string()).default([]),
+  files: zod.z.array(registryFileSchema).min(1, "At least one file is required"),
+  cssVars: zod.z.object({
+    light: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+    dark: zod.z.record(zod.z.string(), zod.z.string()).optional()
+  }).optional(),
+  categories: zod.z.array(zod.z.string()).optional()
+});
+var registryIndexEntrySchema = zod.z.object({
+  name: zod.z.string(),
+  type: registryItemTypeSchema,
+  title: zod.z.string(),
+  description: zod.z.string(),
+  dependencies: zod.z.array(zod.z.string()),
+  registryDependencies: zod.z.array(zod.z.string()),
+  categories: zod.z.array(zod.z.string()).optional()
+});
+var registryIndexSchema = zod.z.object({
+  version: zod.z.string(),
+  count: zod.z.number(),
+  items: zod.z.array(registryIndexEntrySchema)
+});
+
+// src/registry/component-map.ts
+var componentMap = {
+  accordion: {
+    type: "registry:ui",
+    title: "Accordion",
+    description: "Collapsible content panels for presenting information in a limited space.",
+    categories: ["disclosure", "layout"]
+  },
+  alert: {
+    type: "registry:ui",
+    title: "Alert",
+    description: "Contextual feedback messages for user actions.",
+    categories: ["feedback"]
+  },
+  avatar: {
+    type: "registry:ui",
+    title: "Avatar",
+    description: "Graphical representation of a user or entity.",
+    categories: ["data-display"]
+  },
+  badge: {
+    type: "registry:ui",
+    title: "Badge",
+    description: "Small count or status indicator, typically displayed on other elements.",
+    categories: ["data-display"]
+  },
+  breadcrumb: {
+    type: "registry:ui",
+    title: "Breadcrumb",
+    description: "Navigation aid showing the current page location within a hierarchy.",
+    categories: ["navigation"]
+  },
+  button: {
+    type: "registry:ui",
+    title: "Button",
+    description: "Trigger for actions and events.",
+    categories: ["actions"]
+  },
+  card: {
+    type: "registry:ui",
+    title: "Card",
+    description: "Flexible container for grouping related content and actions.",
+    categories: ["layout", "data-display"]
+  },
+  "card-list": {
+    type: "registry:ui",
+    title: "CardList",
+    description: "Responsive list of selectable cards with keyboard navigation.",
+    categories: ["layout", "data-display"]
+  },
+  carousel: {
+    type: "registry:ui",
+    title: "Carousel",
+    description: "Slideshow component for cycling through content.",
+    categories: ["data-display"]
+  },
+  checkbox: {
+    type: "registry:ui",
+    title: "Checkbox",
+    description: "Toggle control for boolean selections.",
+    categories: ["forms"]
+  },
+  "checkbox-group": {
+    type: "registry:ui",
+    title: "CheckboxGroup",
+    description: "Managed group of checkboxes with shared state.",
+    categories: ["forms"]
+  },
+  dropdown: {
+    type: "registry:ui",
+    title: "Dropdown",
+    description: "Toggleable overlay menu for displaying a list of actions.",
+    categories: ["navigation", "actions"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  icon: {
+    type: "registry:ui",
+    title: "Icon",
+    description: "Scalable vector icon component with accessibility support.",
+    categories: ["data-display"]
+  },
+  input: {
+    type: "registry:ui",
+    title: "Input",
+    description: "Text input field with validation and formatting support.",
+    categories: ["forms"]
+  },
+  "list-group": {
+    type: "registry:ui",
+    title: "ListGroup",
+    description: "Flexible component for displaying a series of items.",
+    categories: ["data-display", "navigation"]
+  },
+  modal: {
+    type: "registry:ui",
+    title: "Modal",
+    description: "Dialog overlay for focused content and user interactions.",
+    categories: ["feedback", "disclosure"]
+  },
+  navbar: {
+    type: "registry:ui",
+    title: "Navbar",
+    description: "Responsive navigation header with branding and links.",
+    categories: ["navigation"]
+  },
+  pagination: {
+    type: "registry:ui",
+    title: "Pagination",
+    description: "Navigation controls for paged content.",
+    categories: ["navigation"]
+  },
+  popover: {
+    type: "registry:ui",
+    title: "Popover",
+    description: "Floating content panel anchored to a trigger element.",
+    categories: ["disclosure"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  progress: {
+    type: "registry:ui",
+    title: "Progress",
+    description: "Visual indicator of task completion.",
+    categories: ["feedback"]
+  },
+  radio: {
+    type: "registry:ui",
+    title: "Radio",
+    description: "Single-select control within a group of options.",
+    categories: ["forms"]
+  },
+  scrollspy: {
+    type: "registry:ui",
+    title: "Scrollspy",
+    description: "Automatically highlights navigation links based on scroll position.",
+    categories: ["navigation"]
+  },
+  select: {
+    type: "registry:ui",
+    title: "Select",
+    description: "Dropdown selector for choosing from a list of options.",
+    categories: ["forms"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  "selectable-card": {
+    type: "registry:ui",
+    title: "SelectableCard",
+    description: "Card variant that acts as a selectable option.",
+    categories: ["forms", "data-display"]
+  },
+  sheet: {
+    type: "registry:ui",
+    title: "Sheet",
+    description: "Sliding panel overlay from screen edges.",
+    categories: ["disclosure", "layout"]
+  },
+  spinner: {
+    type: "registry:ui",
+    title: "Spinner",
+    description: "Loading indicator for asynchronous operations.",
+    categories: ["feedback"]
+  },
+  switch: {
+    type: "registry:ui",
+    title: "Switch",
+    description: "Toggle control for binary on/off states.",
+    categories: ["forms"]
+  },
+  table: {
+    type: "registry:ui",
+    title: "Table",
+    description: "Data table with sorting, selection, and responsive layout.",
+    categories: ["data-display"]
+  },
+  tabs: {
+    type: "registry:ui",
+    title: "Tabs",
+    description: "Tabbed interface for switching between content panels.",
+    categories: ["navigation", "layout"]
+  },
+  "tabs-pro": {
+    type: "registry:ui",
+    title: "TabsPro",
+    description: "Advanced tabbed interface with closable, sortable, and overflow support.",
+    categories: ["navigation", "layout"]
+  },
+  toast: {
+    type: "registry:ui",
+    title: "Toast",
+    description: "Brief notification messages that auto-dismiss.",
+    categories: ["feedback"]
+  },
+  tooltip: {
+    type: "registry:ui",
+    title: "Tooltip",
+    description: "Informational popup displayed on hover or focus.",
+    categories: ["data-display"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  typography: {
+    type: "registry:ui",
+    title: "Typography",
+    description: "Text rendering primitives with semantic variants.",
+    categories: ["data-display"]
+  }
+};
+var hookMap = {
+  "use-async": {
+    type: "registry:hook",
+    title: "useAsync",
+    description: "Manages async operation lifecycle (loading, error, data states).",
+    categories: ["state"]
+  },
+  "use-callback-ref": {
+    type: "registry:hook",
+    title: "useCallbackRef",
+    description: "Stable callback reference that always points to the latest function.",
+    categories: ["refs"]
+  },
+  "use-click-outside": {
+    type: "registry:hook",
+    title: "useClickOutside",
+    description: "Detects clicks outside of a target element.",
+    categories: ["dom"]
+  },
+  "use-controllable-state": {
+    type: "registry:hook",
+    title: "useControllableState",
+    description: "Manages state that can be either controlled or uncontrolled.",
+    categories: ["state"]
+  },
+  "use-dark-mode": {
+    type: "registry:hook",
+    title: "useDarkMode",
+    description: "Detects and toggles dark mode preference.",
+    categories: ["theme"]
+  },
+  "use-debounce": {
+    type: "registry:hook",
+    title: "useDebounce",
+    description: "Debounces a value or callback over a specified delay.",
+    categories: ["timing"]
+  },
+  "use-field": {
+    type: "registry:hook",
+    title: "useField",
+    description: "Form field state management with validation.",
+    categories: ["forms"]
+  },
+  "use-focus-trap": {
+    type: "registry:hook",
+    title: "useFocusTrap",
+    description: "Traps keyboard focus within a container for modal-like experiences.",
+    categories: ["a11y"]
+  },
+  "use-form": {
+    type: "registry:hook",
+    title: "useForm",
+    description: "Comprehensive form state management with validation.",
+    categories: ["forms"]
+  },
+  "use-hover": {
+    type: "registry:hook",
+    title: "useHover",
+    description: "Tracks hover state of an element with enter/leave delays.",
+    categories: ["dom"]
+  },
+  "use-id": {
+    type: "registry:hook",
+    title: "useId",
+    description: "Generates stable unique identifiers for accessibility attributes.",
+    categories: ["a11y"]
+  },
+  "use-intersection-observer": {
+    type: "registry:hook",
+    title: "useIntersectionObserver",
+    description: "Observes element visibility within the viewport.",
+    categories: ["dom"]
+  },
+  "use-key-press": {
+    type: "registry:hook",
+    title: "useKeyPress",
+    description: "Listens for specific keyboard key presses.",
+    categories: ["dom"]
+  },
+  "use-local-storage": {
+    type: "registry:hook",
+    title: "useLocalStorage",
+    description: "Persists state to localStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-media-query": {
+    type: "registry:hook",
+    title: "useMediaQuery",
+    description: "Matches CSS media queries and provides responsive breakpoint helpers.",
+    categories: ["responsive"]
+  },
+  "use-mounted": {
+    type: "registry:hook",
+    title: "useMounted",
+    description: "Tracks whether the component is currently mounted.",
+    categories: ["lifecycle"]
+  },
+  "use-previous": {
+    type: "registry:hook",
+    title: "usePrevious",
+    description: "Returns the previous value of a variable across renders.",
+    categories: ["state"]
+  },
+  "use-reduced-motion": {
+    type: "registry:hook",
+    title: "useReducedMotion",
+    description: "Detects user preference for reduced motion.",
+    categories: ["a11y"]
+  },
+  "use-resize-observer": {
+    type: "registry:hook",
+    title: "useResizeObserver",
+    description: "Observes element size changes via ResizeObserver.",
+    categories: ["dom"]
+  },
+  "use-roving-focus": {
+    type: "registry:hook",
+    title: "useRovingFocus",
+    description: "Implements roving tabindex pattern for composite widgets.",
+    categories: ["a11y"]
+  },
+  "use-scroll-lock": {
+    type: "registry:hook",
+    title: "useScrollLock",
+    description: "Prevents body scrolling while active (for modals/overlays).",
+    categories: ["dom"]
+  },
+  "use-session-storage": {
+    type: "registry:hook",
+    title: "useSessionStorage",
+    description: "Persists state to sessionStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-throttle": {
+    type: "registry:hook",
+    title: "useThrottle",
+    description: "Throttles a value or callback to fire at most once per interval.",
+    categories: ["timing"]
+  }
+};
+var utilMap = {
+  cn: {
+    type: "registry:util",
+    title: "cn",
+    description: "Conditional class name composition utility.",
+    categories: ["styling"]
+  },
+  a11y: {
+    type: "registry:util",
+    title: "a11y",
+    description: "Accessibility utilities including screen reader announcements and ARIA helpers.",
+    categories: ["a11y"]
+  },
+  async: {
+    type: "registry:util",
+    title: "async",
+    description: "Async operation utilities: abortable tasks, queues, exponential backoff.",
+    categories: ["async"]
+  },
+  browser: {
+    type: "registry:util",
+    title: "browser",
+    description: "Browser environment detection and feature checks.",
+    categories: ["platform"]
+  },
+  collections: {
+    type: "registry:util",
+    title: "collections",
+    description: "Collection utilities: chunk, paginate, memoize, selectors.",
+    categories: ["data"]
+  },
+  color: {
+    type: "registry:util",
+    title: "color",
+    description: "Color manipulation utilities: contrast, luminance, hex/rgb conversion.",
+    categories: ["styling"]
+  },
+  date: {
+    type: "registry:util",
+    title: "date",
+    description: "Date formatting and relative time utilities.",
+    categories: ["formatting"]
+  },
+  "merge-refs": {
+    type: "registry:util",
+    title: "mergeRefs",
+    description: "Merges multiple React refs into a single callback ref.",
+    categories: ["refs"]
+  },
+  dx: {
+    type: "registry:util",
+    title: "dx",
+    description: "Developer experience helpers: component creation, context factories, polymorphic patterns.",
+    categories: ["dx"]
+  },
+  forms: {
+    type: "registry:util",
+    title: "forms",
+    description: "Form utilities: validators, field error extraction, dirty checking.",
+    categories: ["forms"]
+  },
+  keyboard: {
+    type: "registry:util",
+    title: "keyboard",
+    description: "Keyboard event helpers for detecting specific keys.",
+    categories: ["dom"]
+  },
+  layout: {
+    type: "registry:util",
+    title: "layout",
+    description: "Layout measurement utilities: element bounds, viewport size, resize observation.",
+    categories: ["dom"]
+  },
+  misc: {
+    type: "registry:util",
+    title: "misc",
+    description: "Miscellaneous utilities: clear icon, safe input props, event helpers.",
+    categories: ["misc"]
+  },
+  motion: {
+    type: "registry:util",
+    title: "motion",
+    description: "Animation utilities: spring physics, easing functions, distance calculations.",
+    categories: ["animation"]
+  },
+  number: {
+    type: "registry:util",
+    title: "number",
+    description: "Number formatting and clamping utilities.",
+    categories: ["formatting"]
+  },
+  object: {
+    type: "registry:util",
+    title: "object",
+    description: "Object manipulation utilities: deep merge, pick, omit.",
+    categories: ["data"]
+  },
+  platform: {
+    type: "registry:util",
+    title: "platform",
+    description: "Platform detection utilities: browser, OS, device pixel ratio, text direction.",
+    categories: ["platform"]
+  },
+  responsive: {
+    type: "registry:util",
+    title: "responsive",
+    description: "Responsive design utilities.",
+    categories: ["responsive"]
+  },
+  safety: {
+    type: "registry:util",
+    title: "safety",
+    description: "Security utilities: clipboard access, crypto ID generation, token generation.",
+    categories: ["security"]
+  },
+  string: {
+    type: "registry:util",
+    title: "string",
+    description: "String manipulation utilities: capitalize, slugify, variant classes.",
+    categories: ["formatting"]
+  },
+  telemetry: {
+    type: "registry:util",
+    title: "telemetry",
+    description: "Telemetry utilities: error catching, performance measurement, timing.",
+    categories: ["observability"]
+  },
+  timing: {
+    type: "registry:util",
+    title: "timing",
+    description: "Timing utilities: debounce and throttle functions.",
+    categories: ["timing"]
+  },
+  types: {
+    type: "registry:util",
+    title: "types",
+    description: "Shared type guards and type utilities.",
+    categories: ["types"]
+  },
+  validation: {
+    type: "registry:util",
+    title: "validation",
+    description: "Input validation utilities: email, URL, href safety checks.",
+    categories: ["validation"]
+  }
+};
+var directoryToRegistryName = {
+  Accordion: "accordion",
+  Alert: "alert",
+  Avatar: "avatar",
+  Badge: "badge",
+  Breadcrumb: "breadcrumb",
+  Button: "button",
+  Card: "card",
+  CardList: "card-list",
+  Carousel: "carousel",
+  Checkbox: "checkbox",
+  CheckboxGroup: "checkbox-group",
+  Dropdown: "dropdown",
+  Icon: "icon",
+  Input: "input",
+  ListGroup: "list-group",
+  Modal: "modal",
+  Navbar: "navbar",
+  Pagination: "pagination",
+  Popover: "popover",
+  Progress: "progress",
+  Radio: "radio",
+  Scrollspy: "scrollspy",
+  Select: "select",
+  SelectableCard: "selectable-card",
+  Sheet: "sheet",
+  Spinner: "spinner",
+  Switch: "switch",
+  Table: "table",
+  Tabs: "tabs",
+  TabsPro: "tabs-pro",
+  Toast: "toast",
+  Tooltip: "tooltip",
+  Typography: "typography"
+};
+var hookDirectoryToRegistryName = {
+  useAsync: "use-async",
+  useCallbackRef: "use-callback-ref",
+  useClickOutside: "use-click-outside",
+  useControllableState: "use-controllable-state",
+  useDarkMode: "use-dark-mode",
+  useDebounce: "use-debounce",
+  useField: "use-field",
+  useFocusTrap: "use-focus-trap",
+  useForm: "use-form",
+  useHover: "use-hover",
+  useId: "use-id",
+  useIntersectionObserver: "use-intersection-observer",
+  useKeyPress: "use-key-press",
+  useLocalStorage: "use-local-storage",
+  useMediaQuery: "use-media-query",
+  useMounted: "use-mounted",
+  usePrevious: "use-previous",
+  useReducedMotion: "use-reduced-motion",
+  useResizeObserver: "use-resize-observer",
+  useRovingFocus: "use-roving-focus",
+  useScrollLock: "use-scroll-lock",
+  useSessionStorage: "use-session-storage",
+  useThrottle: "use-throttle"
+};
+
+// src/registry/builder.ts
+var EXCLUDE_PATTERNS = [
+  /\.test\.(tsx?|jsx?)$/,
+  /\.spec\.(tsx?|jsx?)$/,
+  /\.stories\.(tsx?|jsx?)$/,
+  /\.figma\.(tsx?|jsx?)$/,
+  /\.a11y\.test\./,
+  /\.security\.test\./,
+  /\.integration\.test\./,
+  /README\.md$/
+];
+var REACT_BUILTINS = /* @__PURE__ */ new Set(["react", "react-dom", "react/jsx-runtime", "react-dom/client"]);
+var UTIL_SUBPATH_TO_REGISTRY = {
+  index: "cn",
+  keyboard: "keyboard",
+  dom: "merge-refs",
+  "dom/mergeRefs": "merge-refs",
+  browser: "browser",
+  validation: "validation",
+  string: "string",
+  misc: "misc",
+  a11y: "a11y",
+  types: "types",
+  async: "async",
+  collections: "collections",
+  color: "color",
+  date: "date",
+  dx: "dx",
+  forms: "forms",
+  layout: "layout",
+  motion: "motion",
+  number: "number",
+  object: "object",
+  platform: "platform",
+  responsive: "responsive",
+  safety: "safety",
+  telemetry: "telemetry",
+  timing: "timing"
+};
+function shouldIncludeFile(filePath) {
+  const ext = path2.extname(filePath);
+  if (![".ts", ".tsx", ".css"].includes(ext)) return false;
+  return !EXCLUDE_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function readSourceFiles(dirPath) {
+  if (!fs3.existsSync(dirPath) || !fs3.statSync(dirPath).isDirectory()) return [];
+  const results = [];
+  for (const entry of fs3.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = path2.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      for (const sub of fs3.readdirSync(fullPath, { withFileTypes: true })) {
+        if (sub.isFile()) {
+          const subPath = path2.join(fullPath, sub.name);
+          if (shouldIncludeFile(subPath)) {
+            results.push({ path: path2.relative(dirPath, subPath), content: fs3.readFileSync(subPath, "utf-8") });
+          }
+        }
+      }
+    } else if (entry.isFile() && shouldIncludeFile(fullPath)) {
+      results.push({ path: entry.name, content: fs3.readFileSync(fullPath, "utf-8") });
+    }
+  }
+  return results;
+}
+function extractCnSource(utilsIndexPath) {
+  const content = fs3.readFileSync(utilsIndexPath, "utf-8");
+  const cnPattern = /(\/\*\*[\s\S]*?\*\/\s*)?export function cn\b[\s\S]*?\n\}/;
+  const match = cnPattern.exec(content);
+  return match ? match[0] : "export function cn(...classes: (string | boolean | undefined | null)[]): string {\n  return classes.filter(Boolean).join(' ');\n}";
+}
+function analyzeImports(files, knownNpmDeps) {
+  const registryDeps = /* @__PURE__ */ new Set();
+  const npmDeps = new Set(knownNpmDeps);
+  const importPattern = /(?:import|export)\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  for (const file of files) {
+    let m;
+    importPattern.lastIndex = 0;
+    while ((m = importPattern.exec(file.content)) !== null) {
+      const specifier = m[1] ?? "";
+      const typesPattern = /\.\.\/(?:\.\.\/)?types(?:\/.*)?$/;
+      if (typesPattern.test(specifier)) {
+        registryDeps.add("dsai-types");
+        continue;
+      }
+      const hookPattern = /\.\.\/(?:\.\.\/)?hooks\/(\w+)/;
+      const hookMatch = hookPattern.exec(specifier);
+      if (hookMatch && hookMatch[1]) {
+        const regName = hookDirectoryToRegistryName[hookMatch[1]];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const utilPattern = /\.\.\/(?:\.\.\/)?utils(?:\/(.+))?$/;
+      const utilMatch = utilPattern.exec(specifier);
+      if (utilMatch) {
+        const subpath = utilMatch[1] ?? "index";
+        const regName = UTIL_SUBPATH_TO_REGISTRY[subpath];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const compPattern = /^\.\.\/(\.\.\/)?(?:components\/)?([A-Z]\w+)(?:\/.*)?$/;
+      const compMatch = compPattern.exec(specifier);
+      if (compMatch && compMatch[2]) {
+        const compDir = compMatch[2];
+        const regName = directoryToRegistryName[compDir];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+        const parts = specifier.split("/");
+        const pkgName = specifier.startsWith("@") && parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0] ?? specifier;
+        if (pkgName && !REACT_BUILTINS.has(pkgName) && !pkgName.startsWith("@dsai-io/")) {
+          npmDeps.add(pkgName);
+        }
+      }
+    }
+  }
+  return { registryDeps, npmDeps };
+}
+function buildComponentItem(name, dirPath, log) {
+  const meta = componentMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for component "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: path2.extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildHookItem(name, dirPath, log) {
+  const meta = hookMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for hook "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: path2.extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildUtilItem(name, reactSrcDir, log) {
+  const meta = utilMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for util "${name}", skipping`);
+    return null;
+  }
+  let files;
+  let registryDeps = /* @__PURE__ */ new Set();
+  let npmDeps = /* @__PURE__ */ new Set();
+  if (name === "cn") {
+    const indexPath = path2.join(reactSrcDir, "utils", "index.ts");
+    const cnSource = extractCnSource(indexPath);
+    files = [{ path: "cn.ts", type: "registry:util", content: cnSource }];
+  } else if (name === "merge-refs") {
+    const dirPath = path2.join(reactSrcDir, "utils", "dom");
+    const sourceFiles = readSourceFiles(dirPath);
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `dom/${f.path}`,
+      type: path2.extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  } else {
+    const dirPath = path2.join(reactSrcDir, "utils", name);
+    if (!fs3.existsSync(dirPath) || !fs3.statSync(dirPath).isDirectory()) {
+      log(`  [WARN] Util directory not found: ${dirPath}`);
+      return null;
+    }
+    const sourceFiles = readSourceFiles(dirPath);
+    if (sourceFiles.length === 0) {
+      log(`  [WARN] No source files found in ${dirPath}`);
+      return null;
+    }
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `${name}/${f.path}`,
+      type: path2.extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  }
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildTypesItem(reactSrcDir, log) {
+  const typesDir = path2.join(reactSrcDir, "types");
+  const sourceFiles = readSourceFiles(typesDir);
+  if (sourceFiles.length === 0) {
+    log("  [WARN] No type files found");
+    return null;
+  }
+  const files = sourceFiles.map((f) => {
+    let content = f.content;
+    content = content.replace(/export \{[^}]*\} from ['"]\.\.\/utils\/[^'"]+['"];?\n?/g, "");
+    return {
+      path: `types/${f.path}`,
+      type: "registry:type",
+      content
+    };
+  });
+  return {
+    name: "dsai-types",
+    type: "registry:type",
+    title: "Shared Types",
+    description: "Shared type definitions (SafeHTMLAttributes, ComponentSize, PolymorphicComponentProps, etc.)",
+    dependencies: [],
+    devDependencies: [],
+    registryDependencies: [],
+    files,
+    categories: ["types"]
+  };
+}
+function buildRegistry(options) {
+  const { reactSrcDir, outputDir, verbose = false } = options;
+  const log = verbose ? (msg) => console.log(msg) : (_msg) => {
+  };
+  const componentsDir = path2.join(reactSrcDir, "components");
+  const hooksDir = path2.join(reactSrcDir, "hooks");
+  const allItems = [];
+  log("[registry] Scanning components...");
+  if (fs3.existsSync(componentsDir)) {
+    for (const entry of fs3.readdirSync(componentsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = directoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown component directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildComponentItem(registryName, path2.join(componentsDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning hooks...");
+  if (fs3.existsSync(hooksDir)) {
+    for (const entry of fs3.readdirSync(hooksDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = hookDirectoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown hook directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildHookItem(registryName, path2.join(hooksDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning utils...");
+  for (const name of Object.keys(utilMap)) {
+    log(`  Building ${name}...`);
+    const item = buildUtilItem(name, reactSrcDir, log);
+    if (item) allItems.push(item);
+  }
+  log("[registry] Building shared types...");
+  const typesItem = buildTypesItem(reactSrcDir, log);
+  if (typesItem) {
+    allItems.push(typesItem);
+    log(`  Built dsai-types (${typesItem.files.length} files)`);
+  }
+  log(`[registry] Writing ${allItems.length} items to ${outputDir}...`);
+  for (const sub of ["components", "hooks", "utils", "types"]) {
+    const dir = path2.join(outputDir, sub);
+    if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+  }
+  const typeToSubdir = {
+    "registry:ui": "components",
+    "registry:component": "components",
+    "registry:hook": "hooks",
+    "registry:util": "utils",
+    "registry:lib": "utils",
+    "registry:type": "types"
+  };
+  for (const item of allItems) {
+    const subdir = typeToSubdir[item.type] ?? "utils";
+    const filePath = path2.join(outputDir, subdir, `${item.name}.json`);
+    fs3.writeFileSync(filePath, JSON.stringify(item, null, 2) + "\n", "utf-8");
+    log(`  Wrote ${path2.relative(outputDir, filePath)}`);
+  }
+  const indexEntries = allItems.map((item) => ({
+    name: item.name,
+    type: item.type,
+    title: item.title,
+    description: item.description,
+    dependencies: item.dependencies,
+    registryDependencies: item.registryDependencies,
+    categories: item.categories
+  }));
+  const registryIndex = {
+    version: "0.1.0",
+    count: indexEntries.length,
+    items: indexEntries
+  };
+  fs3.writeFileSync(path2.join(outputDir, "index.json"), JSON.stringify(registryIndex, null, 2) + "\n", "utf-8");
+  log(`[registry] Wrote index.json (${registryIndex.count} items)`);
+  return registryIndex;
+}
+function loadItem(name, registryDir) {
+  const subdirs = ["components", "hooks", "utils", "lib", "styles", "types"];
+  for (const sub of subdirs) {
+    const filePath = path2.join(registryDir, sub, `${name}.json`);
+    if (fs3.existsSync(filePath)) {
+      return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    }
+  }
+  return null;
+}
+function resolveTree(names, registryDir) {
+  const visited = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (visited.has(name)) continue;
+    const item = loadItem(name, registryDir);
+    if (!item) {
+      throw new Error(`Registry item "${name}" not found. Run \`dsai registry build\` or check the name.`);
+    }
+    visited.set(name, item);
+    for (const dep of item.registryDependencies) {
+      if (!visited.has(dep)) queue.push(dep);
+    }
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const [name, item] of visited) {
+    inDeg.set(name, item.registryDependencies.filter((d) => visited.has(d)).length);
+  }
+  const sorted = [];
+  const ready = [];
+  for (const [name, deg] of inDeg) {
+    if (deg === 0) ready.push(name);
+  }
+  while (ready.length > 0) {
+    const name = ready.shift();
+    sorted.push(visited.get(name));
+    for (const [otherName, otherItem] of visited) {
+      if (otherItem.registryDependencies.includes(name)) {
+        const newDeg = (inDeg.get(otherName) ?? 1) - 1;
+        inDeg.set(otherName, newDeg);
+        if (newDeg === 0) ready.push(otherName);
+      }
+    }
+  }
+  if (sorted.length !== visited.size) {
+    const missing = [...visited.keys()].filter((n) => !sorted.some((s) => s.name === n));
+    throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  const allDevDeps = /* @__PURE__ */ new Set();
+  const lightVars = {};
+  const darkVars = {};
+  for (const item of sorted) {
+    for (const dep of item.dependencies) allDeps.add(dep);
+    for (const dep of item.devDependencies) allDevDeps.add(dep);
+    if (item.cssVars?.light) Object.assign(lightVars, item.cssVars.light);
+    if (item.cssVars?.dark) Object.assign(darkVars, item.cssVars.dark);
+  }
+  return {
+    items: sorted,
+    dependencies: [...allDeps],
+    devDependencies: [...allDevDeps],
+    cssVars: { light: lightVars, dark: darkVars }
+  };
+}
+
+// src/registry/transformer.ts
+function transformImports(content, options) {
+  const { aliases } = options;
+  let result = content;
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+types(?:\/([^'"]+))?(['"])/g,
+    (_match, prefix, subpath, suffix) => {
+      if (subpath) {
+        return `${prefix}${aliases.importAlias}${aliases.components}/types/${subpath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.components}/types${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])\.\.\/(([A-Z]\w+)(\/[^'"]+)?)(['"])/g,
+    (_match, prefix, _fullPath, dirName, subPath, suffix) => {
+      const kebab = dirName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      if (subPath) {
+        return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${subPath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+hooks\/(\w+)(['"])/g,
+    `$1${aliases.importAlias}${aliases.hooks}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils\/(\w+(?:\/\w+)?)(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}$2`
+  );
+  return result;
+}
+function normalizeExtensions(content, tsx) {
+  if (!tsx) {
+    return content.replace(/(from\s+['"][^'"]+)\.tsx(['"])/g, "$1.jsx$2").replace(/(from\s+['"][^'"]+)\.ts(['"])/g, "$1.js$2");
+  }
+  return content;
+}
+function getTargetDir(type, aliases) {
+  switch (type) {
+    case "registry:ui":
+      return aliases.ui;
+    case "registry:hook":
+      return aliases.hooks;
+    case "registry:util":
+      return aliases.utils;
+    case "registry:lib":
+      return aliases.lib;
+    case "registry:component":
+      return aliases.components;
+    case "registry:type":
+      return aliases.components;
+    case "registry:style":
+      return aliases.ui;
+    default:
+      return aliases.lib;
+  }
+}
+function detectPackageManager(projectDir) {
+  if (fs3.existsSync(path2.join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs3.existsSync(path2.join(projectDir, "bun.lockb")) || fs3.existsSync(path2.join(projectDir, "bun.lock"))) return "bun";
+  if (fs3.existsSync(path2.join(projectDir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getInstallArgs(pm, packages, dev) {
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", ["add", ...[], ...packages]];
+    case "yarn":
+      return ["yarn", ["add", ...[], ...packages]];
+    case "bun":
+      return ["bun", ["add", ...[], ...packages]];
+    default:
+      return ["npm", ["install", ...[], ...packages]];
+  }
+}
+function writeRegistryItems(tree, options) {
+  const { projectDir, aliases, components, overwrite, dryRun, log } = options;
+  const result = { written: [], skipped: [], installedDeps: [] };
+  const shouldOverwrite = overwrite ?? components.overwrite;
+  for (const item of tree.items) {
+    const targetBaseDir = getTargetDir(item.type, aliases);
+    for (const file of item.files) {
+      const fileName = path2.basename(file.path);
+      let targetPath;
+      if (file.target) {
+        targetPath = path2.join(projectDir, file.target);
+      } else if (item.type === "registry:ui" || item.type === "registry:component") {
+        targetPath = path2.join(projectDir, targetBaseDir, item.name, fileName);
+      } else if (item.type === "registry:type") {
+        targetPath = path2.join(projectDir, targetBaseDir, file.path);
+      } else {
+        targetPath = path2.join(projectDir, targetBaseDir, fileName);
+      }
+      if (fs3.existsSync(targetPath) && !shouldOverwrite) {
+        if (log) log(`  Skipped (exists): ${targetPath}`);
+        result.skipped.push(targetPath);
+        continue;
+      }
+      let content = file.content;
+      content = transformImports(content, { aliases, tsx: components.tsx });
+      content = normalizeExtensions(content, components.tsx);
+      if (dryRun) {
+        if (log) log(`  Would write: ${targetPath}`);
+        result.written.push(targetPath);
+        continue;
+      }
+      const dir = path2.dirname(targetPath);
+      if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+      fs3.writeFileSync(targetPath, content, "utf-8");
+      if (log) log(`  Written: ${targetPath}`);
+      result.written.push(targetPath);
+    }
+  }
+  const depsToInstall = tree.dependencies.filter((dep) => {
+    const pkgJsonPath = path2.join(projectDir, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+      return !Reflect.get(allDeps, dep);
+    }
+    return true;
+  });
+  if (depsToInstall.length > 0 && !dryRun) {
+    const pm = detectPackageManager(projectDir);
+    const [cmd, args] = getInstallArgs(pm, depsToInstall);
+    if (log) log(`  Installing: ${cmd} ${args.join(" ")}`);
+    child_process.execFileSync(cmd, args, { cwd: projectDir, stdio: "inherit" });
+    result.installedDeps = depsToInstall;
+  } else if (depsToInstall.length > 0 && dryRun) {
+    if (log) log(`  Would install: ${depsToInstall.join(", ")}`);
+    result.installedDeps = depsToInstall;
+  }
+  return result;
+}
 function getPackageRoot() {
   const currentFile = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
   return path2.resolve(path2.dirname(currentFile), "..");
@@ -9219,11 +10429,13 @@ exports.DEFAULT_PREFIX = DEFAULT_PREFIX;
 exports.DEFAULT_SOURCE_DIR = DEFAULT_SOURCE_DIR;
 exports.VALID_TOKEN_TYPES = VALID_TOKEN_TYPES;
 exports.addScssImportHeader = addScssImportHeader;
+exports.aliasesConfigSchema = aliasesConfigSchema;
 exports.applyNameMapping = applyNameMapping;
 exports.autoDetectThemes = autoDetectThemes;
 exports.buildAllThemes = buildAllThemes;
 exports.buildConfigSchema = buildConfigSchema;
 exports.buildIcons = buildIcons;
+exports.buildRegistry = buildRegistry;
 exports.buildTheme = buildTheme;
 exports.buildTokens = buildTokens;
 exports.buildTokensCLI = buildTokensCLI;
@@ -9234,6 +10446,7 @@ exports.cleanSVGForReact = cleanSVGForReact;
 exports.cleanTokenOutputs = cleanTokenOutputs;
 exports.cleanTokensCLI = cleanTokensCLI;
 exports.clearConfigCache = clearConfigCache;
+exports.componentsConfigSchema = componentsConfigSchema;
 exports.createBundle = createBundle;
 exports.createBundleFromFiles = createBundleFromFiles;
 exports.createBundles = createBundles;
@@ -9245,6 +10458,8 @@ exports.createStyleDictionaryConfig = createStyleDictionaryConfig;
 exports.customFormatSchema = customFormatSchema;
 exports.customTransformSchema = customTransformSchema;
 exports.deepMerge = deepMerge2;
+exports.defaultAliasesConfig = defaultAliasesConfig;
+exports.defaultComponentsConfig = defaultComponentsConfig;
 exports.defaultConfig = defaultConfig;
 exports.defaultFormats = defaultFormats;
 exports.defaultGlobalConfig = defaultGlobalConfig;
@@ -9351,6 +10566,7 @@ exports.mergeConfigs = mergeConfigs;
 exports.mergeContent = mergeContent;
 exports.migrateConfig = migrateConfig;
 exports.migrateLegacyTokensConfig = migrateLegacyTokensConfig;
+exports.normalizeExtensions = normalizeExtensions;
 exports.normalizeIconName = normalizeIconName;
 exports.optimizeSVG = optimizeSVG;
 exports.optimizeSVGFiles = optimizeSVGFiles;
@@ -9370,11 +10586,17 @@ exports.registerFormats = registerFormats;
 exports.registerPreprocessors = registerPreprocessors;
 exports.registerTransformGroups = registerTransformGroups;
 exports.registerTransforms = registerTransforms;
+exports.registryFileSchema = registryFileSchema;
+exports.registryIndexEntrySchema = registryIndexEntrySchema;
+exports.registryIndexSchema = registryIndexSchema;
+exports.registryItemSchema = registryItemSchema;
+exports.registryItemTypeSchema = registryItemTypeSchema;
 exports.replacePlaceholders = replacePlaceholders;
 exports.resolveAllOutputPaths = resolveAllOutputPaths;
 exports.resolveConfig = resolveConfig;
 exports.resolveOutputPath = resolveOutputPath;
 exports.resolvePath = resolvePath;
+exports.resolveTree = resolveTree;
 exports.runBuildCLI = runBuildCLI;
 exports.scanDirectories = scanDirectories;
 exports.scanSVGFiles = scanSVGFiles;
@@ -9399,6 +10621,7 @@ exports.tokenCacheConfigSchema = tokenCacheConfigSchema;
 exports.tokenWatchConfigSchema = tokenWatchConfigSchema;
 exports.tokensConfigSchema = tokensConfigSchema;
 exports.tokensHooksSchema = tokensHooksSchema;
+exports.transformImports = transformImports;
 exports.transformToken = transformToken;
 exports.transformTokenTree = transformTokenTree;
 exports.transformTokens = transformTokens;
@@ -9425,5 +10648,6 @@ exports.validateTokensCLI = validateTokensCLI;
 exports.version = version;
 exports.versionSchema = versionSchema;
 exports.writeChangelog = writeChangelog;
+exports.writeRegistryItems = writeRegistryItems;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map