@emeryld/manager 1.3.0 → 1.4.0

package/dist/robot/llm-pack.js

@@ -0,0 +1,1226 @@
+EXPORTS: src / robot / cli / prompts.ts;
+-confirmExecution(function () { });
+() => ;
+src / robot / cli / prompts.ts
+    - promptBoolean(function () { });
+(label, fallback) => ;
+src / robot / cli / prompts.ts
+    - promptChoice(function () { });
+(label);
+string, fallback;
+T, options;
+T[];
+Promise;
+src / robot / cli / prompts.ts
+    - promptKinds(function () { });
+(fallback) => ;
+src / robot / cli / prompts.ts
+    - promptList(function () { });
+(label, fallback) => ;
+src / robot / cli / prompts.ts
+    - promptPositiveNumber(function () { });
+(label, fallback) => ;
+src / robot / cli / prompts.ts
+    - promptRobotSettings(function () { });
+(defaults) => ;
+src / robot / cli / prompts.ts
+    - promptRobotSettingsInteractive(function () { });
+(defaults) => ;
+src / robot / cli / prompts.ts
+    - promptRobotSettingsSequential(function () { });
+(defaults) => ;
+src / robot / cli / prompts.ts
+    - promptTokenBudget(function () { });
+(label, fallback) => ;
+src / robot / cli / prompts.ts
+    - READY_PROMPT();
+const ;
+const READY_PROMPT, src;
+/robot/cli / prompts.ts;
+src / robot / cli / settings.ts;
+-formatValue(function () { });
+(value, descriptor, src) => ;
+/robot/cli / settings.ts
+    - parseBooleanInput(function () { });
+(raw) => ;
+src / robot / cli / settings.ts
+    - parseInteractiveValue(function () { });
+(descriptor, buffer) => src;
+/robot/cli / settings.ts
+    - parseKindsInput(function () { });
+(raw) => ;
+src / robot / cli / settings.ts
+    - parsePositiveInteger(function () { });
+(input) => ;
+src / robot / cli / settings.ts
+    - parseStringList(function () { });
+(input) => ;
+src / robot / cli / settings.ts
+    - RobotSettingDescriptor(type - alias);
+src / robot / cli / settings.ts
+    - SETTING_DESCRIPTORS();
+const ;
+const SETTING_DESCRIPTORS, src;
+/robot/cli / settings.ts
+    - validateRobotSettings(function () { });
+(settings) => src;
+/robot/config.ts;
+-coerceBoolean(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceClosure(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceExportMode(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceKinds(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceOptionalNumber(function () { });
+(value) => ;
+src / robot / config.ts
+    - coercePositiveInteger(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coercePositiveNumber(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceStringArray(function () { });
+(value, fallback) => ;
+src / robot / config.ts
+    - coerceVisibility(function () { });
+(value, exportedOnly, fallback) => ;
+src / robot / config.ts
+    - ensureTagPrefix(function () { });
+(tag) => ;
+src / robot / config.ts
+    - loadRobotSettings(function () { });
+() => ;
+src / robot / config.ts
+    - SETTINGS_SECTION();
+const ;
+const SETTINGS_SECTION, src;
+/robot/config.ts
+    - workspaceSettingsPath();
+const ;
+const workspaceSettingsPath, src;
+/robot/config.ts;
+src / robot / coordinator.ts;
+-robotSettingsSummary(function () { });
+(settings) => ;
+src / robot / coordinator.ts
+    - runRobot(function () { });
+() => ;
+src / robot / coordinator.ts;
+src / robot / index.ts;
+-runRobot(function () { });
+() => ;
+src / robot / coordinator.ts;
+src / robot / pack / builder.ts;
+-applyTokenBudget(function () { });
+(pack, settings, registry) => ;
+src / robot / pack / builder.ts
+    - buildClassMemberSignatures(function () { });
+(className, modulePath, declaration, checker) => ;
+src / robot / pack / builder.ts
+    - buildClassMemberSignatureText(function () { });
+(member, checker) => ;
+src / robot / pack / builder.ts
+    - buildClassSignature(function () { });
+(declaration, checker) => ;
+src / robot / pack / builder.ts
+    - buildConstSignature(function () { });
+(symbol, declaration, checker) => ;
+src / robot / pack / builder.ts
+    - buildExemplarCandidates(function () { });
+(symbols, candidates, settings) => src;
+/robot/pack / builder.ts
+    - buildFunctionSignature(function () { });
+(symbol, declaration, checker) => ;
+src / robot / pack / builder.ts
+    - buildModuleExports(function () { });
+(symbols) => ;
+src / robot / pack / builder.ts
+    - buildPackText(function () { });
+(exportsByModule, types, signatures, exemplars) => ;
+src / robot / pack / builder.ts
+    - buildRobotPack(function () { });
+(options) => ;
+src / robot / pack / builder.ts
+    - buildSymbolId(function () { });
+(symbol, declaration) => ;
+src / robot / pack / builder.ts
+    - buildSymbolSignature(function () { });
+(symbol, declaration, checker, kind) => ;
+src / robot / pack / builder.ts
+    - buildTypeSignature(function () { });
+(declaration) => ;
+src / robot / pack / builder.ts
+    - CandidateInfo(type - alias);
+src / robot / pack / builder.ts
+    - ClassMemberSignatureDeclaration(type - alias);
+src / robot / pack / builder.ts
+    - collectPublicSymbols(function () { });
+(program, checker, candidates, entrypoints, settings) => ;
+src / robot / pack / builder.ts
+    - computeExemplarScore(function () { });
+(fanIn, complexity, annotationBoost, bodySize, heuristics) => ;
+src / robot / pack / builder.ts
+    - determineSymbolKind(function () { });
+(symbol, declaration) => ;
+src / robot / pack / builder.ts
+    - ensureModuleExposure(function () { });
+(moduleEntrypoints, queue, targetPath, exposures) => ;
+src / robot / pack / builder.ts
+    - ensureTagPrefix(function () { });
+(tag) => ;
+src / robot / pack / builder.ts
+    - escapeRegExp(function () { });
+(value) => ;
+src / robot / pack / builder.ts
+    - estimateComplexity(function () { });
+(node) => ;
+src / robot / pack / builder.ts
+    - estimateFanIn(function () { });
+(name, candidates) => ;
+src / robot / pack / builder.ts
+    - estimateTokens(function () { });
+(text) => ;
+src / robot / pack / builder.ts
+    - extractDocTags(function () { });
+(symbol, keepTags) => ;
+src / robot / pack / builder.ts
+    - formatExportSignature(function () { });
+(signature, kind) => ;
+src / robot / pack / builder.ts
+    - formatParameters(function () { });
+(parameters, checker) => ;
+src / robot / pack / builder.ts
+    - getClassMemberName(function () { });
+(member) => ;
+src / robot / pack / builder.ts
+    - handleSymbol(function () { });
+(symbols, sourceSymbol, exposures, moduleInfo, checker, se, src) => ;
+/robot/pack / builder.ts
+    - includeLocalDeclarations(function () { });
+(symbols, moduleInfo, exposures, checker, settings, src) => ;
+/robot/pack / builder.ts
+    - isClassMemberSignature(function () { });
+(member) => ;
+src / robot / pack / builder.ts
+    - isPathInside(function () { });
+(child, parent) => ;
+src / robot / pack / builder.ts
+    - isTypeSymbol(function () { });
+(kind) => ;
+src / robot / pack / builder.ts
+    - MAX_EXPORT_SIGNATURE_LENGTH();
+const ;
+const MAX_EXPORT_SIGNATURE_LENGTH, src;
+/robot/pack / builder.ts
+    - minifyImplementation(function () { });
+(text, keepTags) => ;
+src / robot / pack / builder.ts
+    - normalizeRelativePath(function () { });
+(value) => ;
+src / robot / pack / builder.ts
+    - normalizeSettings(function () { });
+(options) => ;
+src / robot / pack / builder.ts
+    - normalizeTypeText(function () { });
+(text) => ;
+src / robot / pack / builder.ts
+    - PRINTER();
+const ;
+const PRINTER, src;
+/robot/pack / builder.ts
+    - PublicSymbolRecord(type - alias);
+src / robot / pack / builder.ts
+    - resolveEntrypoints(function () { });
+(candidates, settings) => ;
+src / robot / pack / builder.ts
+    - resolveModuleSpecifier(function () { });
+(value, source, compilerOptions) => ;
+src / robot / pack / builder.ts
+    - resolveTsConfig(function () { });
+(rootDir, explicit) => ;
+src / robot / pack / builder.ts
+    - selectCandidateFiles(function () { });
+(sourceFiles, settings) => ;
+src / robot / pack / builder.ts
+    - selectExemplars(function () { });
+(candidates, settings) => ;
+src / robot / pack / builder.ts
+    - stripComments(function () { });
+(source, keepTags) => ;
+src / robot / pack / builder.ts
+    - TypeEntry(type - alias);
+dependenci;
+src / robot / pack / builder.ts
+    - TypeRegistry(class {
+    });
+class TypeRegistry {
+    entries;
+    depthDirty;
+}
+/robot/pack / builder.ts;
+src / robot / pack / cli.ts;
+-runRobotPack(function () { });
+(settings, exportMode) => ;
+src / robot / pack / cli.ts;
+src / robot / pack / globs.ts;
+-createGlobMatchers(function () { });
+(patterns) => ;
+src / robot / pack / globs.ts
+    - ESCAPE_REGEX();
+const ;
+const ESCAPE_REGEX, src;
+/robot/pack / globs.ts
+    - escapeLiteral(function () { });
+(value) => ;
+src / robot / pack / globs.ts
+    - expandBraces(function () { });
+(pattern) => ;
+src / robot / pack / globs.ts
+    - globToRegExp(function () { });
+(pattern) => ;
+src / robot / pack / globs.ts
+    - matchesAnyGlob(function () { });
+(value, matchers) => ;
+src / robot / pack / globs.ts
+    - normalizePatternInput(function () { });
+(value) => ;
+src / robot / pack / globs.ts
+    - normalizeTargetPath(function () { });
+(value) => ;
+src / robot / pack / globs.ts
+    - splitAlternatives(function () { });
+(value) => ;
+src / robot / pack / globs.ts;
+src / robot / pack / types.ts;
+-ExemplarHeuristicWeights(interface);
+src / robot / pack / types.ts
+    - ExemplarRecord(interface);
+src / robot / pack / types.ts
+    - ModuleExportSummary(interface);
+src / robot / pack / types.ts
+    - ROBOT_PACK_DEFAULT_SETTINGS();
+const ;
+const ROBOT_PACK_DEFAULT_SETTINGS, src;
+/robot/pack / types.ts
+    - ROBOT_PACK_SYMBOL_KINDS();
+const ;
+const ROBOT_PACK_SYMBOL_KINDS, src;
+/robot/pack / types.ts
+    - RobotPack(interface);
+src / robot / pack / types.ts
+    - RobotPackClosure(type - alias);
+src / robot / pack / types.ts
+    - RobotPackExportMode(type - alias);
+src / robot / pack / types.ts
+    - RobotPackJson(interface);
+src / robot / pack / types.ts
+    - RobotPackOptions(interface);
+src / robot / pack / types.ts
+    - RobotPackSettings(interface);
+src / robot / pack / types.ts
+    - RobotPackSummary(interface);
+signatu;
+src / robot / pack / types.ts
+    - RobotPackSymbolKind(type - alias);
+src / robot / pack / types.ts
+    - RobotPackVisibility(type - alias);
+src / robot / pack / types.ts
+    - SignatureDefinition(interface);
+src / robot / pack / types.ts
+    - SymbolSummary(interface);
+isR;
+src / robot / pack / types.ts
+    - TypeDefinition(interface);
+src / robot / pack / types.ts;
+TYPES: -CandidateInfo(type - alias);
+-ClassMemberSignatureDeclaration(type - alias);
+-ExemplarHeuristicWeights(interface);
+-RobotPackClosure(type - alias);
+-RobotPackExportMode(type - alias);
+-RobotPackSummary(interface);
+-RobotPackSymbolKind(type - alias);
+-ExemplarRecord(interface);
+-RobotPackOptions(interface);
+-RobotPackVisibility(type - alias);
+-RobotPackSettings(interface);
+-RobotSettingDescriptor(type - alias);
+-SignatureDefinition(interface);
+-SymbolSummary(interface);
+-ModuleExportSummary(interface);
+-PublicSymbolRecord(type - alias);
+-TypeDefinition(interface);
+-RobotPackJson(interface);
+-RobotPack(interface);
+-TypeEntry(type - alias);
+SIGNATURES: -src / robot / pack / types.ts;
+ROBOT_PACK_SYMBOL_KINDS();
+const ;
+const ROBOT_PACK_SYMBOL_KINDS;
+-src / robot / pack / types.ts;
+ROBOT_PACK_DEFAULT_SETTINGS();
+const ;
+const ROBOT_PACK_DEFAULT_SETTINGS;
+-src / robot / config.ts;
+loadRobotSettings(function () { })();
+Promise < RobotPackSettings >
+    -src / robot / config.ts;
+SETTINGS_SECTION();
+const ;
+const SETTINGS_SECTION;
+-src / robot / config.ts;
+workspaceSettingsPath();
+const ;
+const workspaceSettingsPath;
+-src / robot / config.ts;
+coerceBoolean(function () { })(value, unknown, fallback, boolean);
+boolean
+    - src / robot / config.ts;
+coercePositiveNumber(function () { })(value, unknown, fallback, number);
+number
+    - src / robot / config.ts;
+coercePositiveInteger(function () { })(value, unknown, fallback, number);
+number
+    - src / robot / config.ts;
+coerceOptionalNumber(function () { })(value, unknown);
+number | undefined
+    - src / robot / config.ts;
+coerceStringArray(function () { })(value, unknown, fallback, string[]);
+string[]
+    - src / robot / config.ts;
+coerceKinds(function () { })(value, unknown, fallback, RobotPackSymbolKind[]);
+RobotPackSymbolKind[]
+    - src / robot / config.ts;
+coerceExportMode(function () { })(value, unknown, fallback, RobotPackExportMode);
+RobotPackExportMode
+    - src / robot / config.ts;
+coerceVisibility(function () { })(value, unknown, exportedOnly, unknown, fallback, RobotPackVisibility);
+RobotPackVisibility
+    - src / robot / config.ts;
+coerceClosure(function () { })(value, unknown, fallback, RobotPackClosure);
+RobotPackClosure
+    - src / robot / config.ts;
+ensureTagPrefix(function () { })(tag, string);
+string
+    - src / robot / cli / settings.ts;
+formatValue(function () { })(value, string | number | boolean | RobotPackSymbolKind[] | string[] | ExemplarHeuristicWeights | undefined, descriptor, RobotSettingDescriptor);
+string
+    - src / robot / cli / settings.ts;
+parseInteractiveValue(function () { })(descriptor, RobotSettingDescriptor, buffer, string);
+{
+    value ?  : string | number | boolean | RobotPackSymbolKind[] | string[] | ExemplarHeuristicWeights | undefined;
+    error ?  : string | undefined;
+}
+-src / robot / cli / settings.ts;
+validateRobotSettings(function () { })(settings, RobotPackSettings);
+"Specify at least one include glob." | "Specify at least one entrypoint pattern." | "Choose at least one kind to include." | "Maximum exemplars must be a positive number." | "Token budget must be greater than zero or blank for unlimited." | undefined
+    - src / robot / cli / settings.ts;
+parseKindsInput(function () { })(raw, string);
+{
+    value ?  : RobotPackSymbolKind[] | undefined;
+    error ?  : string | undefined;
+}
+-src / robot / cli / settings.ts;
+SETTING_DESCRIPTORS();
+const ;
+const SETTING_DESCRIPTORS;
+-src / robot / cli / settings.ts;
+parseStringList(function () { })(input, string);
+string[]
+    - src / robot / cli / settings.ts;
+parsePositiveInteger(function () { })(input, string);
+number | undefined
+    - src / robot / cli / settings.ts;
+parseBooleanInput(function () { })(raw, string);
+{
+    value: boolean;
+    error ?  : undefined;
+}
+ | { error: string, value: undefined }
+    - src / robot / cli / prompts.ts;
+promptRobotSettings(function () { })(defaults, RobotPackSettings);
+Promise < RobotPackSettings >
+    -src / robot / cli / prompts.ts;
+READY_PROMPT();
+const ;
+const READY_PROMPT;
+-src / robot / cli / prompts.ts;
+confirmExecution(function () { })();
+Promise < boolean >
+    -src / robot / cli / prompts.ts;
+promptRobotSettingsSequential(function () { })(defaults, RobotPackSettings);
+Promise < { includeGlobs: string[], excludeGlobs: string[], entrypoints: string[], exportMode: RobotPackExportMode, visibility: RobotPackVisibility, ...10, more, ..., keepJSDocTags: string[] } >
+    -src / robot / cli / prompts.ts;
+promptList(function () { })(label, string, fallback, string[]);
+Promise < string[] >
+    -src / robot / cli / prompts.ts;
+promptChoice(function () { })(label, string, fallback, T, options, readonly, T[]);
+Promise < T >
+    -src / robot / cli / prompts.ts;
+promptKinds(function () { })(fallback, RobotPackSymbolKind[]);
+Promise < RobotPackSymbolKind[] >
+    -src / robot / cli / prompts.ts;
+promptPositiveNumber(function () { })(label, string, fallback, number);
+Promise < number >
+    -src / robot / cli / prompts.ts;
+promptTokenBudget(function () { })(label, string, fallback, number | undefined);
+Promise < number | undefined >
+    -src / robot / cli / prompts.ts;
+promptBoolean(function () { })(label, string, fallback, boolean);
+Promise < boolean >
+    -src / robot / cli / prompts.ts;
+promptRobotSettingsInteractive(function () { })(defaults, RobotPackSettings);
+Promise < RobotPackSettings >
+    -src / robot / pack / globs.ts;
+createGlobMatchers(function () { })(patterns, string[]);
+RegExp[]
+    - src / robot / pack / globs.ts;
+matchesAnyGlob(function () { })(value, string, matchers, RegExp[]);
+boolean
+    - src / robot / pack / globs.ts;
+ESCAPE_REGEX();
+const ;
+const ESCAPE_REGEX;
+-src / robot / pack / globs.ts;
+escapeLiteral(function () { })(value, string);
+string
+    - src / robot / pack / globs.ts;
+normalizePatternInput(function () { })(value, string);
+string
+    - src / robot / pack / globs.ts;
+normalizeTargetPath(function () { })(value, string);
+string
+    - src / robot / pack / globs.ts;
+splitAlternatives(function () { })(value, string);
+string[]
+    - src / robot / pack / globs.ts;
+expandBraces(function () { })(pattern, string);
+string[]
+    - src / robot / pack / globs.ts;
+globToRegExp(function () { })(pattern, string);
+string
+    - src / robot / pack / builder.ts;
+buildRobotPack(function () { })(options, RobotPackOptions);
+Promise < RobotPack >
+    -src / robot / pack / builder.ts;
+PRINTER();
+const ;
+const PRINTER;
+-src / robot / pack / builder.ts;
+normalizeSettings(function () { })(options, RobotPackOptions);
+RobotPackSettings
+    - src / robot / pack / builder.ts;
+ensureTagPrefix(function () { })(tag, string);
+string
+    - src / robot / pack / builder.ts;
+resolveTsConfig(function () { })(rootDir, string, explicit ?  : string | undefined);
+string | undefined
+    - src / robot / pack / builder.ts;
+selectCandidateFiles(function () { })(sourceFiles, readonly, SourceFile[], settings, RobotPackSettings);
+CandidateInfo[]
+    - src / robot / pack / builder.ts;
+resolveEntrypoints(function () { })(candidates, CandidateInfo[], settings, RobotPackSettings);
+Map < string, Set < string >>
+    -src / robot / pack / builder.ts;
+collectPublicSymbols(function () { })(program, Program, checker, TypeChecker, candidates, CandidateInfo[], entrypoints, (Map), settings, RobotPackSettings);
+Map < ;
+ >
+    -src / robot / pack / builder.ts;
+includeLocalDeclarations(function () { })(symbols, (Map), moduleInfo, CandidateInfo, exposures, (Set), checker, TypeChecker, settings, RobotPackSettings);
+void -src / robot / pack / builder.ts;
+handleSymbol(function () { })(symbols, (Map), sourceSymbol, Symbol, exposures, (Set), moduleInfo, CandidateInfo, checker, TypeChecker, settings, RobotPackSettings, isReexport, boolean);
+void -src / robot / pack / builder.ts;
+determineSymbolKind(function () { })(symbol, Symbol, declaration, Declaration);
+RobotPackSymbolKind | undefined
+    - src / robot / pack / builder.ts;
+buildSymbolSignature(function () { })(symbol, Symbol, declaration, Declaration, checker, TypeChecker, kind, RobotPackSymbolKind);
+string
+    - src / robot / pack / builder.ts;
+buildFunctionSignature(function () { })(symbol, Symbol, declaration, Declaration, checker, TypeChecker);
+string
+    - src / robot / pack / builder.ts;
+buildClassSignature(function () { })(declaration, Declaration, checker, TypeChecker);
+string
+    - src / robot / pack / builder.ts;
+buildClassMemberSignatures(function () { })(className, string, modulePath, string, declaration, Declaration, checker, TypeChecker);
+SignatureDefinition[]
+    - src / robot / pack / builder.ts;
+isClassMemberSignature(function () { })(member, Node);
+member;
+is;
+ClassMemberSignatureDeclaration
+    - src / robot / pack / builder.ts;
+getClassMemberName(function () { })(member, ClassMemberSignatureDeclaration);
+string | undefined
+    - src / robot / pack / builder.ts;
+buildClassMemberSignatureText(function () { })(member, ClassMemberSignatureDeclaration, checker, TypeChecker);
+string | undefined
+    - src / robot / pack / builder.ts;
+formatParameters(function () { })(parameters, (NodeArray), checker, TypeChecker);
+string
+    - src / robot / pack / builder.ts;
+buildConstSignature(function () { })(symbol, Symbol, declaration, Declaration, checker, TypeChecker);
+string
+    - src / robot / pack / builder.ts;
+buildTypeSignature(function () { })(declaration, Declaration);
+string
+    - src / robot / pack / builder.ts;
+buildSymbolId(function () { })(symbol, Symbol, declaration, Declaration);
+string
+    - src / robot / pack / builder.ts;
+extractDocTags(function () { })(symbol, Symbol, keepTags, string[]);
+string[]
+    - src / robot / pack / builder.ts;
+resolveModuleSpecifier(function () { })(value, string, source, SourceFile, compilerOptions, CompilerOptions);
+string | undefined
+    - src / robot / pack / builder.ts;
+ensureModuleExposure(function () { })(moduleEntrypoints, (Map), queue, string[], targetPath, string, exposures, (Set));
+void -src / robot / pack / builder.ts;
+buildModuleExports(function () { })(symbols, (Map));
+ModuleExportSummary[]
+    - src / robot / pack / builder.ts;
+buildPackText(function () { })(exportsByModule, ModuleExportSummary[], types, TypeDefinition[], signatures, SignatureDefinition[], exemplars, ExemplarRecord[]);
+string
+    - src / robot / pack / builder.ts;
+MAX_EXPORT_SIGNATURE_LENGTH();
+const ;
+const MAX_EXPORT_SIGNATURE_LENGTH;
+-src / robot / pack / builder.ts;
+formatExportSignature(function () { })(signature, string, kind, RobotPackSymbolKind);
+string
+    - src / robot / pack / builder.ts;
+applyTokenBudget(function () { })(pack, RobotPack, settings, RobotPackSettings, registry, TypeRegistry);
+void -src / robot / pack / builder.ts;
+estimateTokens(function () { })(text, string);
+number
+    - src / robot / pack / builder.ts;
+normalizeTypeText(function () { })(text, string);
+string
+    - src / robot / pack / builder.ts;
+normalizeRelativePath(function () { })(value, string);
+string
+    - src / robot / pack / builder.ts;
+isPathInside(function () { })(child, string, parent, string);
+boolean
+    - src / robot / pack / builder.ts;
+isTypeSymbol(function () { })(kind, RobotPackSymbolKind);
+kind;
+is;
+"interface" | "type-alias" | "enum"
+    - src / robot / pack / builder.ts;
+TypeRegistry.constructor(function () { })(checker, TypeChecker, rootDir, string, candidateFiles, (Set));
+TypeRegistry
+    - src / robot / pack / builder.ts;
+TypeRegistry.ensureTypeDeclaration(function () { })(symbol, Symbol, declaration, Declaration);
+string | undefined
+    - src / robot / pack / builder.ts;
+TypeRegistry.collectDependenciesForType(function () { })(key, string, symbol, Symbol, declaration, Declaration);
+string[]
+    - src / robot / pack / builder.ts;
+TypeRegistry.collectDependenciesForSymbol(function () { })(record, PublicSymbolRecord);
+string[]
+    - src / robot / pack / builder.ts;
+TypeRegistry.buildDefinitions(function () { })();
+{
+    name: string;
+    kind: "interface" | "type-alias" | "enum";
+    text: string;
+}
+[]
+    - src / robot / pack / builder.ts;
+TypeRegistry.dropNextDependency(function () { })();
+boolean
+    - src / robot / pack / builder.ts;
+TypeRegistry.ensureEntry(function () { });
+private(symbol, Symbol, declaration, Declaration, isSurface, boolean);
+string | undefined
+    - src / robot / pack / builder.ts;
+TypeRegistry.traverseType(function () { });
+private(type, Type | undefined, ownerKey, string | undefined, dependencyNames, (Set), visited, (Set));
+void -src / robot / pack / builder.ts;
+TypeRegistry.traverseSignature(function () { });
+private(signature, Signature, ownerKey, string | undefined, dependencyNames, (Set), visited, (Set));
+void -src / robot / pack / builder.ts;
+TypeRegistry.getTypeId(function () { });
+private(type, Type);
+number | undefined
+    - src / robot / pack / builder.ts;
+TypeRegistry.isCandidateDeclaration(function () { });
+private(declaration, Declaration);
+boolean
+    - src / robot / pack / builder.ts;
+TypeRegistry.determineDeclarationKind(function () { });
+private(declaration, Declaration);
+"interface" | "type-alias" | "enum" | undefined
+    - src / robot / pack / builder.ts;
+TypeRegistry.buildTypeKey(function () { });
+private(symbol, Symbol, declaration, Declaration);
+string
+    - src / robot / pack / builder.ts;
+TypeRegistry.orderEntries(function () { });
+private();
+TypeEntry[]
+    - src / robot / pack / builder.ts;
+TypeRegistry.computeDepths(function () { });
+private();
+void -src / robot / pack / builder.ts;
+TypeRegistry.ensureDepths(function () { });
+private();
+void -src / robot / pack / builder.ts;
+TypeRegistry.getDependencyCandidates(function () { });
+private();
+TypeEntry[]
+    - src / robot / pack / builder.ts;
+TypeRegistry.sortedArray(function () { });
+private(set, (Set));
+string[]
+    - src / robot / pack / builder.ts;
+buildExemplarCandidates(function () { })(symbols, (Map), candidates, CandidateInfo[], settings, RobotPackSettings);
+{
+    record: PublicSymbolRecord;
+    score: number;
+    body: string;
+}
+[]
+    - src / robot / pack / builder.ts;
+selectExemplars(function () { })(candidates, { record: PublicSymbolRecord, score: number, body: string }[], settings, RobotPackSettings);
+ExemplarRecord[]
+    - src / robot / pack / builder.ts;
+escapeRegExp(function () { })(value, string);
+string
+    - src / robot / pack / builder.ts;
+minifyImplementation(function () { })(text, string, keepTags, (Set));
+string
+    - src / robot / pack / builder.ts;
+stripComments(function () { })(source, string, keepTags, string[]);
+string
+    - src / robot / pack / builder.ts;
+estimateComplexity(function () { })(node, Node);
+number
+    - src / robot / pack / builder.ts;
+estimateFanIn(function () { })(name, string, candidates, CandidateInfo[]);
+number
+    - src / robot / pack / builder.ts;
+computeExemplarScore(function () { })(fanIn, number, complexity, number, annotationBoost, number, bodySize, number, heuristics, ExemplarHeuristicWeights);
+number
+    - src / robot / pack / cli.ts;
+runRobotPack(function () { })(settings, RobotPackSettings, exportMode, ExportMode);
+Promise < void  >
+    -src / robot / coordinator.ts;
+runRobot(function () { })();
+Promise < void  >
+    -src / robot / coordinator.ts;
+robotSettingsSummary(function () { })(settings, RobotPackSettings);
+string;
+EXEMPLARS: 
+// TypeRegistry (class) [score=18.64]
+class TypeRegistry {
+    checker;
+    rootDir;
+    candidateFiles;
+    entries = new Map();
+    depthDirty = true;
+    constructor(checker, rootDir, candidateFiles) {
+        this.checker = checker;
+        this.rootDir = rootDir;
+        this.candidateFiles = candidateFiles;
+    }
+    ensureTypeDeclaration(symbol, declaration) {
+        return this.ensureEntry(symbol, declaration, true);
+    }
+    collectDependenciesForType(key, symbol, declaration) {
+        const dependencies = new Set();
+        const declaredType = this.checker.getDeclaredTypeOfSymbol(symbol);
+        if (declaredType) {
+            this.traverseType(declaredType, key, dependencies, new Set());
+        }
+        return this.sortedArray(dependencies);
+    }
+    collectDependenciesForSymbol(record) {
+        const dependencies = new Set();
+        const type = this.checker.getTypeOfSymbolAtLocation(record.symbol, record.declaration);
+        if (record.summary.kind === 'function') {
+            const signatures = this.checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+            for (const signature of signatures) {
+                this.traverseSignature(signature, undefined, dependencies, new Set());
+            }
+        }
+        else {
+            this.traverseType(type, undefined, dependencies, new Set());
+        }
+        return this.sortedArray(dependencies);
+    }
+    buildDefinitions() {
+        const ordered = this.orderEntries();
+        return ordered.map((entry) => ({
+            name: entry.name,
+            kind: entry.kind,
+            text: entry.text,
+        }));
+    }
+    dropNextDependency() {
+        const candidates = this.getDependencyCandidates();
+        if (!candidates.length)
+            return false;
+        const target = candidates[0];
+        this.entries.delete(target.key);
+        for (const entry of this.entries.values()) {
+            entry.dependencies.delete(target.key);
+        }
+        this.depthDirty = true;
+        return true;
+    }
+    ensureEntry(symbol, declaration, isSurface) {
+        if (!this.isCandidateDeclaration(declaration))
+            return undefined;
+        const kind = this.determineDeclarationKind(declaration);
+        if (!kind)
+            return undefined;
+        const key = this.buildTypeKey(symbol, declaration);
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = {
+                key,
+                name: symbol.getName(),
+                kind,
+                text: normalizeTypeText(PRINTER.printNode(ts.EmitHint.Unspecified, declaration, declaration.getSourceFile())),
+                sourcePath: normalizeRelativePath(path.relative(this.rootDir, declaration.getSourceFile().fileName)),
+                dependencies: new Set(),
+                isSurface,
+            };
+            this.entries.set(key, entry);
+        }
+        else if (isSurface) {
+            entry.isSurface = true;
+        }
+        this.depthDirty = true;
+        return entry.key;
+    }
+    traverseType(type, ownerKey, dependencyNames, visited) {
+        if (!type)
+            return;
+        const typeId = this.getTypeId(type);
+        if (typeId !== undefined && visited.has(typeId))
+            return;
+        if (typeId !== undefined)
+            visited.add(typeId);
+        const referencedSymbol = type.aliasSymbol ?? type.getSymbol();
+        if (referencedSymbol) {
+            const declaration = referencedSymbol.valueDeclaration ?? referencedSymbol.declarations?.[0];
+            if (declaration) {
+                const childKey = this.ensureEntry(referencedSymbol, declaration, false);
+                if (childKey && ownerKey && ownerKey !== childKey) {
+                    this.entries.get(ownerKey)?.dependencies.add(childKey);
+                }
+                if (childKey) {
+                    dependencyNames.add(this.entries.get(childKey).name);
+                }
+            }
+        }
+        if (type.isUnionOrIntersection()) {
+            for (const part of type.types) {
+                this.traverseType(part, ownerKey, dependencyNames, visited);
+            }
+        }
+        const reference = type;
+        const typeArguments = reference.typeArguments ?? type.aliasTypeArguments;
+        if (typeArguments) {
+            for (const arg of typeArguments) {
+                this.traverseType(arg, ownerKey, dependencyNames, visited);
+            }
+        }
+        if (reference.target) {
+            this.traverseType(reference.target, ownerKey, dependencyNames, visited);
+        }
+        for (const signature of type.getCallSignatures()) {
+            this.traverseSignature(signature, ownerKey, dependencyNames, visited);
+        }
+        for (const signature of type.getConstructSignatures()) {
+            this.traverseSignature(signature, ownerKey, dependencyNames, visited);
+        }
+        const properties = type.getProperties();
+        for (const property of properties) {
+            const decl = property.valueDeclaration ?? property.declarations?.[0];
+            if (!decl)
+                continue;
+            const propType = this.checker.getTypeAtLocation(decl);
+            this.traverseType(propType, ownerKey, dependencyNames, visited);
+        }
+        const stringIndex = type.getStringIndexType();
+        if (stringIndex)
+            this.traverseType(stringIndex, ownerKey, dependencyNames, visited);
+        const numberIndex = type.getNumberIndexType();
+        if (numberIndex)
+            this.traverseType(numberIndex, ownerKey, dependencyNames, visited);
+        for (const base of type.getBaseTypes() ?? []) {
+            this.traverseType(base, ownerKey, dependencyNames, visited);
+        }
+    }
+    traverseSignature(signature, ownerKey, dependencyNames, visited) {
+        this.traverseType(signature.getReturnType(), ownerKey, dependencyNames, visited);
+        for (const parameter of signature.getParameters()) {
+            const decl = parameter.valueDeclaration ?? parameter.declarations?.[0];
+            if (!decl)
+                continue;
+            this.traverseType(this.checker.getTypeAtLocation(decl), ownerKey, dependencyNames, visited);
+        }
+        for (const typeParam of signature.typeParameters ?? []) {
+            const constraint = typeParam.getConstraint();
+            if (constraint) {
+                this.traverseType(constraint, ownerKey, dependencyNames, visited);
+            }
+        }
+    }
+    getTypeId(type) {
+        return type.id;
+    }
+    isCandidateDeclaration(declaration) {
+        const file = path.resolve(declaration.getSourceFile().fileName);
+        return this.candidateFiles.has(file);
+    }
+    determineDeclarationKind(declaration) {
+        if (ts.isInterfaceDeclaration(declaration))
+            return 'interface';
+        if (ts.isTypeAliasDeclaration(declaration))
+            return 'type-alias';
+        if (ts.isEnumDeclaration(declaration))
+            return 'enum';
+        return undefined;
+    }
+    buildTypeKey(symbol, declaration) {
+        const relative = normalizeRelativePath(path.relative(this.rootDir, declaration.getSourceFile().fileName));
+        return `${symbol.getName()}@${relative}:${declaration.getStart()}`;
+    }
+    orderEntries() {
+        const dependencyCounts = new Map();
+        const dependents = new Map();
+        for (const entry of this.entries.values()) {
+            const filtered = Array.from(entry.dependencies).filter((dep) => this.entries.has(dep));
+            dependencyCounts.set(entry.key, filtered.length);
+            for (const dep of filtered) {
+                const parents = dependents.get(dep) ?? new Set();
+                parents.add(entry.key);
+                dependents.set(dep, parents);
+            }
+        }
+        const compare = (a, b) => {
+            if (a.name !== b.name)
+                return a.name.localeCompare(b.name);
+            return a.sourcePath.localeCompare(b.sourcePath);
+        };
+        const available = Array.from(this.entries.values()).filter((entry) => (dependencyCounts.get(entry.key) ?? 0) === 0);
+        available.sort(compare);
+        const ordered = [];
+        const processed = new Set();
+        while (available.length > 0) {
+            const current = available.shift();
+            ordered.push(current);
+            processed.add(current.key);
+            const children = dependents.get(current.key);
+            if (children) {
+                for (const childKey of Array.from(children)) {
+                    const count = (dependencyCounts.get(childKey) ?? 0) - 1;
+                    dependencyCounts.set(childKey, count);
+                    if (count <= 0 && !processed.has(childKey)) {
+                        const child = this.entries.get(childKey);
+                        if (child) {
+                            available.push(child);
+                        }
+                    }
+                }
+                dependents.delete(current.key);
+            }
+            available.sort(compare);
+        }
+        if (ordered.length < this.entries.size) {
+            const remaining = Array.from(this.entries.values()).filter((entry) => !processed.has(entry.key));
+            remaining.sort(compare);
+            ordered.push(...remaining);
+        }
+        return ordered;
+    }
+    computeDepths() {
+        const surfaceKeys = new Set();
+        for (const entry of this.entries.values()) {
+            if (entry.isSurface)
+                surfaceKeys.add(entry.key);
+        }
+        for (const entry of this.entries.values()) {
+            entry.depth = undefined;
+        }
+        const queue = [];
+        for (const key of surfaceKeys) {
+            const entry = this.entries.get(key);
+            if (entry) {
+                entry.depth = 0;
+                queue.push(key);
+            }
+        }
+        while (queue.length) {
+            const parentKey = queue.shift();
+            const parent = this.entries.get(parentKey);
+            if (!parent)
+                continue;
+            for (const dependencyKey of parent.dependencies) {
+                const child = this.entries.get(dependencyKey);
+                if (!child)
+                    continue;
+                const depthCandidate = (parent.depth ?? 0) + 1;
+                if (child.depth === undefined || depthCandidate < child.depth) {
+                    child.depth = depthCandidate;
+                    queue.push(child.key);
+                }
+            }
+        }
+        this.depthDirty = false;
+    }
+    ensureDepths() {
+        if (this.depthDirty) {
+            this.computeDepths();
+        }
+    }
+    getDependencyCandidates() {
+        this.ensureDepths();
+        const candidates = Array.from(this.entries.values()).filter((entry) => !entry.isSurface);
+        candidates.sort((a, b) => {
+            const depthDiff = (b.depth ?? 0) - (a.depth ?? 0);
+            if (depthDiff !== 0)
+                return depthDiff;
+            if (a.name !== b.name)
+                return a.name.localeCompare(b.name);
+            return a.sourcePath.localeCompare(b.sourcePath);
+        });
+        return candidates;
+    }
+    sortedArray(set) {
+        return Array.from(set).sort();
+    }
+}
+// parseInteractiveValue (function) [score=6.04]
+export function parseInteractiveValue(descriptor, buffer) {
+    const trimmed = buffer.trim();
+    if (!trimmed) {
+        if (descriptor.allowEmpty) {
+            return { value: undefined };
+        }
+        return { value: undefined };
+    }
+    switch (descriptor.type) {
+        case 'list':
+            if (descriptor.key === 'includeKinds') {
+                return parseKindsInput(trimmed);
+            }
+            return { value: parseStringList(trimmed) };
+        case 'choice':
+            if (!descriptor.options)
+                return { value: undefined };
+            if (!descriptor.options.includes(trimmed)) {
+                return { error: `Choose one of: ${descriptor.options.join(', ')}.` };
+            }
+            return { value: trimmed };
+        case 'number':
+            if (descriptor.allowEmpty && trimmed === '') {
+                return { value: undefined };
+            }
+            const parsed = parsePositiveInteger(trimmed);
+            if (parsed === undefined) {
+                return { error: `${descriptor.label} requires a positive integer.` };
+            }
+            return { value: parsed };
+        case 'boolean': {
+            const parsedBool = parseBooleanInput(trimmed);
+            if (parsedBool.error)
+                return { error: parsedBool.error };
+            return { value: parsedBool.value };
+        }
+        default:
+            return { value: undefined };
+    }
+}
+// buildClassSignature (function) [score=5.21]
+function buildClassSignature(declaration, checker) {
+    if (!ts.isClassLike(declaration))
+        return declaration.getText();
+    const name = declaration.name?.getText() ?? 'Anonymous';
+    const heritage = declaration.heritageClauses
+        ? declaration.heritageClauses
+            .map((clause) => clause.getText())
+            .join(' ')
+            .trim()
+        : '';
+    const header = `export declare class ${name}${heritage ? ` ${heritage}` : ''}`;
+    const memberParts = [];
+    for (const member of declaration.members) {
+        if (ts.isConstructorDeclaration(member)) {
+            memberParts.push(`constructor(${formatParameters(member.parameters, checker)})`);
+            continue;
+        }
+        if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
+            const memberName = member.name?.getText() ?? 'anonymous';
+            const signature = checker.getSignatureFromDeclaration(member);
+            const text = signature
+                ? checker.signatureToString(signature)
+                : `${memberName}()`;
+            memberParts.push(`${memberName}${text.slice(memberName.length)}`);
+            continue;
+        }
+        if (ts.isPropertyDeclaration(member) || ts.isPropertySignature(member)) {
+            const nameText = member.name?.getText() ?? '';
+            const type = member.type
+                ? checker.getTypeAtLocation(member.type)
+                : checker.getTypeAtLocation(member);
+            const typeText = checker.typeToString(type);
+            const optional = member.questionToken ? '?' : '';
+            memberParts.push(`${nameText}${optional}: ${typeText}`);
+        }
+    }
+    const body = memberParts.length ? ` { ${memberParts.join('; ')} }` : ' {}';
+    return `${header}${body}`;
+}
+// normalizeSettings (function) [score=4.98]
+function normalizeSettings(options) {
+    const defaults = ROBOT_PACK_DEFAULT_SETTINGS;
+    const rootDir = path.resolve(options.rootDir);
+    const candidateScope = options.scopeDir
+        ? path.resolve(rootDir, options.scopeDir)
+        : rootDir;
+    const scopeDir = isPathInside(candidateScope, rootDir) ? candidateScope : rootDir;
+    return {
+        reportMethod: options.reportMethod ?? defaults.reportMethod,
+        rootDir,
+        scopeDir,
+        tsconfigPath: options.tsconfigPath,
+        includeGlobs: options.includeGlobs && options.includeGlobs.length > 0
+            ? [...options.includeGlobs]
+            : [...defaults.includeGlobs],
+        excludeGlobs: options.excludeGlobs && options.excludeGlobs.length > 0
+            ? [...options.excludeGlobs]
+            : [...defaults.excludeGlobs],
+        entrypoints: options.entrypoints && options.entrypoints.length > 0
+            ? [...options.entrypoints]
+            : [...defaults.entrypoints],
+        exportMode: options.exportMode ?? defaults.exportMode,
+        visibility: options.visibility ?? defaults.visibility,
+        includeKinds: options.includeKinds && options.includeKinds.length > 0
+            ? [...options.includeKinds]
+            : [...defaults.includeKinds],
+        closure: options.closure ?? defaults.closure,
+        maxExemplars: options.maxExemplars ?? defaults.maxExemplars,
+        tokenBudget: options.tokenBudget ?? defaults.tokenBudget,
+        preferTypeSurface: options.preferTypeSurface ?? defaults.preferTypeSurface,
+        exemplarHeuristics: {
+            ...defaults.exemplarHeuristics,
+            ...(options.exemplarHeuristics ?? {}),
+        },
+        keepJSDocTags: (options.keepJSDocTags && options.keepJSDocTags.length > 0
+            ? options.keepJSDocTags
+            : defaults.keepJSDocTags).map((tag) => ensureTagPrefix(tag)),
+    };
+}
+// includeLocalDeclarations (function) [score=4.89]
+function includeLocalDeclarations(symbols, moduleInfo, exposures, checker, settings) {
+    for (const stmt of moduleInfo.sourceFile.statements) {
+        const candidates = [];
+        if (ts.isFunctionDeclaration(stmt) ||
+            ts.isClassDeclaration(stmt) ||
+            ts.isInterfaceDeclaration(stmt) ||
+            ts.isTypeAliasDeclaration(stmt) ||
+            ts.isEnumDeclaration(stmt)) {
+            const symbol = stmt.name ? checker.getSymbolAtLocation(stmt.name) : undefined;
+            if (symbol)
+                candidates.push(symbol);
+        }
+        if (ts.isVariableStatement(stmt)) {
+            for (const declaration of stmt.declarationList.declarations) {
+                const symbol = declaration.name
+                    ? checker.getSymbolAtLocation(declaration.name)
+                    : undefined;
+                if (symbol)
+                    candidates.push(symbol);
+            }
+        }
+        for (const candidate of candidates) {
+            handleSymbol(symbols, candidate, exposures, moduleInfo, checker, settings, false);
+        }
+    }
+}
+// formatValue (function) [score=4.82]
+export function formatValue(value, descriptor) {
+    if (descriptor.type === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (descriptor.type === 'list') {
+        const items = value;
+        if (!items.length)
+            return 'none';
+        return items.join(', ');
+    }
+    if (descriptor.type === 'choice') {
+        return `${value}`;
+    }
+    if (descriptor.type === 'number') {
+        if (descriptor.key === 'tokenBudget' && value === undefined) {
+            return 'unlimited';
+        }
+        return `${value}`;
+    }
+    return `${value}`;
+}
+// parseKindsInput (function) [score=4.04]
+export function parseKindsInput(raw) {
+    const normalized = raw
+        .split(',')
+        .map((chunk) => chunk.trim().toLowerCase())
+        .filter(Boolean);
+    if (!normalized.length) {
+        return { error: 'Enter at least one kind or "all".' };
+    }
+    if (normalized.length === 1 && normalized[0] === 'all') {
+        return { value: [...ROBOT_PACK_SYMBOL_KINDS] };
+    }
+    const invalid = [];
+    const unique = [];
+    const seen = new Set();
+    for (const entry of normalized) {
+        if (!ROBOT_PACK_SYMBOL_KINDS.includes(entry)) {
+            invalid.push(entry);
+            continue;
+        }
+        const kind = entry;
+        if (!seen.has(kind)) {
+            seen.add(kind);
+            unique.push(kind);
+        }
+    }
+    if (invalid.length > 0) {
+        return {
+            error: `Unknown kinds: ${invalid.join(', ')}. Valid kinds are ${ROBOT_PACK_SYMBOL_KINDS.join(', ')}.`,
+        };
+    }
+    if (!unique.length) {
+        return { error: 'Provide at least one valid kind.' };
+    }
+    return { value: unique };
+}
+// validateRobotSettings (function) [score=3.93]
+export function validateRobotSettings(settings) {
+    if (!settings.includeGlobs.length)
+        return 'Specify at least one include glob.';
+    if (!settings.entrypoints.length)
+        return 'Specify at least one entrypoint pattern.';
+    if (!settings.includeKinds.length)
+        return 'Choose at least one kind to include.';
+    if (!Number.isFinite(settings.maxExemplars) || settings.maxExemplars <= 0) {
+        return 'Maximum exemplars must be a positive number.';
+    }
+    if (settings.tokenBudget !== undefined && settings.tokenBudget <= 0) {
+        return 'Token budget must be greater than zero or blank for unlimited.';
+    }
+    return undefined;
+}