@c4a/extract-ts 0.5.41-beta.6 → 0.6.0-alpha.1

package/README.md

@@ -1,6 +1,9 @@
 # @c4a/extract-ts
 
-TypeScript/TSX extraction plugin for C4A. It implements the `ExtractionPlugin` protocol from `@c4a/extract` and is the default plugin used by `context capture --code` for npm-style packages.
+TypeScript/TSX extraction plugin for Context. It implements the
+`ExtractionPlugin` protocol from `@c4a/extract` and is the default plugin used
+by the SDK `extractTs({ source, collection: "wikis" })` phase for npm-style
+packages.
 
 ## Role in the Monorepo
 
@@ -82,7 +85,9 @@ The plugin returns `ExtractionResult` v2. The `@c4a/extract` runner turns that i
 - `edges.jsonl` receives relation rows with package/module/version/hash metadata.
 - `digests.jsonl` receives versioned module digest rows.
 
-`context compile --code` consumes those rows to build package/category/symbol Nodes. The important projection inputs are:
+The Context CLI consumes those rows during `context run extract:<source>:wikis`
+to build review candidates for package/category/symbol knowledge Nodes. The
+important projection inputs are:
 
 - stable package names and versions
 - stable exported symbol names
@@ -92,7 +97,8 @@ The plugin returns `ExtractionResult` v2. The `@c4a/extract` runner turns that i
 - relation `from` / `to` values
 - JSDoc and type/member metadata
 
-Obsidian Render reads compiled Markdown and graph YAML after projection; it does not read `@c4a/extract-ts` output directly.
+Package build reads approved Markdown and generated project metadata after
+review/apply and close; it does not read `@c4a/extract-ts` output directly.
 
 ## Usage
 
