@genesislcap/ts-builder 14.417.1-alpha-83eabbf.0 → 14.418.0

package/src/react-jsx-generator.ts

@@ -1,994 +0,0 @@
-import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
-import { dirname, relative, resolve } from 'node:path';
-
-type CEMType = { text?: string };
-type CEMEvent = { name?: string; type?: CEMType };
-type CEMSuperclass = {
-  name?: string;
-  package?: string;
-};
-type CEMMember = {
-  name?: string;
-  fieldName?: string;
-  attribute?: string | null;
-  kind?: string;
-  privacy?: string;
-  type?: CEMType;
-};
-type CEMDeclaration = {
-  name?: string;
-  customElement?: boolean;
-  tagName?: string;
-  superclass?: CEMSuperclass;
-  members?: CEMMember[];
-  attributes?: CEMMember[];
-  events?: CEMEvent[];
-};
-type CEMModule = {
-  declarations?: CEMDeclaration[];
-};
-type CEMManifest = {
-  modules?: CEMModule[];
-};
-
-type TypeImportState = {
-  importsByIdentifier: Map<string, string>;
-  ambiguousIdentifiers: Set<string>;
-  usedImports: Map<string, Set<string>>;
-  wildcardExportModules: Set<string>;
-};
-
-function createTypeImportState(): TypeImportState {
-  return {
-    importsByIdentifier: new Map(),
-    ambiguousIdentifiers: new Set(),
-    usedImports: new Map(),
-    wildcardExportModules: new Set(),
-  };
-}
-
-const GENERATED_FILE_NAME = 'react-jsx-runtime.d.ts';
-
-const primitiveUnionRegex =
-  /^(?:\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)(?:\|\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)*$/;
-
-const allowedTypeIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
-const allowedTypeNameSet = new Set([
-  'Array',
-  'ReadonlyArray',
-  'Promise',
-  'Record',
-  'Partial',
-  'Required',
-  'Pick',
-  'Omit',
-  'Map',
-  'Set',
-  'WeakMap',
-  'WeakSet',
-  'Date',
-  'RegExp',
-  'Error',
-  'Node',
-  'Element',
-  'HTMLElement',
-  'SVGElement',
-  'Event',
-  'CustomEvent',
-  'MouseEvent',
-  'KeyboardEvent',
-  'FocusEvent',
-  'InputEvent',
-  'PointerEvent',
-  'WheelEvent',
-  'DragEvent',
-  'SubmitEvent',
-  'AbortSignal',
-  'DOMRect',
-  'Document',
-  'Window',
-  'URL',
-  'URLSearchParams',
-  'CSSStyleDeclaration',
-  'Intl.Locale',
-]);
-
-const reactNativeEventHandlerNames = new Set([
-  'onCopy',
-  'onCut',
-  'onPaste',
-  'onCompositionEnd',
-  'onCompositionStart',
-  'onCompositionUpdate',
-  'onFocus',
-  'onBlur',
-  'onChange',
-  'onBeforeInput',
-  'onInput',
-  'onReset',
-  'onSubmit',
-  'onInvalid',
-  'onLoad',
-  'onError',
-  'onKeyDown',
-  'onKeyPress',
-  'onKeyUp',
-  'onAbort',
-  'onCanPlay',
-  'onCanPlayThrough',
-  'onDurationChange',
-  'onEmptied',
-  'onEncrypted',
-  'onEnded',
-  'onLoadedData',
-  'onLoadedMetadata',
-  'onLoadStart',
-  'onPause',
-  'onPlay',
-  'onPlaying',
-  'onProgress',
-  'onRateChange',
-  'onResize',
-  'onSeeked',
-  'onSeeking',
-  'onStalled',
-  'onSuspend',
-  'onTimeUpdate',
-  'onVolumeChange',
-  'onWaiting',
-  'onAuxClick',
-  'onClick',
-  'onContextMenu',
-  'onDoubleClick',
-  'onDrag',
-  'onDragEnd',
-  'onDragEnter',
-  'onDragExit',
-  'onDragLeave',
-  'onDragOver',
-  'onDragStart',
-  'onDrop',
-  'onMouseDown',
-  'onMouseEnter',
-  'onMouseLeave',
-  'onMouseMove',
-  'onMouseOut',
-  'onMouseOver',
-  'onMouseUp',
-  'onSelect',
-  'onTouchCancel',
-  'onTouchEnd',
-  'onTouchMove',
-  'onTouchStart',
-  'onPointerOver',
-  'onPointerEnter',
-  'onPointerDown',
-  'onPointerMove',
-  'onPointerUp',
-  'onPointerCancel',
-  'onPointerOut',
-  'onPointerLeave',
-  'onGotPointerCapture',
-  'onLostPointerCapture',
-  'onScroll',
-  'onWheel',
-  'onAnimationStart',
-  'onAnimationEnd',
-  'onAnimationIteration',
-  'onTransitionEnd',
-  'onToggle',
-]);
-
-function normalizeWhitespace(value: string): string {
-  return value.replace(/\s+/g, ' ').trim();
-}
-
-function toTypeNameSegment(value: string): string {
-  const pascal = toPascalCase(value);
-  if (!pascal) {
-    return 'Pkg';
-  }
-
-  if (/^[0-9]/.test(pascal)) {
-    return `Pkg${pascal}`;
-  }
-
-  return pascal;
-}
-
-function getPackageTypePrefix(packageName: string): string {
-  const withoutScope = packageName.replace(/^@/, '').replace(/\//g, '-');
-  const segment = toTypeNameSegment(withoutScope);
-  return `${segment}React`;
-}
-
-function normalizePropertyName(name: string): string | null {
-  let normalized = name.trim();
-  if (!normalized) return null;
-
-  const bracketQuotedMatch = normalized.match(/^\[\s*['"](.+?)['"]\s*\]$/);
-  if (bracketQuotedMatch) {
-    normalized = bracketQuotedMatch[1];
-  } else {
-    const bracketMatch = normalized.match(/^\[\s*(.+?)\s*\]$/);
-    if (bracketMatch) {
-      normalized = bracketMatch[1];
-    }
-    const quotedMatch = normalized.match(/^['"](.+?)['"]$/);
-    if (quotedMatch) {
-      normalized = quotedMatch[1];
-    }
-  }
-
-  normalized = normalized.trim();
-  if (!normalized) return null;
-  if (normalized.includes('\n') || normalized.includes('\r')) return null;
-  return normalized;
-}
-
-function escapeSingleQuotes(value: string): string {
-  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-
-function isKnownTypeIdentifier(identifier: string): boolean {
-  if (allowedTypeNameSet.has(identifier)) return true;
-  if (allowedTypeIdentifierRegex.test(identifier) && identifier.startsWith('globalThis.')) return true;
-  return false;
-}
-
-function getIdentifierTokens(typeText: string): string[] {
-  return typeText.match(/[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g) ?? [];
-}
-
-function isPrimitiveToken(match: string): boolean {
-  return (
-    match === 'true' ||
-    match === 'false' ||
-    match === 'null' ||
-    match === 'undefined' ||
-    match === 'string' ||
-    match === 'number' ||
-    match === 'boolean' ||
-    match === 'bigint' ||
-    match === 'symbol' ||
-    match === 'unknown' ||
-    match === 'any' ||
-    match === 'void' ||
-    match === 'never'
-  );
-}
-
-function registerTypeImport(
-  state: TypeImportState,
-  identifier: string,
-  moduleSpecifier: string,
-): void {
-  if (state.ambiguousIdentifiers.has(identifier)) {
-    return;
-  }
-
-  const existing = state.importsByIdentifier.get(identifier);
-  if (existing && existing !== moduleSpecifier) {
-    state.importsByIdentifier.delete(identifier);
-    state.ambiguousIdentifiers.add(identifier);
-    return;
-  }
-
-  if (!existing) {
-    state.importsByIdentifier.set(identifier, moduleSpecifier);
-  }
-}
-
-function trackImportedIdentifierUsage(
-  state: TypeImportState,
-  identifier: string,
-  moduleSpecifier: string,
-): void {
-  if (!state.usedImports.has(moduleSpecifier)) {
-    state.usedImports.set(moduleSpecifier, new Set());
-  }
-  state.usedImports.get(moduleSpecifier)!.add(identifier);
-}
-
-function isBareModuleSpecifier(moduleSpecifier: string): boolean {
-  return !!moduleSpecifier && !moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('/');
-}
-
-function canUseComplexType(typeText: string, typeImportState?: TypeImportState): boolean {
-  if (!typeText) return false;
-  if (/[{};=]/.test(typeText)) return false;
-  if (/=>/.test(typeText)) return false;
-  if (!/^[A-Za-z0-9_$<>\[\]\(\)\|&,.?'"`\s:-]+$/.test(typeText)) return false;
-
-  const identifierMatches = getIdentifierTokens(typeText);
-  for (const match of identifierMatches) {
-    if (isPrimitiveToken(match)) {
-      continue;
-    }
-
-    if (isKnownTypeIdentifier(match)) {
-      continue;
-    }
-
-    const rootIdentifier = match.split('.')[0];
-    if (
-      typeImportState &&
-      !typeImportState.ambiguousIdentifiers.has(rootIdentifier) &&
-      typeImportState.importsByIdentifier.has(rootIdentifier)
-    ) {
-      trackImportedIdentifierUsage(
-        typeImportState,
-        rootIdentifier,
-        typeImportState.importsByIdentifier.get(rootIdentifier)!,
-      );
-      continue;
-    }
-
-    if (!isKnownTypeIdentifier(rootIdentifier)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function toPascalCase(value: string): string {
-  return value
-    .split(/[^a-zA-Z0-9]+/)
-    .filter(Boolean)
-    .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
-    .join('');
-}
-
-function toCamelCase(value: string): string {
-  const pascal = toPascalCase(value);
-  if (!pascal) return '';
-  return `${pascal[0].toLowerCase()}${pascal.slice(1)}`;
-}
-
-function toSafeType(typeText?: string, typeImportState?: TypeImportState): string {
-  if (!typeText) return 'unknown';
-  const normalized = normalizeWhitespace(typeText);
-  if (!normalized) return 'unknown';
-
-  if (primitiveUnionRegex.test(normalized)) {
-    return normalized;
-  }
-
-  if (normalized.endsWith('[]')) {
-    const itemType = normalized.slice(0, -2).trim();
-    if (primitiveUnionRegex.test(itemType)) {
-      return `${itemType}[]`;
-    }
-  }
-
-  if (canUseComplexType(normalized, typeImportState)) {
-    return normalized;
-  }
-
-  return 'unknown';
-}
-
-function getCEMManifestPath(cwd: string, packageJson: Record<string, unknown>): string {
-  if (typeof packageJson.customElements === 'string' && packageJson.customElements.trim().length > 0) {
-    return resolve(cwd, packageJson.customElements);
-  }
-
-  return resolve(cwd, 'dist/custom-elements.json');
-}
-
-function collectCustomElements(manifest: CEMManifest): CEMDeclaration[] {
-  const elements: CEMDeclaration[] = [];
-
-  for (const moduleDefinition of manifest.modules ?? []) {
-    for (const declaration of moduleDefinition.declarations ?? []) {
-      if (declaration.customElement && declaration.tagName) {
-        elements.push(declaration);
-      }
-    }
-  }
-
-  return elements;
-}
-
-function mergeUniqueByKey<T>(base: T[], extra: T[], getKey: (item: T) => string | null): T[] {
-  const merged = [...base];
-  const knownKeys = new Set(
-    base
-      .map((item) => getKey(item))
-      .filter((item): item is string => !!item),
-  );
-
-  for (const item of extra) {
-    const key = getKey(item);
-    if (!key || !knownKeys.has(key)) {
-      merged.push(item);
-      if (key) knownKeys.add(key);
-    }
-  }
-
-  return merged;
-}
-
-function mergeDeclarationMetadata(
-  declaration: CEMDeclaration,
-  inheritedDeclaration: CEMDeclaration,
-): CEMDeclaration {
-  const declarationAttributes = declaration.attributes ?? [];
-  const inheritedAttributes = inheritedDeclaration.attributes ?? [];
-  const attributes = mergeUniqueByKey(
-    declarationAttributes,
-    inheritedAttributes,
-    (attribute) => normalizePropertyName(attribute.fieldName ?? attribute.name ?? ''),
-  );
-
-  const declarationMembers = declaration.members ?? [];
-  const inheritedMembers = inheritedDeclaration.members ?? [];
-  const members = mergeUniqueByKey(
-    declarationMembers,
-    inheritedMembers,
-    (member) => normalizePropertyName(member.name ?? ''),
-  );
-
-  const declarationEvents = declaration.events ?? [];
-  const inheritedEvents = inheritedDeclaration.events ?? [];
-  const events = mergeUniqueByKey(
-    declarationEvents,
-    inheritedEvents,
-    (event) => normalizePropertyName(event.name ?? ''),
-  );
-
-  return {
-    ...declaration,
-    attributes,
-    members,
-    events,
-  };
-}
-
-function createDeclarationLookup(manifest: CEMManifest): {
-  byTagAndName: Map<string, CEMDeclaration>;
-  byTag: Map<string, CEMDeclaration>;
-} {
-  const byTagAndName = new Map<string, CEMDeclaration>();
-  const byTag = new Map<string, CEMDeclaration>();
-
-  for (const moduleDefinition of manifest.modules ?? []) {
-    for (const declaration of moduleDefinition.declarations ?? []) {
-      if (!declaration.customElement || !declaration.tagName) continue;
-
-      if (declaration.name) {
-        byTagAndName.set(`${declaration.tagName}::${declaration.name}`, declaration);
-      }
-
-      if (!byTag.has(declaration.tagName)) {
-        byTag.set(declaration.tagName, declaration);
-      }
-    }
-  }
-
-  return { byTagAndName, byTag };
-}
-
-async function mergeFastInheritanceFromManifest(
-  cwd: string,
-  declarations: CEMDeclaration[],
-): Promise<CEMDeclaration[]> {
-  const fastManifestPath = resolve(cwd, 'ms-fast-components/custom-elements.json');
-  if (!(await fileExists(fastManifestPath))) {
-    return declarations;
-  }
-
-  const fastManifest = JSON.parse(await readFile(fastManifestPath, 'utf8')) as CEMManifest;
-  const { byTagAndName, byTag } = createDeclarationLookup(fastManifest);
-
-  return declarations.map((declaration) => {
-    if (!declaration.tagName || declaration.superclass?.package !== '@microsoft/fast-components') {
-      return declaration;
-    }
-
-    const byTagAndNameKey = `${declaration.tagName}::${declaration.name ?? ''}`;
-    const inheritedDeclaration =
-      byTagAndName.get(byTagAndNameKey) ??
-      byTagAndName.get(`${declaration.tagName}::${declaration.superclass?.name ?? ''}`) ??
-      byTag.get(declaration.tagName);
-
-    if (!inheritedDeclaration) {
-      return declaration;
-    }
-
-    return mergeDeclarationMetadata(declaration, inheritedDeclaration);
-  });
-}
-
-function resolveTagPrefixes(packageName: string): string[] {
-  const normalized = packageName.toLowerCase();
-
-  if (normalized === '@genesislcap/foundation-ui') {
-    return ['foundation'];
-  }
-
-  if (normalized.startsWith('@genesislcap/rapid-') || normalized.includes('/rapid-')) {
-    return ['rapid'];
-  }
-
-  if (normalized.includes('foundation-zero') || normalized.startsWith('@genesislcap/zero-')) {
-    return ['zero'];
-  }
-
-  // MF and generic foundation packages can switch prefixes at runtime.
-  return ['foundation', 'rapid', 'zero'];
-}
-
-function normalizeTagNames(tagName: string, packageName: string): string[] {
-  const prefixToken = '%%prefix%%-';
-  if (!tagName.includes(prefixToken)) {
-    return [tagName];
-  }
-
-  const suffix = tagName.replace(prefixToken, '');
-  return resolveTagPrefixes(packageName).map((prefix) => `${prefix}-${suffix}`);
-}
-
-function toEventHandlerType(typeText?: string, typeImportState?: TypeImportState): string {
-  if (!typeText) {
-    return '(event: CustomEvent<unknown>) => void';
-  }
-
-  const normalized = typeText.trim();
-  if (!normalized) {
-    return '(event: CustomEvent<unknown>) => void';
-  }
-
-  if (normalized === 'Event') {
-    return '(event: Event) => void';
-  }
-
-  if (normalized.startsWith('CustomEvent<')) {
-    const match = normalized.match(/^CustomEvent<(.+)>$/);
-    if (!match) return '(event: CustomEvent<unknown>) => void';
-    const detailType = toSafeType(match[1]?.trim(), typeImportState);
-    return `(event: CustomEvent<${detailType}>) => void`;
-  }
-
-  if (normalized === 'CustomEvent') {
-    return '(event: CustomEvent<unknown>) => void';
-  }
-
-  return '(event: CustomEvent<unknown>) => void';
-}
-
-function buildElementProps(declaration: CEMDeclaration, typeImportState: TypeImportState): string[] {
-  const propertyMap = new Map<string, string>();
-  const eventMap = new Map<string, string>();
-
-  const addProperty = (name: string, typeText?: string) => {
-    if (!name) return;
-    const normalizedName = normalizePropertyName(name);
-    if (!normalizedName) return;
-    const safeType = toSafeType(typeText, typeImportState);
-    if (!propertyMap.has(normalizedName)) {
-      propertyMap.set(normalizedName, safeType);
-    }
-  };
-
-  for (const attribute of declaration.attributes ?? []) {
-    // Prefer React-friendly property casing when available.
-    if (attribute.fieldName) {
-      addProperty(attribute.fieldName, attribute.type?.text);
-    } else if (attribute.name) {
-      addProperty(attribute.name, attribute.type?.text);
-      if (attribute.name.includes('-')) {
-        const camelName = toCamelCase(attribute.name);
-        if (camelName) {
-          addProperty(camelName, attribute.type?.text);
-        }
-      }
-    }
-  }
-
-  // Only include public fields that are reflected as attributes.
-  for (const member of declaration.members ?? []) {
-    if (
-      member.kind === 'field' &&
-      member.privacy !== 'private' &&
-      member.privacy !== 'protected' &&
-      member.attribute &&
-      member.name &&
-      !member.name.startsWith('_') &&
-      !member.name.startsWith('$')
-    ) {
-      // React canonical typing should expose property name (camelCase).
-      addProperty(member.name, member.type?.text);
-    }
-  }
-
-  for (const event of declaration.events ?? []) {
-    if (!event.name) continue;
-    const normalizedEventName = normalizePropertyName(event.name);
-    if (!normalizedEventName) continue;
-    const eventHandlerType = toEventHandlerType(event.type?.text, typeImportState);
-    const pascalName = toPascalCase(normalizedEventName);
-    if (pascalName) {
-      const handlerName = `on${pascalName}`;
-      if (!reactNativeEventHandlerNames.has(handlerName)) {
-        eventMap.set(handlerName, eventHandlerType);
-      }
-    }
-  }
-
-  const lines: string[] = [
-    'class?: string;',
-    'part?: string;',
-    '[key: `data-${string}`]: string | number | boolean | undefined;',
-  ];
-
-  for (const [name, typeText] of propertyMap) {
-    lines.push(`'${escapeSingleQuotes(name)}'?: ${typeText};`);
-  }
-
-  for (const [name, handlerType] of eventMap) {
-    lines.push(`'${escapeSingleQuotes(name)}'?: ${handlerType};`);
-  }
-
-  return lines;
-}
-
-function generateDeclarations(
-  packageName: string,
-  declarations: CEMDeclaration[],
-  typeImportState: TypeImportState,
-): string {
-  const packagePrefix = getPackageTypePrefix(packageName);
-  const interfaceEntries: { interfaceName: string; code: string }[] = [];
-  const interfacesByTag = new Map<string, string>();
-  let interfaceCounter = 0;
-
-  for (const declaration of declarations) {
-    const interfaceName = `${packagePrefix}ElementProps${interfaceCounter + 1}`;
-    interfaceCounter += 1;
-    const props = buildElementProps(declaration, typeImportState).map((line) => `    ${line}`);
-    const code = [`  interface ${interfaceName} {`, ...props, '  }'].join('\n');
-    interfaceEntries.push({ interfaceName, code });
-    for (const tagName of normalizeTagNames(declaration.tagName!, packageName)) {
-      if (!interfacesByTag.has(tagName)) {
-        interfacesByTag.set(tagName, interfaceName);
-      }
-    }
-  }
-
-  const intrinsicEntries = [...interfacesByTag.entries()]
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([tagName, interfaceName]) => `      '${tagName}': ${interfaceName};`);
-
-  const elementInterfaces = interfaceEntries.map((entry) =>
-    entry.code.replace(
-      `interface ${entry.interfaceName} {`,
-      `interface ${entry.interfaceName} extends HTMLAttributes<HTMLElement> {`,
-    ),
-  );
-
-  const importLines = [...typeImportState.usedImports.entries()]
-    .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([moduleSpecifier, identifiers]) => {
-      const sortedIdentifiers = [...identifiers].sort((a, b) => a.localeCompare(b));
-      return `import type { ${sortedIdentifiers.join(', ')} } from '${moduleSpecifier}';`;
-    });
-
-  return [
-    '/**',
-    ' * AUTO-GENERATED FILE - DO NOT EDIT.',
-    ` * Source package: ${packageName}`,
-    ' * Generated from custom-elements manifest.',
-    ' */',
-    '',
-    "import type { HTMLAttributes } from 'react';",
-    ...importLines,
-    '',
-    "declare module 'react/jsx-runtime' {",
-    '  namespace JSX {',
-    ...elementInterfaces,
-    '    interface IntrinsicElements {',
-    ...intrinsicEntries,
-    '    }',
-    '  }',
-    '}',
-    '',
-    'export {};',
-    '',
-  ].join('\n');
-}
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function addCanonicalReferenceFromValue(value: unknown, state: TypeImportState): void {
-  if (!value || typeof value !== 'object') {
-    return;
-  }
-
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      addCanonicalReferenceFromValue(item, state);
-    }
-    return;
-  }
-
-  const record = value as Record<string, unknown>;
-  const canonicalReference = record.canonicalReference;
-  if (typeof canonicalReference === 'string') {
-    const match = canonicalReference.match(/^(@[^!]+)!([^:]+):/);
-    if (match) {
-      const moduleSpecifier = match[1];
-      const identifier = match[2];
-      if (identifier && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) {
-        registerTypeImport(state, identifier, moduleSpecifier);
-      }
-    }
-  }
-
-  for (const nestedValue of Object.values(record)) {
-    if (nestedValue && typeof nestedValue === 'object') {
-      addCanonicalReferenceFromValue(nestedValue, state);
-    }
-  }
-}
-
-function parseImportsFromDtsContent(content: string, state: TypeImportState): void {
-  const importOrExportBlockRegex =
-    /(?:import|export)\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
-  for (const match of content.matchAll(importOrExportBlockRegex)) {
-    const importList = match[1] ?? '';
-    const moduleSpecifier = match[2] ?? '';
-    if (!isBareModuleSpecifier(moduleSpecifier)) continue;
-
-    for (const entryRaw of importList.split(',')) {
-      const entry = entryRaw.trim();
-      if (!entry) continue;
-      const aliasMatch = entry.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
-      if (aliasMatch) {
-        registerTypeImport(state, aliasMatch[2], moduleSpecifier);
-        continue;
-      }
-      if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(entry)) {
-        registerTypeImport(state, entry, moduleSpecifier);
-      }
-    }
-  }
-
-  const exportAllRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
-  for (const match of content.matchAll(exportAllRegex)) {
-    const moduleSpecifier = match[1] ?? '';
-    if (!isBareModuleSpecifier(moduleSpecifier)) continue;
-    state.wildcardExportModules.add(moduleSpecifier);
-  }
-}
-
-async function collectFilesRecursively(
-  rootDirectory: string,
-  isTargetFile: (fileName: string) => boolean,
-): Promise<string[]> {
-  const files: string[] = [];
-  const queue: string[] = [rootDirectory];
-
-  while (queue.length) {
-    const currentDirectory = queue.pop()!;
-    const entries = await readdir(currentDirectory, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = resolve(currentDirectory, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      } else if (entry.isFile() && isTargetFile(entry.name)) {
-        files.push(fullPath);
-      }
-    }
-  }
-
-  return files;
-}
-
-async function collectTypeMetadataFiles(
-  distDirectory: string,
-): Promise<{ apiJsonFiles: string[]; dtsFiles: string[] }> {
-  const [apiJsonFiles, dtsFiles] = await Promise.all([
-    collectFilesRecursively(distDirectory, (fileName) => fileName.endsWith('.api.json')),
-    collectFilesRecursively(distDirectory, (fileName) => fileName.endsWith('.d.ts')),
-  ]);
-
-  return { apiJsonFiles, dtsFiles };
-}
-
-async function parseApiJsonFiles(filePaths: string[], state: TypeImportState): Promise<void> {
-  for (const filePath of filePaths) {
-    const apiJson = JSON.parse(await readFile(filePath, 'utf8')) as unknown;
-    addCanonicalReferenceFromValue(apiJson, state);
-  }
-}
-
-async function parseDtsFiles(filePaths: string[], state: TypeImportState): Promise<void> {
-  for (const filePath of filePaths) {
-    const dtsContent = await readFile(filePath, 'utf8');
-    parseImportsFromDtsContent(dtsContent, state);
-  }
-}
-
-function mergeTypeImportStateInto(
-  targetState: TypeImportState,
-  sourceState: TypeImportState,
-): void {
-  for (const ambiguousIdentifier of sourceState.ambiguousIdentifiers) {
-    targetState.importsByIdentifier.delete(ambiguousIdentifier);
-    targetState.ambiguousIdentifiers.add(ambiguousIdentifier);
-  }
-
-  for (const [identifier, moduleSpecifier] of sourceState.importsByIdentifier) {
-    registerTypeImport(targetState, identifier, moduleSpecifier);
-  }
-}
-
-async function findWorkspaceRoot(startDirectory: string): Promise<string> {
-  let currentDirectory = startDirectory;
-  while (true) {
-    const hasPackagesDirectory = await fileExists(resolve(currentDirectory, 'packages'));
-    const hasRootPackageJson = await fileExists(resolve(currentDirectory, 'package.json'));
-    if (hasPackagesDirectory && hasRootPackageJson) {
-      return currentDirectory;
-    }
-
-    const parentDirectory = dirname(currentDirectory);
-    if (parentDirectory === currentDirectory) {
-      return startDirectory;
-    }
-    currentDirectory = parentDirectory;
-  }
-}
-
-async function getWorkspacePackageDirectoryByName(
-  workspaceRoot: string,
-  packageName: string,
-): Promise<string | undefined> {
-  const packagesDirectory = resolve(workspaceRoot, 'packages');
-  if (!(await fileExists(packagesDirectory))) {
-    return undefined;
-  }
-
-  const packageJsonFiles = await collectFilesRecursively(
-    packagesDirectory,
-    (fileName) => fileName === 'package.json',
-  );
-  for (const packageJsonPath of packageJsonFiles) {
-    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as Record<string, unknown>;
-    if (packageJson.name === packageName) {
-      return dirname(packageJsonPath);
-    }
-  }
-
-  return undefined;
-}
-
-async function enrichFromWorkspaceWildcardExports(
-  cwd: string,
-  state: TypeImportState,
-): Promise<void> {
-  const workspaceRoot = await findWorkspaceRoot(cwd);
-  const processedModules = new Set<string>();
-  const modulesToProcess = [...state.wildcardExportModules].filter((moduleSpecifier) =>
-    moduleSpecifier.startsWith('@genesislcap/'),
-  );
-
-  while (modulesToProcess.length) {
-    const moduleSpecifier = modulesToProcess.pop()!;
-    if (processedModules.has(moduleSpecifier)) {
-      continue;
-    }
-    processedModules.add(moduleSpecifier);
-
-    const packageDirectory = await getWorkspacePackageDirectoryByName(workspaceRoot, moduleSpecifier);
-    if (!packageDirectory) {
-      continue;
-    }
-
-    const distDirectory = resolve(packageDirectory, 'dist');
-    if (!(await fileExists(distDirectory))) {
-      continue;
-    }
-
-    const referencedState = createTypeImportState();
-    const { apiJsonFiles, dtsFiles } = await collectTypeMetadataFiles(distDirectory);
-    await parseApiJsonFiles(apiJsonFiles, referencedState);
-    await parseDtsFiles(dtsFiles, referencedState);
-    mergeTypeImportStateInto(state, referencedState);
-
-    for (const exportedModule of referencedState.wildcardExportModules) {
-      if (exportedModule.startsWith('@genesislcap/') && !processedModules.has(exportedModule)) {
-        modulesToProcess.push(exportedModule);
-      }
-    }
-  }
-}
-
-async function buildTypeImportState(cwd: string): Promise<TypeImportState> {
-  const state = createTypeImportState();
-
-  const distDirectory = resolve(cwd, 'dist');
-  if (!(await fileExists(distDirectory))) {
-    return state;
-  }
-
-  const { apiJsonFiles, dtsFiles } = await collectTypeMetadataFiles(distDirectory);
-  await parseApiJsonFiles(apiJsonFiles, state);
-  await parseDtsFiles(dtsFiles, state);
-  await enrichFromWorkspaceWildcardExports(cwd, state);
-
-  return state;
-}
-
-async function ensureReferenceInTypesFile(
-  filePath: string,
-  reactJsxRuntimePath: string,
-): Promise<void> {
-  if (!(await fileExists(filePath))) {
-    return;
-  }
-
-  const relativeReferencePath = relative(dirname(filePath), reactJsxRuntimePath).replace(/\\/g, '/');
-  const normalizedReferencePath = relativeReferencePath.startsWith('.')
-    ? relativeReferencePath
-    : `./${relativeReferencePath}`;
-  const referenceLine = `/// <reference path="${normalizedReferencePath}" />`;
-
-  const existingContent = await readFile(filePath, 'utf8');
-  if (!existingContent.includes(referenceLine)) {
-    await writeFile(filePath, `${referenceLine}\n${existingContent}`, 'utf8');
-  }
-}
-
-
-export async function generateReactJsxTypes(
-  cwd: string,
-): Promise<{ generated: boolean; path?: string; reason?: string }> {
-  const packageJsonPath = resolve(cwd, 'package.json');
-  if (!(await fileExists(packageJsonPath))) {
-    return { generated: false, reason: 'No package.json found.' };
-  }
-
-  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as Record<string, unknown>;
-  const manifestPath = getCEMManifestPath(cwd, packageJson);
-  if (!(await fileExists(manifestPath))) {
-    return { generated: false, reason: 'No custom elements manifest found.' };
-  }
-
-  const manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as CEMManifest;
-  const declarations = collectCustomElements(manifest);
-  if (!declarations.length) {
-    return { generated: false, reason: 'No custom elements discovered in manifest.' };
-  }
-
-  const resolvedDeclarations = await mergeFastInheritanceFromManifest(cwd, declarations);
-
-  const dtsRoot = resolve(cwd, 'dist/dts');
-  const outputPath = resolve(dtsRoot, GENERATED_FILE_NAME);
-  await mkdir(dirname(outputPath), { recursive: true });
-
-  const packageName = typeof packageJson.name === 'string' ? packageJson.name : 'unknown-package';
-  const typeImportState = await buildTypeImportState(cwd);
-  const content = generateDeclarations(packageName, resolvedDeclarations, typeImportState);
-  await writeFile(outputPath, content, 'utf8');
-
-  const candidateTypesPaths = new Set<string>([resolve(cwd, 'dist/dts/index.d.ts')]);
-  if (typeof packageJson.types === 'string' && packageJson.types.endsWith('.d.ts')) {
-    candidateTypesPaths.add(resolve(cwd, packageJson.types));
-  }
-
-  for (const typesPath of candidateTypesPaths) {
-    await ensureReferenceInTypesFile(typesPath, outputPath);
-  }
-
-  return { generated: true, path: outputPath };
-}