@metamask-previews/messenger-cli 0.1.0-preview-2a71f636e → 0.1.0-preview-212d43f

package/dist/docs/discovery.mjs

@@ -1,41 +0,0 @@
-import { glob } from "glob";
-/**
- * Find all non-test TypeScript source files in a directory.
- * Skips node_modules, dist, test directories, and declaration files.
- *
- * @param dir - The directory to search.
- * @returns A promise that resolves to an array of absolute file paths.
- */
-export async function findTsFiles(dir) {
-    return await glob('**/*.ts', {
-        cwd: dir,
-        absolute: true,
-        ignore: [
-            '**/node_modules/**',
-            '**/dist/**',
-            '**/__tests__/**',
-            '**/tests/**',
-            '**/test/**',
-            '**/__mocks__/**',
-            '**/*.test.ts',
-            '**/*.test-d.ts',
-            '**/*.spec.ts',
-            '**/*.d.ts',
-        ],
-    });
-}
-/**
- * Find all `.d.cts` declaration files in a directory.
- * Skips nested node_modules subdirectories.
- *
- * @param dir - The directory to search.
- * @returns A promise that resolves to an array of absolute file paths.
- */
-export async function findDtsFiles(dir) {
-    return await glob('**/*.d.cts', {
-        cwd: dir,
-        absolute: true,
-        ignore: ['**/node_modules/**'],
-    });
-}
-//# sourceMappingURL=discovery.mjs.map

package/dist/docs/discovery.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"discovery.mjs","sourceRoot":"","sources":["../../src/docs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,aAAa;AAE5B;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,GAAW;IAC3C,OAAO,MAAM,IAAI,CAAC,SAAS,EAAE;QAC3B,GAAG,EAAE,GAAG;QACR,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,oBAAoB;YACpB,YAAY;YACZ,iBAAiB;YACjB,aAAa;YACb,YAAY;YACZ,iBAAiB;YACjB,cAAc;YACd,gBAAgB;YAChB,cAAc;YACd,WAAW;SACZ;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,GAAW;IAC5C,OAAO,MAAM,IAAI,CAAC,YAAY,EAAE;QAC9B,GAAG,EAAE,GAAG;QACR,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,CAAC,oBAAoB,CAAC;KAC/B,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { glob } from 'glob';\n\n/**\n * Find all non-test TypeScript source files in a directory.\n * Skips node_modules, dist, test directories, and declaration files.\n *\n * @param dir - The directory to search.\n * @returns A promise that resolves to an array of absolute file paths.\n */\nexport async function findTsFiles(dir: string): Promise<string[]> {\n  return await glob('**/*.ts', {\n    cwd: dir,\n    absolute: true,\n    ignore: [\n      '**/node_modules/**',\n      '**/dist/**',\n      '**/__tests__/**',\n      '**/tests/**',\n      '**/test/**',\n      '**/__mocks__/**',\n      '**/*.test.ts',\n      '**/*.test-d.ts',\n      '**/*.spec.ts',\n      '**/*.d.ts',\n    ],\n  });\n}\n\n/**\n * Find all `.d.cts` declaration files in a directory.\n * Skips nested node_modules subdirectories.\n *\n * @param dir - The directory to search.\n * @returns A promise that resolves to an array of absolute file paths.\n */\nexport async function findDtsFiles(dir: string): Promise<string[]> {\n  return await glob('**/*.d.cts', {\n    cwd: dir,\n    absolute: true,\n    ignore: ['**/node_modules/**'],\n  });\n}\n"]}

package/dist/docs/extraction.cjs