@@ -106,7 +112,33 @@ const registry = new ExtractionPluginRegistry();
 registry.register(new TypeScriptPlugin());
 ```
 
-Runner usage normally goes through `context capture --code`; agents should not hand-build runner input or raw snapshots.
+Workspace usage normally goes through a declared project phase:
+
+```ts
+import { defineProject, extractTs, reviewValidity, source } from "@c4a/context";
+
+const componentLib = source("component-lib");
+
+export default defineProject({
+  sources: [componentLib],
+  phases: [
+    extractTs({ source: componentLib, collection: "wikis" }),
+    reviewValidity({ collection: "wikis" }),
+  ],
+  packages: [],
+});
+```
+
+The source boundary is registered first, then the phase is previewed or run:
+
+```bash
+context source add repo component-lib --local ../packages/component-lib
+context run extract:component-lib:wikis --dry-run
+context run extract:component-lib:wikis
+```
+
+Agents should not hand-build runner input or raw snapshots for normal Context
+workspace operation.
 
 ## Internal Modules
 

package/index.js

@@ -6981,7 +6981,7 @@ var require_dist = __commonJS((exports) => {
 
 // ../../node_modules/.bun/web-tree-sitter@0.20.8/node_modules/web-tree-sitter/tree-sitter.js
 var require_tree_sitter = __commonJS((exports, module2) => {
-  var __dirname = "/Users/bytedance/github/c4a/node_modules/.bun/web-tree-sitter@0.20.8/node_modules/web-tree-sitter";
+  var __dirname = "/Users/bytedance/github/c4a/context/node_modules/.bun/web-tree-sitter@0.20.8/node_modules/web-tree-sitter";
   var Module = Module !== undefined ? Module : {};
   var TreeSitter = function() {
     var initPromise, document = typeof window == "object" ? { currentScript: window.document.currentScript } : null;
@@ -13808,7 +13808,9 @@ var symbolInfoSchema = exports_external.lazy(() => exports_external.object({
   implements: exports_external.array(exports_external.string().min(1)).optional(),
   doc: exports_external.string().nullable().optional(),
   propsType: exports_external.string().min(1).nullable().optional(),
-  unionValues: exports_external.array(exports_external.string()).optional()
+  unionValues: exports_external.array(exports_external.string()).optional(),
+  initializer: exports_external.string().min(1).nullable().optional(),
+  signature: exports_external.string().min(1).nullable().optional()
 }));
 var relationInfoSchema = exports_external.object({
   type: relationTypeSchema,
@@ -14298,7 +14300,7 @@ var traceExports = async (entryPath, fs2) => {
   };
 };
 
-// src/symbolExtractor.ts
+// src/symbolExtractorAst.ts
 var DECLARATION_TYPES2 = new Set([
   "function_declaration",
   "class_declaration",
@@ -14368,6 +14370,47 @@ var getReturnType = (node2) => {
   const returnNode = node2.childForFieldName("return_type") ?? node2.namedChildren.find((child) => child.type === "type_annotation") ?? null;
   return extractTypeAnnotation(returnNode);
 };
+var getInitializer = (node2) => node2.childForFieldName("value") ?? node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function" || child.type === "call_expression") ?? null;
+var getCallableFromInitializer = (node2) => {
+  if (!node2)
+    return null;
+  if (node2.type === "arrow_function" || node2.type === "function")
+    return node2;
+  if (node2.type === "call_expression") {
+    return node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function") ?? null;
+  }
+  return null;
+};
+var getInitializerTypeAnnotation = (node2) => {
+  if (!node2 || node2.type !== "call_expression")
+    return null;
+  const typeArguments = node2.namedChildren.find((child) => child.type === "type_arguments") ?? null;
+  if (!typeArguments)
+    return null;
+  const callee = node2.namedChildren.find((child) => child.type !== "type_arguments" && child.type !== "arguments") ?? null;
+  const calleeText = callee?.text?.trim();
+  return calleeText ? `${calleeText}${typeArguments.text}` : typeArguments.text;
+};
+var getInitializerText = (node2, options = {}) => {
+  if (!node2)
+    return null;
+  if ((node2.type === "arrow_function" || node2.type === "function") && !options.includeCallable)
+    return null;
+  const text = node2.text.trim();
+  if ((node2.type === "arrow_function" || node2.type === "function") && text.length > 600)
+    return null;
+  return text.length > 0 ? text : null;
+};
+var inferReturnType = (node2) => {
+  if (!node2)
+    return null;
+  return containsJsx(node2) ? "JSX.Element" : null;
+};
+var containsJsx = (node2) => {
+  if (node2.type.startsWith("jsx_"))
+    return true;
+  return node2.namedChildren.some(containsJsx);
+};
 var getTypeNames = (typeText) => {
   if (!typeText)
     return [];
@@ -14433,9 +14476,15 @@ var collectMembers = (node2, declarations, importBindings, ownerName, relations)
       appendTypeRelations(relations, "of_type" /* OfType */, ownerName, typeAnnotation, importBindings, declarations, getLine(child));
       continue;
     }
+    const indexMember = indexSignatureMember(child);
+    if (indexMember) {
+      members.push(indexMember.info);
+      appendTypeRelations(relations, "of_type" /* OfType */, ownerName, indexMember.typeAnnotation, importBindings, declarations, getLine(child));
+      continue;
+    }
     if (child.type === "method_definition" || child.type === "method_signature") {
       const nameNode = child.childForFieldName("name") ?? child.namedChildren.find((candidate) => candidate.type === "property_identifier" || candidate.type === "identifier");
-      if (!nameNode || nameNode.text === "constructor")
+      if (!nameNode)
         continue;
       const paramsNode = child.childForFieldName("parameters") ?? child.namedChildren.find((candidate) => candidate.type === "formal_parameters") ?? null;
       const params = collectParams(paramsNode);
@@ -14460,6 +14509,48 @@ var collectMembers = (node2, declarations, importBindings, ownerName, relations)
   }
   return members.length > 0 ? members : undefined;
 };
+var indexSignatureMember = (node2) => {
+  if (node2.type !== "index_signature")
+    return null;
+  const match = /^\s*(\[[^\]]+\])\s*:?\s*([^;]+)?;?\s*$/u.exec(node2.text);
+  const name = match?.[1]?.trim();
+  const typeAnnotation = match?.[2]?.trim();
+  if (!name)
+    return null;
+  const propDoc = extractJSDoc(node2);
+  return {
+    info: {
+      name,
+      kind: "prop" /* Prop */,
+      visibility: "internal" /* Internal */,
+      file: "",
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...typeAnnotation ? { typeAnnotation } : {},
+      ...propDoc ? { doc: propDoc } : {}
+    },
+    typeAnnotation
+  };
+};
+var collectEnumValues = (node2) => {
+  const body2 = node2.namedChildren.find((child) => child.type === "enum_body") ?? null;
+  if (!body2)
+    return;
+  const values = [];
+  for (const member of body2.namedChildren.filter((child) => child.type === "enum_assignment" || child.type === "property_identifier")) {
+    if (member.type === "property_identifier") {
+      values.push(member.text);
+      continue;
+    }
+    const name = member.childForFieldName("name")?.text ?? member.namedChildren[0]?.text;
+    if (!name)
+      continue;
+    const valueNode = member.childForFieldName("value") ?? member.namedChildren.find((child) => child !== member.childForFieldName("name")) ?? null;
+    const rawValue = valueNode?.text.replace(/^['"]|['"]$/gu, "");
+    values.push(rawValue ? `${name} = ${rawValue}` : name);
+  }
+  return values.length > 0 ? values : undefined;
+};
 var extractUnionLiteralValues = (typeNode) => {
   if (!typeNode)
     return;
@@ -14500,152 +14591,197 @@ var findObjectTypeNodes = (node2) => {
   }
   return [];
 };
+
+// src/symbolExtractorAnalyze.ts
 var analyzeDeclaration = (node2, filePath, declarations, importBindings, relations) => {
   if (node2.type === "lexical_declaration") {
-    for (const declarator of node2.namedChildren.filter((child) => child.type === "variable_declarator")) {
-      const nameNode2 = declarator.childForFieldName("name") ?? declarator.namedChildren[0];
-      if (!nameNode2)
-        continue;
-      const typeNode = declarator.childForFieldName("type") ?? declarator.namedChildren.find((child) => child.type === "type_annotation") ?? null;
-      const typeAnnotation = extractTypeAnnotation(typeNode);
-      const varDoc = extractJSDoc(node2);
-      declarations.set(nameNode2.text, {
-        info: {
-          name: nameNode2.text,
-          kind: classifyVariable(nameNode2.text, filePath),
-          visibility: "internal" /* Internal */,
-          file: filePath,
-          line: getLine(declarator),
-          endLine: getEndLine(declarator),
-          ...typeAnnotation ? { typeAnnotation } : {},
-          ...varDoc ? { doc: varDoc } : {}
-        }
-      });
-      appendTypeRelations(relations, "of_type" /* OfType */, nameNode2.text, typeAnnotation, importBindings, declarations, getLine(declarator));
-    }
+    analyzeLexicalDeclaration(node2, filePath, declarations, importBindings, relations);
     return;
   }
-  const nameNode = node2.childForFieldName("name") ?? node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
-  const name = getNameNodeText(nameNode);
-  if (!name)
+  const named = getNamedDeclaration(node2);
+  if (!named)
     return;
+  const { name } = named;
   if (node2.type === "function_declaration") {
-    const paramsNode = node2.childForFieldName("parameters") ?? node2.namedChildren.find((child) => child.type === "formal_parameters") ?? null;
-    const params = collectParams(paramsNode);
-    const returnType = getReturnType(node2);
-    const funcDoc = extractJSDoc(node2);
-    declarations.set(name, {
-      info: {
-        name,
-        kind: "function" /* Function */,
-        visibility: "internal" /* Internal */,
-        file: filePath,
-        line: getLine(node2),
-        endLine: getEndLine(node2),
-        ...params.length > 0 ? { params } : {},
-        ...returnType ? { returnType } : {},
-        ...funcDoc ? { doc: funcDoc } : {}
-      }
-    });
-    for (const param of params) {
-      appendTypeRelations(relations, "param_type" /* ParamType */, name, param.type, importBindings, declarations, getLine(node2));
-    }
-    appendTypeRelations(relations, "return_type" /* ReturnType */, name, returnType, importBindings, declarations, getLine(node2));
+    analyzeFunctionDeclaration(node2, name, filePath, declarations, importBindings, relations);
     return;
   }
   const symbolDoc = extractJSDoc(node2);
   if (node2.type === "class_declaration") {
-    const heritage = node2.namedChildren.find((child) => child.type === "class_heritage") ?? null;
-    const extendsClause = heritage?.namedChildren.find((child) => child.type === "extends_clause") ?? null;
-    const implementsClause = heritage?.namedChildren.find((child) => child.type === "implements_clause") ?? null;
-    const extendsValue = extendsClause?.namedChildren[0]?.text ?? null;
-    const implementsValues = implementsClause?.namedChildren.map((child) => child.text) ?? [];
-    const body2 = node2.namedChildren.find((child) => child.type === "class_body") ?? null;
-    const members = collectMembers(body2, declarations, importBindings, name, relations);
-    declarations.set(name, {
-      info: {
-        name,
-        kind: "class" /* Class */,
-        visibility: "internal" /* Internal */,
-        file: filePath,
-        line: getLine(node2),
-        endLine: getEndLine(node2),
-        ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
-        ...extendsValue ? { extends: extendsValue } : {},
-        ...implementsValues.length > 0 ? { implements: implementsValues } : {},
-        ...symbolDoc ? { doc: symbolDoc } : {}
-      }
-    });
-    if (extendsValue) {
-      relations.push(createRelation("extends" /* Extends */, name, extendsValue, resolveTypeBinding(extendsValue, importBindings, declarations), getLine(node2)));
-    }
-    for (const item of implementsValues) {
-      relations.push(createRelation("implements" /* Implements */, name, item, resolveTypeBinding(item, importBindings, declarations), getLine(node2)));
-    }
+    analyzeClassDeclaration(node2, name, symbolDoc, filePath, declarations, importBindings, relations);
     return;
   }
   if (node2.type === "interface_declaration") {
-    const body2 = node2.namedChildren.find((child) => child.type === "interface_body") ?? null;
-    const members = collectMembers(body2, declarations, importBindings, name, relations);
-    declarations.set(name, {
-      info: {
-        name,
-        kind: "interface" /* Interface */,
-        visibility: "internal" /* Internal */,
-        file: filePath,
-        line: getLine(node2),
-        endLine: getEndLine(node2),
-        ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
-        ...symbolDoc ? { doc: symbolDoc } : {}
-      }
-    });
+    analyzeInterfaceDeclaration(node2, name, symbolDoc, filePath, declarations, importBindings, relations);
     return;
   }
   if (node2.type === "type_alias_declaration") {
-    const typeNode = node2.childForFieldName("value") ?? node2.namedChildren.find((c) => c.type !== "type_identifier" && c.type !== "type_parameters") ?? null;
-    const typeAnnotation = typeNode?.text ?? null;
-    const objectTypeNodes = findObjectTypeNodes(typeNode);
-    let members;
-    if (objectTypeNodes.length > 0) {
-      const allMembers = [];
-      for (const objNode of objectTypeNodes) {
-        const m = collectMembers(objNode, declarations, importBindings, name, relations);
-        if (m)
-          allMembers.push(...m);
-      }
-      members = allMembers.length > 0 ? allMembers : undefined;
-    }
-    const unionValues = extractUnionLiteralValues(typeNode);
-    declarations.set(name, {
-      info: {
-        name,
-        kind: "type" /* Type */,
-        visibility: "internal" /* Internal */,
-        file: filePath,
-        line: getLine(node2),
-        endLine: getEndLine(node2),
-        ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
-        ...unionValues ? { unionValues } : {},
-        ...typeAnnotation && !unionValues ? { typeAnnotation } : {},
-        ...symbolDoc ? { doc: symbolDoc } : {}
-      }
-    });
-    appendTypeRelations(relations, "of_type" /* OfType */, name, typeAnnotation, importBindings, declarations, getLine(node2));
+    analyzeTypeAliasDeclaration(node2, name, symbolDoc, filePath, declarations, importBindings, relations);
     return;
   }
   if (node2.type === "enum_declaration") {
-    declarations.set(name, {
+    analyzeEnumDeclaration(node2, name, symbolDoc, filePath, declarations);
+  }
+};
+var getNamedDeclaration = (node2) => {
+  const nameNode = node2.childForFieldName("name") ?? node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
+  const name = getNameNodeText(nameNode);
+  return name ? { name } : null;
+};
+var analyzeLexicalDeclaration = (node2, filePath, declarations, importBindings, relations) => {
+  for (const declarator of node2.namedChildren.filter((child) => child.type === "variable_declarator")) {
+    const nameNode = declarator.childForFieldName("name") ?? declarator.namedChildren[0];
+    if (!nameNode)
+      continue;
+    const typeNode = declarator.childForFieldName("type") ?? declarator.namedChildren.find((child) => child.type === "type_annotation") ?? null;
+    const initializer = getInitializer(declarator);
+    const callable = getCallableFromInitializer(initializer);
+    const paramsNode = callable?.childForFieldName("parameters") ?? callable?.namedChildren.find((child) => child.type === "formal_parameters") ?? null;
+    const params = collectParams(paramsNode);
+    const returnType = callable ? getReturnType(callable) ?? inferReturnType(callable) : null;
+    const initializerTypeAnnotation = getInitializerTypeAnnotation(initializer);
+    const typeAnnotation = extractTypeAnnotation(typeNode) ?? initializerTypeAnnotation;
+    const initializerText = getInitializerText(initializer, {
+      includeCallable: params.length === 0 && !returnType && !typeAnnotation
+    });
+    const varDoc = extractJSDoc(node2);
+    declarations.set(nameNode.text, {
       info: {
-        name,
-        kind: "enum" /* Enum */,
+        name: nameNode.text,
+        kind: classifyVariable(nameNode.text, filePath),
         visibility: "internal" /* Internal */,
         file: filePath,
-        line: getLine(node2),
-        endLine: getEndLine(node2),
-        ...symbolDoc ? { doc: symbolDoc } : {}
+        line: getLine(declarator),
+        endLine: getEndLine(declarator),
+        ...typeAnnotation ? { typeAnnotation } : {},
+        ...params.length > 0 ? { params } : {},
+        ...returnType ? { returnType } : {},
+        ...initializerText ? { initializer: initializerText } : {},
+        ...varDoc ? { doc: varDoc } : {}
       }
     });
+    for (const param of params) {
+      appendTypeRelations(relations, "param_type" /* ParamType */, nameNode.text, param.type, importBindings, declarations, getLine(declarator));
+    }
+    appendTypeRelations(relations, "return_type" /* ReturnType */, nameNode.text, returnType, importBindings, declarations, getLine(declarator));
+    appendTypeRelations(relations, "of_type" /* OfType */, nameNode.text, typeAnnotation, importBindings, declarations, getLine(declarator));
+  }
+};
+var analyzeFunctionDeclaration = (node2, name, filePath, declarations, importBindings, relations) => {
+  const paramsNode = node2.childForFieldName("parameters") ?? node2.namedChildren.find((child) => child.type === "formal_parameters") ?? null;
+  const params = collectParams(paramsNode);
+  const returnType = getReturnType(node2);
+  const funcDoc = extractJSDoc(node2);
+  const signature = `${name}(${params.map((param) => `${param.name}${param.type ? `: ${param.type}` : ""}`).join(", ")})`;
+  declarations.set(name, {
+    info: {
+      name,
+      kind: "function" /* Function */,
+      visibility: "internal" /* Internal */,
+      file: filePath,
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      signature,
+      ...params.length > 0 ? { params } : {},
+      ...returnType ? { returnType } : {},
+      ...funcDoc ? { doc: funcDoc } : {}
+    }
+  });
+  for (const param of params) {
+    appendTypeRelations(relations, "param_type" /* ParamType */, name, param.type, importBindings, declarations, getLine(node2));
+  }
+  appendTypeRelations(relations, "return_type" /* ReturnType */, name, returnType, importBindings, declarations, getLine(node2));
+};
+var analyzeClassDeclaration = (node2, name, symbolDoc, filePath, declarations, importBindings, relations) => {
+  const heritage = node2.namedChildren.find((child) => child.type === "class_heritage") ?? null;
+  const extendsClause = heritage?.namedChildren.find((child) => child.type === "extends_clause") ?? null;
+  const implementsClause = heritage?.namedChildren.find((child) => child.type === "implements_clause") ?? null;
+  const extendsValue = extendsClause?.namedChildren[0]?.text ?? null;
+  const implementsValues = implementsClause?.namedChildren.map((child) => child.text) ?? [];
+  const body2 = node2.namedChildren.find((child) => child.type === "class_body") ?? null;
+  const members = collectMembers(body2, declarations, importBindings, name, relations);
+  declarations.set(name, {
+    info: {
+      name,
+      kind: "class" /* Class */,
+      visibility: "internal" /* Internal */,
+      file: filePath,
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
+      ...extendsValue ? { extends: extendsValue } : {},
+      ...implementsValues.length > 0 ? { implements: implementsValues } : {},
+      ...symbolDoc ? { doc: symbolDoc } : {}
+    }
+  });
+  if (extendsValue) {
+    relations.push(createRelation("extends" /* Extends */, name, extendsValue, resolveTypeBinding(extendsValue, importBindings, declarations), getLine(node2)));
   }
+  for (const item of implementsValues) {
+    relations.push(createRelation("implements" /* Implements */, name, item, resolveTypeBinding(item, importBindings, declarations), getLine(node2)));
+  }
+};
+var analyzeInterfaceDeclaration = (node2, name, symbolDoc, filePath, declarations, importBindings, relations) => {
+  const body2 = node2.namedChildren.find((child) => child.type === "interface_body") ?? null;
+  const members = collectMembers(body2, declarations, importBindings, name, relations);
+  declarations.set(name, {
+    info: {
+      name,
+      kind: "interface" /* Interface */,
+      visibility: "internal" /* Internal */,
+      file: filePath,
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
+      ...symbolDoc ? { doc: symbolDoc } : {}
+    }
+  });
+};
+var analyzeTypeAliasDeclaration = (node2, name, symbolDoc, filePath, declarations, importBindings, relations) => {
+  const typeNode = node2.childForFieldName("value") ?? node2.namedChildren.find((c) => c.type !== "type_identifier" && c.type !== "type_parameters") ?? null;
+  const typeAnnotation = typeNode?.text ?? null;
+  const objectTypeNodes = findObjectTypeNodes(typeNode);
+  let members;
+  if (objectTypeNodes.length > 0) {
+    const allMembers = [];
+    for (const objNode of objectTypeNodes) {
+      const extractedMembers = collectMembers(objNode, declarations, importBindings, name, relations);
+      if (extractedMembers)
+        allMembers.push(...extractedMembers);
+    }
+    members = allMembers.length > 0 ? allMembers : undefined;
+  }
+  const unionValues = extractUnionLiteralValues(typeNode);
+  declarations.set(name, {
+    info: {
+      name,
+      kind: "type" /* Type */,
+      visibility: "internal" /* Internal */,
+      file: filePath,
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...members ? { members: members.map((member) => ({ ...member, file: filePath })) } : {},
+      ...unionValues ? { unionValues } : {},
+      ...typeAnnotation && !unionValues ? { typeAnnotation } : {},
+      ...symbolDoc ? { doc: symbolDoc } : {}
+    }
+  });
+  appendTypeRelations(relations, "of_type" /* OfType */, name, typeAnnotation, importBindings, declarations, getLine(node2));
+};
+var analyzeEnumDeclaration = (node2, name, symbolDoc, filePath, declarations) => {
+  const enumValues = collectEnumValues(node2);
+  declarations.set(name, {
+    info: {
+      name,
+      kind: "enum" /* Enum */,
+      visibility: "internal" /* Internal */,
+      file: filePath,
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...enumValues ? { unionValues: enumValues } : {},
+      ...symbolDoc ? { doc: symbolDoc } : {}
+    }
+  });
 };
 var collectImportBindings2 = (root, relations) => {
   const bindings = new Map;
@@ -14732,6 +14868,8 @@ var analyzeFile = async (filePath, fs2) => {
     lines: countLines(source2)
   };
 };
+
+// src/symbolExtractor.ts
 var extractSymbols = async (entries, fs2, options) => {
   const exportedSymbols = [];
   const internalSymbols = [];
@@ -14790,10 +14928,9 @@ var extractSymbols = async (entries, fs2, options) => {
       continue;
     let propsTypeName;
     if (sym.typeAnnotation) {
-      const match = sym.typeAnnotation.match(/<([A-Z]\w+)(?:\s*,\s*[A-Z]\w+)*\s*>/);
-      if (match?.[1] && typeDeclarations.has(match[1])) {
-        propsTypeName = match[1];
-      }
+      const genericBody = /<(.+)>/u.exec(sym.typeAnnotation)?.[1];
+      const genericNames = genericBody?.match(/\b[A-Z][A-Za-z0-9_]*\b/gu) ?? [];
+      propsTypeName = genericNames.filter((name) => typeDeclarations.has(name)).at(-1);
     }
     if (!propsTypeName) {
       const conventionName = `${sym.name}Props`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/extract-ts",
-  "version": "0.5.41-beta.6",
+  "version": "0.6.0-alpha.1",
   "type": "module",
   "dependencies": {
     "web-tree-sitter": "^0.20.8"