@@ -1,580 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFromFile = void 0;
-const node_1 = require("@metamask/utils/node");
-const fs = __importStar(require("node:fs/promises"));
-const path = __importStar(require("node:path"));
-const typescript_1 = require("typescript");
-/**
- * Extract string constants from top-level variable declarations in a source file.
- * Only looks at top-level `const x = 'string'` or `const x = 'string' as const`.
- *
- * @param sourceFile - The TypeScript source file to extract constants from.
- * @returns A map of constant name to string value.
- */
-function extractStringConstants(sourceFile) {
-    const names = new Map();
-    for (const statement of sourceFile.statements) {
-        if (!(0, typescript_1.isVariableStatement)(statement)) {
-            continue;
-        }
-        for (const decl of statement.declarationList.declarations) {
-            if (!(0, typescript_1.isIdentifier)(decl.name)) {
-                continue;
-            }
-            if (decl.initializer) {
-                const init = decl.initializer;
-                if ((0, typescript_1.isStringLiteral)(init)) {
-                    names.set(decl.name.text, init.text);
-                }
-                else if ((0, typescript_1.isAsExpression)(init) && (0, typescript_1.isStringLiteral)(init.expression)) {
-                    names.set(decl.name.text, init.expression.text);
-                }
-            }
-            // Handle `declare const x: "value"` (common in .d.cts files)
-            if (!decl.initializer &&
-                decl.type &&
-                (0, typescript_1.isLiteralTypeNode)(decl.type) &&
-                (0, typescript_1.isStringLiteral)(decl.type.literal)) {
-                names.set(decl.name.text, decl.type.literal.text);
-            }
-        }
-    }
-    return names;
-}
-/**
- * Resolve the value of `controllerName` (or similar constant) defined in the
- * same file or imported from a local `./constants*` module (single-hop only).
- *
- * @param sourceFile - The TypeScript source file to search.
- * @param filePath - The absolute path of the source file on disk.
- * @returns A promise that resolves to a map of constant name to resolved string value.
- */
-async function resolveControllerName(sourceFile, filePath) {
-    const names = extractStringConstants(sourceFile);
-    // Chase single-hop local imports (no further recursion):
-    //   import { BRIDGE_CONTROLLER_NAME } from './constants/bridge';
-    for (const statement of sourceFile.statements) {
-        if (!(0, typescript_1.isImportDeclaration)(statement) ||
-            !statement.moduleSpecifier ||
-            !(0, typescript_1.isStringLiteral)(statement.moduleSpecifier)) {
-            continue;
-        }
-        const spec = statement.moduleSpecifier.text;
-        if (!spec.startsWith('.')) {
-            continue;
-        }
-        const dir = path.dirname(filePath);
-        const isDts = filePath.endsWith('.d.cts') || filePath.endsWith('.d.ts');
-        // Strip .cjs/.js extension from specifier for .d.cts resolution
-        const bareSpec = spec.replace(/\.(c|m)?js$/u, '');
-        const candidates = isDts
-            ? [
-                path.join(dir, `${bareSpec}.d.cts`),
-                path.join(dir, bareSpec, 'index.d.cts'),
-                path.join(dir, `${bareSpec}.d.ts`),
-                path.join(dir, bareSpec, 'index.d.ts'),
-            ]
-            : [path.join(dir, `${spec}.ts`), path.join(dir, spec, 'index.ts')];
-        for (const candidate of candidates) {
-            if (!(await (0, node_1.fileExists)(candidate))) {
-                continue;
-            }
-            const content = await fs.readFile(candidate, 'utf8');
-            const sf = (0, typescript_1.createSourceFile)(candidate, content, typescript_1.ScriptTarget.Latest, true);
-            // Only extract constants — do NOT follow further imports
-            const imported = extractStringConstants(sf);
-            if (statement.importClause?.namedBindings &&
-                (0, typescript_1.isNamedImports)(statement.importClause.namedBindings)) {
-                for (const element of statement.importClause.namedBindings.elements) {
-                    const importedName = (element.propertyName ?? element.name).text;
-                    const localName = element.name.text;
-                    const value = imported.get(importedName);
-                    if (value !== undefined) {
-                        names.set(localName, value);
-                    }
-                }
-            }
-            break;
-        }
-    }
-    return names;
-}
-/**
- * Resolve a template-literal or string-literal `type` property to its string
- * value. Returns null if unresolvable.
- *
- * @param node - The expression node to resolve.
- * @param constants - A map of known constant names to their string values.
- * @returns The resolved string value, or null if unresolvable.
- */
-function resolveTypeString(node, constants) {
-    if ((0, typescript_1.isStringLiteral)(node) || (0, typescript_1.isNoSubstitutionTemplateLiteral)(node)) {
-        return node.text;
-    }
-    if ((0, typescript_1.isTemplateExpression)(node)) {
-        let result = node.head.text;
-        for (const span of node.templateSpans) {
-            // typeof X  →  resolve X
-            if ((0, typescript_1.isTypeOfExpression)(span.expression)) {
-                if ((0, typescript_1.isIdentifier)(span.expression.expression)) {
-                    const val = constants.get(span.expression.expression.text);
-                    if (val === undefined) {
-                        return null;
-                    }
-                    result += val;
-                }
-                else {
-                    return null;
-                }
-            }
-            else if ((0, typescript_1.isIdentifier)(span.expression)) {
-                const val = constants.get(span.expression.text);
-                if (val === undefined) {
-                    return null;
-                }
-                result += val;
-            }
-            else {
-                return null;
-            }
-            result += span.literal.text;
-        }
-        return result;
-    }
-    return null;
-}
-/**
- * Resolve a TemplateLiteralTypeNode (used in type positions like
- * `type: \`${typeof controllerName}:name\``) to its string value.
- *
- * @param node - The template literal type node to resolve.
- * @param constants - A map of known constant names to their string values.
- * @returns The resolved string value, or null if unresolvable.
- */
-function resolveTemplateLiteralType(node, constants) {
-    let result = node.head.text;
-    for (const span of node.templateSpans) {
-        // In type position, `typeof X` is a TypeQueryNode
-        if ((0, typescript_1.isTypeQueryNode)(span.type) && (0, typescript_1.isIdentifier)(span.type.exprName)) {
-            const val = constants.get(span.type.exprName.text);
-            if (val === undefined) {
-                return null;
-            }
-            result += val;
-        }
-        else if ((0, typescript_1.isLiteralTypeNode)(span.type) &&
-            (0, typescript_1.isStringLiteral)(span.type.literal)) {
-            result += span.type.literal.text;
-        }
-        else {
-            return null;
-        }
-        result += span.literal.text;
-    }
-    return result;
-}
-/**
- * Extract cleaned JSDoc body text from a node.
- *
- * @param node - The AST node to extract JSDoc from.
- * @param sourceFile - The source file containing the node.
- * @returns The cleaned JSDoc text, or empty string if none.
- */
-function extractJsDocText(node, sourceFile) {
-    const jsDocs = (0, typescript_1.getJSDocCommentsAndTags)(node);
-    if (jsDocs.length === 0) {
-        return '';
-    }
-    const jsDoc = jsDocs[0];
-    if (!(0, typescript_1.isJSDoc)(jsDoc)) {
-        return '';
-    }
-    const fullText = sourceFile.getFullText();
-    const raw = fullText.substring(jsDoc.getFullStart(), jsDoc.getEnd()).trim();
-    // Handle single-line JSDoc: /** Gets the current state. */
-    const singleLineMatch = raw.match(/^\/\*\*\s*(.*?)\s*\*\/$/u);
-    if (singleLineMatch) {
-        let text = singleLineMatch[1].replace(/^\*\s*/u, '');
-        // Apply same escaping as multi-line path
-        text = text.replace(/\{@link\s+([^}]+)\}/gu, '`$1`');
-        text = text.replace(/`[^`]*`|(\{)|(\})/gu, (match, open, close) => {
-            if (open) {
-                return '\\{';
-            }
-            if (close) {
-                return '\\}';
-            }
-            return match;
-        });
-        return text || '';
-    }
-    // Strip comment delimiters, leading asterisks, and @param/@returns/@see tags
-    const lines = raw.split('\n');
-    const cleaned = [];
-    const skippedTags = [
-        '@param',
-        '@returns',
-        '@see',
-        '@throws',
-        '@template',
-        '@example',
-    ];
-    let currentTag = null;
-    let deprecatedParts = [];
-    for (const rawLine of lines) {
-        let trimmed = rawLine.trim();
-        if (trimmed === '/**' || trimmed === '*/') {
-            continue;
-        }
-        if (trimmed.startsWith('* ')) {
-            trimmed = trimmed.slice(2);
-        }
-        else if (trimmed === '*') {
-            trimmed = '';
-        }
-        else if (trimmed.startsWith('*')) {
-            trimmed = trimmed.slice(1);
-        }
-        // Check if this line starts a new tag
-        if (trimmed.startsWith('@')) {
-            // Flush any accumulated deprecated text
-            if (currentTag === 'deprecated' && deprecatedParts.length > 0) {
-                cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
-                deprecatedParts = [];
-            }
-            if (trimmed.startsWith('@deprecated')) {
-                currentTag = 'deprecated';
-                const depText = trimmed.slice('@deprecated'.length).trim();
-                if (depText) {
-                    deprecatedParts.push(depText);
-                }
-                continue;
-            }
-            currentTag = skippedTags.some((tag) => trimmed.startsWith(tag))
-                ? 'skip'
-                : null;
-            if (currentTag === 'skip') {
-                continue;
-            }
-        }
-        else if (currentTag === 'skip') {
-            if (trimmed === '') {
-                currentTag = null;
-            }
-            else {
-                continue;
-            }
-        }
-        else if (currentTag === 'deprecated') {
-            if (trimmed === '') {
-                // End of deprecated tag
-                if (deprecatedParts.length > 0) {
-                    cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
-                    deprecatedParts = [];
-                }
-                currentTag = null;
-            }
-            else {
-                deprecatedParts.push(trimmed);
-                continue;
-            }
-        }
-        cleaned.push(trimmed);
-    }
-    // Flush any remaining deprecated text
-    if (deprecatedParts.length > 0) {
-        cleaned.push(`**Deprecated:** ${deprecatedParts.join(' ')}`);
-    }
-    let result = cleaned.join('\n').trim();
-    // Convert JSDoc {@link X} references to markdown backtick code
-    result = result.replace(/\{@link\s+([^}]+)\}/gu, '`$1`');
-    // Escape remaining curly braces for MDX safety (but not inside backtick code spans)
-    result = result.replace(/`[^`]*`|(\{)|(\})/gu, (match, open, close) => {
-        if (open) {
-            return '\\{';
-        }
-        if (close) {
-            return '\\}';
-        }
-        return match; // preserve content inside backticks
-    });
-    return result;
-}
-/**
- * Check whether a node has an `@deprecated` JSDoc tag.
- *
- * @param node - The AST node to check.
- * @returns True if the node has an `@deprecated` tag.
- */
-function isDeprecated(node) {
-    const tags = (0, typescript_1.getJSDocTags)(node);
-    return tags.some((tag) => tag.tagName.text === 'deprecated');
-}
-/**
- * Collect method info from all class declarations in a source file.
- * Returns a map keyed by "ClassName.methodName".
- *
- * @param sourceFile - The TypeScript source file to scan.
- * @returns A map of "ClassName.methodName" to method info.
- */
-function collectClassMethods(sourceFile) {
-    const methods = new Map();
-    for (const statement of sourceFile.statements) {
-        if (!(0, typescript_1.isClassDeclaration)(statement) || !statement.name) {
-            continue;
-        }
-        const className = statement.name.text;
-        for (const member of statement.members) {
-            if (!(0, typescript_1.isMethodDeclaration)(member) ||
-                !member.name ||
-                !(0, typescript_1.isIdentifier)(member.name)) {
-                continue;
-            }
-            const methodName = member.name.text;
-            // Build parameter list
-            const params = member.parameters
-                .map((param) => {
-                const paramName = param.name.getText(sourceFile);
-                const optional = param.questionToken ? '?' : '';
-                const paramType = param.type
-                    ? param.type.getText(sourceFile)
-                    : 'unknown';
-                return `${paramName}${optional}: ${paramType}`;
-            })
-                .join(', ');
-            // Get return type
-            const returnType = member.type ? member.type.getText(sourceFile) : 'void';
-            // For async methods, the declared return type already includes Promise<>,
-            // so we don't need to wrap again.
-            const methodSignature = `(${params}) => ${returnType}`;
-            const jsDoc = extractJsDocText(member, sourceFile);
-            methods.set(`${className}.${methodName}`, {
-                jsDoc,
-                signature: methodSignature,
-            });
-        }
-    }
-    return methods;
-}
-/**
- * If `handlerText` matches `ClassName['methodName']`, look it up in classMethodInfo
- * and return the resolved signature. Otherwise return the original text.
- *
- * @param handlerText - The raw handler text to resolve.
- * @param classMethods - A map of class methods collected from the source file.
- * @returns An object with the resolved signature and any associated JSDoc.
- */
-function resolveHandler(handlerText, classMethods) {
-    const match = handlerText.match(/^(\w+)\['(\w+)'\]$/u);
-    if (match) {
-        const key = `${match[1]}.${match[2]}`;
-        const info = classMethods.get(key);
-        if (info) {
-            return { signature: info.signature, methodJsDoc: info.jsDoc };
-        }
-    }
-    return { signature: handlerText, methodJsDoc: '' };
-}
-/**
- * Get the raw source text for a property value inside a type literal.
- *
- * @param members - The type literal members to search.
- * @param propName - The property name to find.
- * @param sourceFile - The source file for getText calls.
- * @returns The raw text of the property type, or empty string if not found.
- */
-function getPropertyText(members, propName, sourceFile) {
-    for (const member of members) {
-        if ((0, typescript_1.isPropertySignature)(member) &&
-            member.name &&
-            (0, typescript_1.isIdentifier)(member.name) &&
-            member.name.text === propName &&
-            member.type) {
-            return member.type.getText(sourceFile).trim();
-        }
-    }
-    return '';
-}
-// ---------------------------------------------------------------------------
-// Main extraction
-// ---------------------------------------------------------------------------
-/**
- * Extract messenger action/event type definitions from a single TypeScript file.
- *
- * @param filePath - The absolute path to the TypeScript file.
- * @param relBase - Base path for computing relative source paths.
- * @returns A promise that resolves to an array of extracted messenger item docs.
- */
-async function extractFromFile(filePath, relBase) {
-    const content = await fs.readFile(filePath, 'utf8');
-    const sourceFile = (0, typescript_1.createSourceFile)(filePath, content, typescript_1.ScriptTarget.Latest, true);
-    const constants = await resolveControllerName(sourceFile, filePath);
-    const classMethods = collectClassMethods(sourceFile);
-    const items = [];
-    const relPath = path.relative(relBase, filePath);
-    // Type aliases and interfaces are always top-level statements
-    for (const statement of sourceFile.statements) {
-        // ---------------------------------------------------------------
-        // Pattern 1: { type: '...'; handler/payload: ... }
-        // Matches both:
-        //   type X = { type: '...'; handler: ... }   (type alias with literal body)
-        //   interface X { type: '...'; handler: ... } (interface declaration)
-        // ---------------------------------------------------------------
-        let inlineNode;
-        let inlineMembers;
-        if ((0, typescript_1.isTypeAliasDeclaration)(statement) &&
-            (0, typescript_1.isTypeLiteralNode)(statement.type)) {
-            inlineNode = statement;
-            inlineMembers = statement.type.members;
-        }
-        else if ((0, typescript_1.isInterfaceDeclaration)(statement)) {
-            inlineNode = statement;
-            inlineMembers = statement.members;
-        }
-        if (inlineNode && inlineMembers) {
-            const typeName = inlineNode.name.text;
-            const line = sourceFile.getLineAndCharacterOfPosition(inlineNode.getStart()).line +
-                1;
-            // Find `type` property
-            let typeString = null;
-            for (const member of inlineMembers) {
-                if ((0, typescript_1.isPropertySignature)(member) &&
-                    member.name &&
-                    (0, typescript_1.isIdentifier)(member.name) &&
-                    member.name.text === 'type' &&
-                    member.type) {
-                    if ((0, typescript_1.isLiteralTypeNode)(member.type)) {
-                        typeString = resolveTypeString(member.type.literal, constants);
-                    }
-                    else if ((0, typescript_1.isTemplateLiteralTypeNode)(member.type)) {
-                        typeString = resolveTemplateLiteralType(member.type, constants);
-                    }
-                }
-            }
-            if (typeString?.includes(':')) {
-                const handlerText = getPropertyText(inlineMembers, 'handler', sourceFile);
-                const payloadText = getPropertyText(inlineMembers, 'payload', sourceFile);
-                if (handlerText || payloadText) {
-                    const kind = handlerText ? 'action' : 'event';
-                    // For actions, resolve ClassName['methodName'] to actual signature + JSDoc
-                    let resolvedHandler = handlerText || payloadText;
-                    let typeAliasJsDoc = extractJsDocText(inlineNode, sourceFile);
-                    if (handlerText) {
-                        const resolved = resolveHandler(handlerText, classMethods);
-                        resolvedHandler = resolved.signature;
-                        // If the type alias has no JSDoc, use the method's JSDoc
-                        if (!typeAliasJsDoc && resolved.methodJsDoc) {
-                            typeAliasJsDoc = resolved.methodJsDoc;
-                        }
-                    }
-                    items.push({
-                        typeName,
-                        typeString,
-                        kind,
-                        jsDoc: typeAliasJsDoc,
-                        handlerOrPayload: resolvedHandler,
-                        sourceFile: relPath,
-                        line,
-                        deprecated: isDeprecated(inlineNode),
-                    });
-                }
-            }
-        }
-        // -------------------------------------------------------------------
-        // Patterns 2 & 3 only apply to type aliases (generic type references)
-        // -------------------------------------------------------------------
-        if (!(0, typescript_1.isTypeAliasDeclaration)(statement)) {
-            continue;
-        }
-        const node = statement;
-        const typeName = node.name.text;
-        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-        // -------------------------------------------------------------------
-        // Pattern 2: ControllerGetStateAction<typeof cn, State>
-        // -------------------------------------------------------------------
-        if ((0, typescript_1.isTypeReferenceNode)(node.type) &&
-            (0, typescript_1.isIdentifier)(node.type.typeName) &&
-            node.type.typeName.text === 'ControllerGetStateAction' &&
-            node.type.typeArguments &&
-            node.type.typeArguments.length >= 2) {
-            const firstArg = node.type.typeArguments[0];
-            const stateArg = node.type.typeArguments[1];
-            let namespace = null;
-            if ((0, typescript_1.isTypeQueryNode)(firstArg) && (0, typescript_1.isIdentifier)(firstArg.exprName)) {
-                namespace = constants.get(firstArg.exprName.text) ?? null;
-            }
-            if ((0, typescript_1.isLiteralTypeNode)(firstArg) && (0, typescript_1.isStringLiteral)(firstArg.literal)) {
-                namespace = firstArg.literal.text;
-            }
-            if (namespace) {
-                items.push({
-                    typeName,
-                    typeString: `${namespace}:getState`,
-                    kind: 'action',
-                    jsDoc: extractJsDocText(node, sourceFile),
-                    handlerOrPayload: `() => ${stateArg.getText(sourceFile)}`,
-                    sourceFile: relPath,
-                    line,
-                    deprecated: isDeprecated(node),
-                });
-            }
-        }
-        // -------------------------------------------------------------------
-        // Pattern 3: ControllerStateChangeEvent<typeof cn, State>
-        // -------------------------------------------------------------------
-        if ((0, typescript_1.isTypeReferenceNode)(node.type) &&
-            (0, typescript_1.isIdentifier)(node.type.typeName) &&
-            node.type.typeName.text === 'ControllerStateChangeEvent' &&
-            node.type.typeArguments &&
-            node.type.typeArguments.length >= 2) {
-            const firstArg = node.type.typeArguments[0];
-            const stateArg = node.type.typeArguments[1];
-            let namespace = null;
-            if ((0, typescript_1.isTypeQueryNode)(firstArg) && (0, typescript_1.isIdentifier)(firstArg.exprName)) {
-                namespace = constants.get(firstArg.exprName.text) ?? null;
-            }
-            if ((0, typescript_1.isLiteralTypeNode)(firstArg) && (0, typescript_1.isStringLiteral)(firstArg.literal)) {
-                namespace = firstArg.literal.text;
-            }
-            if (namespace) {
-                items.push({
-                    typeName,
-                    typeString: `${namespace}:stateChange`,
-                    kind: 'event',
-                    jsDoc: extractJsDocText(node, sourceFile),
-                    handlerOrPayload: `[${stateArg.getText(sourceFile)}, Patch[]]`,
-                    sourceFile: relPath,
-                    line,
-                    deprecated: isDeprecated(node),
-                });
-            }
-        }
-    }
-    return items;
-}
-exports.extractFromFile = extractFromFile;
-//# sourceMappingURL=extraction.cjs.map