@vibeframe/mcp-server 0.113.8 → 0.113.10

package/dist/index.js

@@ -120570,8 +120570,8 @@ var init_which_module = __esm({
 });
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/command.js
-function command(usage3, validation3, globalMiddleware, shim4) {
-  return new CommandInstance(usage3, validation3, globalMiddleware, shim4);
+function command(usage4, validation3, globalMiddleware, shim4) {
+  return new CommandInstance(usage4, validation3, globalMiddleware, shim4);
 }
 function isCommandBuilderDefinition(builder) {
   return typeof builder === "object" && !!builder.builder && typeof builder.handler === "function";
@@ -120600,13 +120600,13 @@ var init_command = __esm({
     init_which_module();
     DEFAULT_MARKER = /(^\*)|(^\$0)/;
     CommandInstance = class {
-      constructor(usage3, validation3, globalMiddleware, shim4) {
+      constructor(usage4, validation3, globalMiddleware, shim4) {
         this.requireCache = /* @__PURE__ */ new Set();
         this.handlers = {};
         this.aliasMap = {};
         this.frozens = [];
         this.shim = shim4;
-        this.usage = usage3;
+        this.usage = usage4;
         this.globalMiddleware = globalMiddleware;
         this.validation = validation3;
       }
@@ -121172,10 +121172,10 @@ function usage(yargs, shim4) {
     });
     if (!usageDisabled) {
       if (usages.length) {
-        usages.forEach((usage3) => {
-          ui3.div({ text: `${usage3[0].replace(/\$0/g, base$0)}` });
-          if (usage3[1]) {
-            ui3.div({ text: `${usage3[1]}`, padding: [1, 0, 0, 0] });
+        usages.forEach((usage4) => {
+          ui3.div({ text: `${usage4[0].replace(/\$0/g, base$0)}` });
+          if (usage4[1]) {
+            ui3.div({ text: `${usage4[1]}`, padding: [1, 0, 0, 0] });
           }
         });
         ui3.div();
@@ -121595,8 +121595,8 @@ compdef _{{app_name}}_yargs_completions {{app_name}}
 });
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/completion.js
-function completion(yargs, usage3, command3, shim4) {
-  return new Completion(yargs, usage3, command3, shim4);
+function completion(yargs, usage4, command3, shim4) {
+  return new Completion(yargs, usage4, command3, shim4);
 }
 function isSyncCompletionFunction(completionFunction) {
   return completionFunction.length < 3;
@@ -121613,10 +121613,10 @@ var init_completion = __esm({
     init_is_promise();
     init_parse_command();
     Completion = class {
-      constructor(yargs, usage3, command3, shim4) {
+      constructor(yargs, usage4, command3, shim4) {
         var _a9, _b3, _c3;
         this.yargs = yargs;
-        this.usage = usage3;
+        this.usage = usage4;
         this.command = command3;
         this.shim = shim4;
         this.completionKey = "get-yargs-completions";
@@ -121853,7 +121853,7 @@ var init_levenshtein = __esm({
 });
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/validation.js
-function validation(yargs, usage3, shim4) {
+function validation(yargs, usage4, shim4) {
   const __ = shim4.y18n.__;
   const __n = shim4.y18n.__n;
   const self2 = {};
@@ -121864,22 +121864,22 @@ function validation(yargs, usage3, shim4) {
     if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
       if (_s < demandedCommands._.min) {
         if (demandedCommands._.minMsg !== void 0) {
-          usage3.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
+          usage4.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
         } else {
-          usage3.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
+          usage4.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
         }
       } else if (_s > demandedCommands._.max) {
         if (demandedCommands._.maxMsg !== void 0) {
-          usage3.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
+          usage4.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
         } else {
-          usage3.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
+          usage4.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
         }
       }
     }
   };
   self2.positionalCount = function positionalCount(required, observed) {
     if (observed < required) {
-      usage3.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed + "", required + ""));
+      usage4.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed + "", required + ""));
     }
   };
   self2.requiredArguments = function requiredArguments(argv, demandedOptions) {
@@ -121900,7 +121900,7 @@ function validation(yargs, usage3, shim4) {
       }
       const customMsg = customMsgs.length ? `
 ${customMsgs.join("\n")}` : "";
-      usage3.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg));
+      usage4.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg));
     }
   };
   self2.unknownArguments = function unknownArguments(argv, aliases2, positionalMap, isDefaultCommand, checkPositionals = true) {
@@ -121934,7 +121934,7 @@ ${customMsgs.join("\n")}` : "";
       }
     }
     if (unknown.length) {
-      usage3.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s2) => s2.trim() ? s2 : `"${s2}"`).join(", ")));
+      usage4.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s2) => s2.trim() ? s2 : `"${s2}"`).join(", ")));
     }
   };
   self2.unknownCommands = function unknownCommands(argv) {
@@ -121949,7 +121949,7 @@ ${customMsgs.join("\n")}` : "";
       });
     }
     if (unknown.length > 0) {
-      usage3.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", ")));
+      usage4.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", ")));
       return true;
     } else {
       return false;
@@ -121982,9 +121982,9 @@ ${customMsgs.join("\n")}` : "";
     let msg = __("Invalid values:");
     invalidKeys.forEach((key2) => {
       msg += `
-  ${__("Argument: %s, Given: %s, Choices: %s", key2, usage3.stringifiedValues(invalid[key2]), usage3.stringifiedValues(options.choices[key2]))}`;
+  ${__("Argument: %s, Given: %s, Choices: %s", key2, usage4.stringifiedValues(invalid[key2]), usage4.stringifiedValues(options.choices[key2]))}`;
     });
-    usage3.fail(msg);
+    usage4.fail(msg);
   };
   let implied = {};
   self2.implies = function implies(key2, value) {
@@ -122042,7 +122042,7 @@ ${customMsgs.join("\n")}` : "";
       implyFail.forEach((value) => {
         msg += value;
       });
-      usage3.fail(msg);
+      usage4.fail(msg);
     }
   };
   let conflicting = {};
@@ -122070,7 +122070,7 @@ ${customMsgs.join("\n")}` : "";
       if (conflicting[key2]) {
         conflicting[key2].forEach((value) => {
           if (value && argv[key2] !== void 0 && argv[value] !== void 0) {
-            usage3.fail(__("Arguments %s and %s are mutually exclusive", key2, value));
+            usage4.fail(__("Arguments %s and %s are mutually exclusive", key2, value));
           }
         });
       }
@@ -122079,7 +122079,7 @@ ${customMsgs.join("\n")}` : "";
       Object.keys(conflicting).forEach((key2) => {
         conflicting[key2].forEach((value) => {
           if (value && argv[shim4.Parser.camelCase(key2)] !== void 0 && argv[shim4.Parser.camelCase(value)] !== void 0) {
-            usage3.fail(__("Arguments %s and %s are mutually exclusive", key2, value));
+            usage4.fail(__("Arguments %s and %s are mutually exclusive", key2, value));
           }
         });
       });
@@ -122098,7 +122098,7 @@ ${customMsgs.join("\n")}` : "";
       }
     }
     if (recommended)
-      usage3.fail(__("Did you mean %s?", recommended));
+      usage4.fail(__("Did you mean %s?", recommended));
   };
   self2.reset = function reset(localLookup) {
     implied = objFilter(implied, (k2) => !localLookup[k2]);
@@ -152275,34 +152275,34 @@ ${lanes.join("\n")}
         directories: directoriesMatcher,
         exclude: excludeMatcher
       };
-      function getRegularExpressionForWildcard(specs, basePath, usage3) {
-        const patterns = getRegularExpressionsForWildcards(specs, basePath, usage3);
+      function getRegularExpressionForWildcard(specs, basePath, usage4) {
+        const patterns = getRegularExpressionsForWildcards(specs, basePath, usage4);
         if (!patterns || !patterns.length) {
           return void 0;
         }
         const pattern = patterns.map((pattern2) => `(?:${pattern2})`).join("|");
-        const terminator = usage3 === "exclude" ? "(?:$|/)" : "$";
+        const terminator = usage4 === "exclude" ? "(?:$|/)" : "$";
         return `^(?:${pattern})${terminator}`;
       }
-      function getRegularExpressionsForWildcards(specs, basePath, usage3) {
+      function getRegularExpressionsForWildcards(specs, basePath, usage4) {
         if (specs === void 0 || specs.length === 0) {
           return void 0;
         }
-        return flatMap(specs, (spec) => spec && getSubPatternFromSpec(spec, basePath, usage3, wildcardMatchers[usage3]));
+        return flatMap(specs, (spec) => spec && getSubPatternFromSpec(spec, basePath, usage4, wildcardMatchers[usage4]));
       }
       function isImplicitGlob(lastPathComponent) {
         return !/[.*?]/.test(lastPathComponent);
       }
-      function getPatternFromSpec(spec, basePath, usage3) {
-        const pattern = spec && getSubPatternFromSpec(spec, basePath, usage3, wildcardMatchers[usage3]);
-        return pattern && `^(?:${pattern})${usage3 === "exclude" ? "(?:$|/)" : "$"}`;
+      function getPatternFromSpec(spec, basePath, usage4) {
+        const pattern = spec && getSubPatternFromSpec(spec, basePath, usage4, wildcardMatchers[usage4]);
+        return pattern && `^(?:${pattern})${usage4 === "exclude" ? "(?:$|/)" : "$"}`;
       }
-      function getSubPatternFromSpec(spec, basePath, usage3, { singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter: replaceWildcardCharacter2 } = wildcardMatchers[usage3]) {
+      function getSubPatternFromSpec(spec, basePath, usage4, { singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter: replaceWildcardCharacter2 } = wildcardMatchers[usage4]) {
         let subpattern = "";
         let hasWrittenComponent = false;
         const components = getNormalizedPathComponents(spec, basePath);
         const lastComponent = last3(components);
-        if (usage3 !== "exclude" && lastComponent === "**") {
+        if (usage4 !== "exclude" && lastComponent === "**") {
           return void 0;
         }
         components[0] = removeTrailingDirectorySeparator(components[0]);
@@ -152314,14 +152314,14 @@ ${lanes.join("\n")}
           if (component === "**") {
             subpattern += doubleAsteriskRegexFragment;
           } else {
-            if (usage3 === "directories") {
+            if (usage4 === "directories") {
               subpattern += "(?:";
               optionalCount++;
             }
             if (hasWrittenComponent) {
               subpattern += directorySeparator;
             }
-            if (usage3 !== "exclude") {
+            if (usage4 !== "exclude") {
               let componentPattern = "";
               if (component.charCodeAt(0) === 42) {
                 componentPattern += "(?:[^./]" + singleAsteriskRegexFragment + ")?";
@@ -185619,27 +185619,27 @@ ${lanes.join("\n")}
           }
           return Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
         }
-        function isBlockScopedNameDeclaredBeforeUse(declaration, usage3) {
+        function isBlockScopedNameDeclaredBeforeUse(declaration, usage4) {
           const declarationFile = getSourceFileOfNode(declaration);
-          const useFile = getSourceFileOfNode(usage3);
+          const useFile = getSourceFileOfNode(usage4);
           const declContainer = getEnclosingBlockScopeContainer(declaration);
           if (declarationFile !== useFile) {
-            if (moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator) || !compilerOptions.outFile || isInTypeQuery(usage3) || declaration.flags & 33554432) {
+            if (moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator) || !compilerOptions.outFile || isInTypeQuery(usage4) || declaration.flags & 33554432) {
               return true;
             }
-            if (isUsedInFunctionOrInstanceProperty(usage3, declaration)) {
+            if (isUsedInFunctionOrInstanceProperty(usage4, declaration)) {
               return true;
             }
             const sourceFiles = host.getSourceFiles();
             return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
           }
-          if (!!(usage3.flags & 16777216) || isInTypeQuery(usage3) || isInAmbientOrTypeNode(usage3)) {
+          if (!!(usage4.flags & 16777216) || isInTypeQuery(usage4) || isInAmbientOrTypeNode(usage4)) {
             return true;
           }
-          if (declaration.pos <= usage3.pos && !(isPropertyDeclaration(declaration) && isThisProperty(usage3.parent) && !declaration.initializer && !declaration.exclamationToken)) {
+          if (declaration.pos <= usage4.pos && !(isPropertyDeclaration(declaration) && isThisProperty(usage4.parent) && !declaration.initializer && !declaration.exclamationToken)) {
             if (declaration.kind === 209) {
               const errorBindingElement = getAncestor(
-                usage3,
+                usage4,
                 209
                 /* BindingElement */
               );
@@ -185650,41 +185650,41 @@ ${lanes.join("\n")}
                 declaration,
                 261
                 /* VariableDeclaration */
-              ), usage3);
+              ), usage4);
             } else if (declaration.kind === 261) {
-              return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage3);
+              return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage4);
             } else if (isClassLike(declaration)) {
-              const container = findAncestor(usage3, (n2) => n2 === declaration ? "quit" : isComputedPropertyName(n2) ? n2.parent.parent === declaration : !legacyDecorators && isDecorator(n2) && (n2.parent === declaration || isMethodDeclaration(n2.parent) && n2.parent.parent === declaration || isGetOrSetAccessorDeclaration(n2.parent) && n2.parent.parent === declaration || isPropertyDeclaration(n2.parent) && n2.parent.parent === declaration || isParameter(n2.parent) && n2.parent.parent.parent === declaration));
+              const container = findAncestor(usage4, (n2) => n2 === declaration ? "quit" : isComputedPropertyName(n2) ? n2.parent.parent === declaration : !legacyDecorators && isDecorator(n2) && (n2.parent === declaration || isMethodDeclaration(n2.parent) && n2.parent.parent === declaration || isGetOrSetAccessorDeclaration(n2.parent) && n2.parent.parent === declaration || isPropertyDeclaration(n2.parent) && n2.parent.parent === declaration || isParameter(n2.parent) && n2.parent.parent.parent === declaration));
               if (!container) {
                 return true;
               }
               if (!legacyDecorators && isDecorator(container)) {
-                return !!findAncestor(usage3, (n2) => n2 === container ? "quit" : isFunctionLike(n2) && !getImmediatelyInvokedFunctionExpression(n2));
+                return !!findAncestor(usage4, (n2) => n2 === container ? "quit" : isFunctionLike(n2) && !getImmediatelyInvokedFunctionExpression(n2));
               }
               return false;
             } else if (isPropertyDeclaration(declaration)) {
               return !isPropertyImmediatelyReferencedWithinDeclaration(
                 declaration,
-                usage3,
+                usage4,
                 /*stopAtAnyPropertyDeclaration*/
                 false
               );
             } else if (isParameterPropertyDeclaration(declaration, declaration.parent)) {
-              return !(emitStandardClassFields && getContainingClass(declaration) === getContainingClass(usage3) && isUsedInFunctionOrInstanceProperty(usage3, declaration));
+              return !(emitStandardClassFields && getContainingClass(declaration) === getContainingClass(usage4) && isUsedInFunctionOrInstanceProperty(usage4, declaration));
             }
             return true;
           }
-          if (usage3.parent.kind === 282 || usage3.parent.kind === 278 && usage3.parent.isExportEquals) {
+          if (usage4.parent.kind === 282 || usage4.parent.kind === 278 && usage4.parent.isExportEquals) {
             return true;
           }
-          if (usage3.kind === 278 && usage3.isExportEquals) {
+          if (usage4.kind === 278 && usage4.isExportEquals) {
             return true;
           }
-          if (isUsedInFunctionOrInstanceProperty(usage3, declaration)) {
+          if (isUsedInFunctionOrInstanceProperty(usage4, declaration)) {
             if (emitStandardClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
               return !isPropertyImmediatelyReferencedWithinDeclaration(
                 declaration,
-                usage3,
+                usage4,
                 /*stopAtAnyPropertyDeclaration*/
                 true
               );
@@ -186290,19 +186290,19 @@ ${lanes.join("\n")}
             /* Default */
           ) || isExportSpecifier(node) || isNamespaceExport(node);
         }
-        function getEmitSyntaxForModuleSpecifierExpression(usage3) {
-          return isStringLiteralLike(usage3) ? host.getEmitSyntaxForUsageLocation(getSourceFileOfNode(usage3), usage3) : void 0;
+        function getEmitSyntaxForModuleSpecifierExpression(usage4) {
+          return isStringLiteralLike(usage4) ? host.getEmitSyntaxForUsageLocation(getSourceFileOfNode(usage4), usage4) : void 0;
         }
         function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
           return usageMode === 99 && targetMode === 1;
         }
-        function isOnlyImportableAsDefault(usage3, resolvedModule) {
+        function isOnlyImportableAsDefault(usage4, resolvedModule) {
           if (100 <= moduleKind && moduleKind <= 199) {
-            const usageMode = getEmitSyntaxForModuleSpecifierExpression(usage3);
+            const usageMode = getEmitSyntaxForModuleSpecifierExpression(usage4);
             if (usageMode === 99) {
               resolvedModule ?? (resolvedModule = resolveExternalModuleName(
-                usage3,
-                usage3,
+                usage4,
+                usage4,
                 /*ignoreErrors*/
                 true
               ));
@@ -186312,8 +186312,8 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage3) {
-          const usageMode = file && getEmitSyntaxForModuleSpecifierExpression(usage3);
+        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage4) {
+          const usageMode = file && getEmitSyntaxForModuleSpecifierExpression(usage4);
           if (file && usageMode !== void 0) {
             const targetMode = host.getImpliedNodeFormatForEmit(file);
             if (usageMode === 99 && targetMode === 1 && 100 <= moduleKind && moduleKind <= 199) {
@@ -265020,43 +265020,43 @@ ${lanes.join("\n")}
         }
         return false;
       }
-      function getModeForUsageLocation(file, usage3, compilerOptions) {
-        return getModeForUsageLocationWorker(file, usage3, compilerOptions);
+      function getModeForUsageLocation(file, usage4, compilerOptions) {
+        return getModeForUsageLocationWorker(file, usage4, compilerOptions);
       }
-      function getModeForUsageLocationWorker(file, usage3, compilerOptions) {
-        if (isImportDeclaration(usage3.parent) || isExportDeclaration(usage3.parent) || isJSDocImportTag(usage3.parent)) {
-          const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage3.parent);
+      function getModeForUsageLocationWorker(file, usage4, compilerOptions) {
+        if (isImportDeclaration(usage4.parent) || isExportDeclaration(usage4.parent) || isJSDocImportTag(usage4.parent)) {
+          const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage4.parent);
           if (isTypeOnly) {
-            const override = getResolutionModeOverride(usage3.parent.attributes);
+            const override = getResolutionModeOverride(usage4.parent.attributes);
             if (override) {
               return override;
             }
           }
         }
-        if (usage3.parent.parent && isImportTypeNode(usage3.parent.parent)) {
-          const override = getResolutionModeOverride(usage3.parent.parent.attributes);
+        if (usage4.parent.parent && isImportTypeNode(usage4.parent.parent)) {
+          const override = getResolutionModeOverride(usage4.parent.parent.attributes);
           if (override) {
             return override;
           }
         }
         if (compilerOptions && importSyntaxAffectsModuleResolution(compilerOptions)) {
-          return getEmitSyntaxForUsageLocationWorker(file, usage3, compilerOptions);
+          return getEmitSyntaxForUsageLocationWorker(file, usage4, compilerOptions);
         }
       }
-      function getEmitSyntaxForUsageLocationWorker(file, usage3, compilerOptions) {
+      function getEmitSyntaxForUsageLocationWorker(file, usage4, compilerOptions) {
         var _a9;
         if (!compilerOptions) {
           return void 0;
         }
-        const exprParentParent = (_a9 = walkUpParenthesizedExpressions(usage3.parent)) == null ? void 0 : _a9.parent;
+        const exprParentParent = (_a9 = walkUpParenthesizedExpressions(usage4.parent)) == null ? void 0 : _a9.parent;
         if (exprParentParent && isImportEqualsDeclaration(exprParentParent) || isRequireCall(
-          usage3.parent,
+          usage4.parent,
           /*requireStringLiteralLikeArgument*/
           false
         )) {
           return 1;
         }
-        if (isImportCall(walkUpParenthesizedExpressions(usage3.parent))) {
+        if (isImportCall(walkUpParenthesizedExpressions(usage4.parent))) {
           return shouldTransformImportCallWorker(file, compilerOptions) ? 1 : 99;
         }
         const fileEmitMode = getEmitModuleFormatOfFileWorker(file, compilerOptions);
@@ -268209,11 +268209,11 @@ ${lanes.join("\n")}
           }
           return symlinks;
         }
-        function getModeForUsageLocation2(file, usage3) {
-          return getModeForUsageLocationWorker(file, usage3, getCompilerOptionsForFile(file));
+        function getModeForUsageLocation2(file, usage4) {
+          return getModeForUsageLocationWorker(file, usage4, getCompilerOptionsForFile(file));
         }
-        function getEmitSyntaxForUsageLocation(file, usage3) {
-          return getEmitSyntaxForUsageLocationWorker(file, usage3, getCompilerOptionsForFile(file));
+        function getEmitSyntaxForUsageLocation(file, usage4) {
+          return getEmitSyntaxForUsageLocationWorker(file, usage4, getCompilerOptionsForFile(file));
         }
         function getModeForResolutionAtIndex2(file, index) {
           return getModeForUsageLocation2(file, getModuleNameStringLiteralAt(file, index));
@@ -286493,23 +286493,23 @@ interface Symbol {
           addNewFileToTsconfig(program2, changes, oldFile.fileName, targetFile, hostGetCanonicalFileName(host));
         }
       }
-      function getNewStatementsAndRemoveFromOldFile(oldFile, targetFile, usage3, changes, toMove, program2, host, preferences, importAdderForNewFile, importAdderForOldFile) {
+      function getNewStatementsAndRemoveFromOldFile(oldFile, targetFile, usage4, changes, toMove, program2, host, preferences, importAdderForNewFile, importAdderForOldFile) {
         const checker = program2.getTypeChecker();
         const prologueDirectives = takeWhile(oldFile.statements, isPrologueDirective);
         const useEsModuleSyntax = !fileShouldUseJavaScriptRequire(targetFile.fileName, program2, host, !!oldFile.commonJsModuleIndicator);
         const quotePreference = getQuotePreference(oldFile, preferences);
-        addImportsForMovedSymbols(usage3.oldFileImportsFromTargetFile, targetFile.fileName, importAdderForOldFile, program2);
-        deleteUnusedOldImports(oldFile, toMove.all, usage3.unusedImportsFromOldFile, importAdderForOldFile);
+        addImportsForMovedSymbols(usage4.oldFileImportsFromTargetFile, targetFile.fileName, importAdderForOldFile, program2);
+        deleteUnusedOldImports(oldFile, toMove.all, usage4.unusedImportsFromOldFile, importAdderForOldFile);
         importAdderForOldFile.writeFixes(changes, quotePreference);
         deleteMovedStatements(oldFile, toMove.ranges, changes);
-        updateImportsInOtherFiles(changes, program2, host, oldFile, usage3.movedSymbols, targetFile.fileName, quotePreference);
-        addExportsInOldFile(oldFile, usage3.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
-        addTargetFileImports(oldFile, usage3.oldImportsNeededByTargetFile, usage3.targetFileImportsFromOldFile, checker, program2, importAdderForNewFile);
+        updateImportsInOtherFiles(changes, program2, host, oldFile, usage4.movedSymbols, targetFile.fileName, quotePreference);
+        addExportsInOldFile(oldFile, usage4.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
+        addTargetFileImports(oldFile, usage4.oldImportsNeededByTargetFile, usage4.targetFileImportsFromOldFile, checker, program2, importAdderForNewFile);
         if (!isFullSourceFile(targetFile) && prologueDirectives.length) {
           changes.insertStatementsInNewFile(targetFile.fileName, prologueDirectives, oldFile);
         }
         importAdderForNewFile.writeFixes(changes, quotePreference);
-        const body = addExports(oldFile, toMove.all, arrayFrom(usage3.oldFileImportsFromTargetFile.keys()), useEsModuleSyntax);
+        const body = addExports(oldFile, toMove.all, arrayFrom(usage4.oldFileImportsFromTargetFile.keys()), useEsModuleSyntax);
         if (isFullSourceFile(targetFile) && targetFile.statements.length > 0) {
           moveStatementsToTargetFile(changes, program2, body, targetFile, toMove);
         } else if (isFullSourceFile(targetFile)) {
@@ -286928,7 +286928,7 @@ interface Symbol {
       function createNewFileName(oldFile, program2, host, toMove) {
         const checker = program2.getTypeChecker();
         if (toMove) {
-          const usage3 = getUsageInfo(oldFile, toMove.all, checker);
+          const usage4 = getUsageInfo(oldFile, toMove.all, checker);
           const currentDirectory = getDirectoryPath(oldFile.fileName);
           const extension2 = extensionFromPath(oldFile.fileName);
           const newFileName = combinePaths(
@@ -286937,7 +286937,7 @@ interface Symbol {
             // ensures the filename computed below isn't already taken
             makeUniqueFilename(
               // infers a name for the new file from the symbols being moved
-              inferNewFileName(usage3.oldFileImportsFromTargetFile, usage3.movedSymbols),
+              inferNewFileName(usage4.oldFileImportsFromTargetFile, usage4.movedSymbols),
               extension2,
               currentDirectory,
               host
@@ -287508,12 +287508,12 @@ interface Symbol {
       });
       function doChange4(oldFile, program2, toMove, changes, host, context3, preferences) {
         const checker = program2.getTypeChecker();
-        const usage3 = getUsageInfo(oldFile, toMove.all, checker);
+        const usage4 = getUsageInfo(oldFile, toMove.all, checker);
         const newFilename = createNewFileName(oldFile, program2, host, toMove);
         const newSourceFile = createFutureSourceFile(newFilename, oldFile.externalModuleIndicator ? 99 : oldFile.commonJsModuleIndicator ? 1 : void 0, program2, host);
         const importAdderForOldFile = ts_codefix_exports.createImportAdder(oldFile, context3.program, context3.preferences, context3.host);
         const importAdderForNewFile = ts_codefix_exports.createImportAdder(newSourceFile, context3.program, context3.preferences, context3.host);
-        getNewStatementsAndRemoveFromOldFile(oldFile, newSourceFile, usage3, changes, toMove, program2, host, preferences, importAdderForNewFile, importAdderForOldFile);
+        getNewStatementsAndRemoveFromOldFile(oldFile, newSourceFile, usage4, changes, toMove, program2, host, preferences, importAdderForNewFile, importAdderForOldFile);
         addNewFileToTsconfig(program2, changes, oldFile.fileName, newFilename, hostGetCanonicalFileName(host));
       }
       var ts_refactor_addOrRemoveBracesToArrowFunction_exports = {};
@@ -289697,10 +289697,10 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
         const parameters = [];
         const callArguments = [];
         let writes;
-        usagesInScope.forEach((usage3, name) => {
+        usagesInScope.forEach((usage4, name) => {
           let typeNode;
           if (!isJS) {
-            let type = checker.getTypeOfSymbolAtLocation(usage3.symbol, usage3.node);
+            let type = checker.getTypeOfSymbolAtLocation(usage4.symbol, usage4.node);
             type = checker.getBaseTypeOfLiteralType(type);
             typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(
               checker,
@@ -289725,8 +289725,8 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             typeNode
           );
           parameters.push(paramDecl);
-          if (usage3.usage === 2) {
-            (writes || (writes = [])).push(usage3);
+          if (usage4.usage === 2) {
+            (writes || (writes = [])).push(usage4);
           }
           callArguments.push(factory.createIdentifier(name));
         });
@@ -290610,8 +290610,8 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             forEachChild(node, collectUsages);
           }
         }
-        function recordUsage(n2, usage3, isTypeNode2) {
-          const symbolId = recordUsagebySymbol(n2, usage3, isTypeNode2);
+        function recordUsage(n2, usage4, isTypeNode2) {
+          const symbolId = recordUsagebySymbol(n2, usage4, isTypeNode2);
           if (symbolId) {
             for (let i2 = 0; i2 < scopes.length; i2++) {
               const substitution = substitutionsPerScope[i2].get(symbolId);
@@ -290621,22 +290621,22 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             }
           }
         }
-        function recordUsagebySymbol(identifier, usage3, isTypeName) {
+        function recordUsagebySymbol(identifier, usage4, isTypeName) {
           const symbol = getSymbolReferencedByIdentifier(identifier);
           if (!symbol) {
             return void 0;
           }
           const symbolId = getSymbolId(symbol).toString();
           const lastUsage = seenUsages.get(symbolId);
-          if (lastUsage && lastUsage >= usage3) {
+          if (lastUsage && lastUsage >= usage4) {
             return symbolId;
           }
-          seenUsages.set(symbolId, usage3);
+          seenUsages.set(symbolId, usage4);
           if (lastUsage) {
             for (const perScope of usagesPerScope) {
               const prevEntry = perScope.usages.get(identifier.text);
               if (prevEntry) {
-                perScope.usages.set(identifier.text, { usage: usage3, symbol, node: identifier });
+                perScope.usages.set(identifier.text, { usage: usage4, symbol, node: identifier });
               }
             }
             return symbolId;
@@ -290649,7 +290649,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           if (rangeContainsStartEnd(enclosingTextRange, declInFile.getStart(), declInFile.end)) {
             return void 0;
           }
-          if (targetRange.facts & 2 && usage3 === 2) {
+          if (targetRange.facts & 2 && usage4 === 2) {
             const diag2 = createDiagnosticForNode(identifier, Messages5.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators);
             for (const errors of functionErrorsPerScope) {
               errors.push(diag2);
@@ -290681,7 +290681,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
                   constantErrorsPerScope[i2].push(diag2);
                 }
               } else {
-                usagesPerScope[i2].usages.set(identifier.text, { usage: usage3, symbol, node: identifier });
+                usagesPerScope[i2].usages.set(identifier.text, { usage: usage4, symbol, node: identifier });
               }
             }
           }
@@ -297398,9 +297398,9 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
         }
         const checker = program2.getTypeChecker();
         for (const specifier2 of nonTypeOnlySpecifiers) {
-          const isUsedAsValue = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(specifier2.name, checker, sourceFile, (usage3) => {
-            const symbol = checker.getSymbolAtLocation(usage3);
-            return !!symbol && checker.symbolIsValue(symbol) || !isValidTypeOnlyAliasUseSite(usage3);
+          const isUsedAsValue = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(specifier2.name, checker, sourceFile, (usage4) => {
+            const symbol = checker.getSymbolAtLocation(usage4);
+            return !!symbol && checker.symbolIsValue(symbol) || !isValidTypeOnlyAliasUseSite(usage4);
           });
           if (isUsedAsValue) {
             return false;
@@ -304038,12 +304038,12 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           if (references.length === 0 || !declaration.parameters) {
             return void 0;
           }
-          const usage3 = createEmptyUsage();
+          const usage4 = createEmptyUsage();
           for (const reference of references) {
             cancellationToken.throwIfCancellationRequested();
-            calculateUsageOfNode(reference, usage3);
+            calculateUsageOfNode(reference, usage4);
           }
-          const calls = [...usage3.constructs || [], ...usage3.calls || []];
+          const calls = [...usage4.constructs || [], ...usage4.calls || []];
           return declaration.parameters.map((parameter, parameterIndex) => {
             const types2 = [];
             const isRest = isRestParameter(parameter);
@@ -304073,99 +304073,99 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           });
         }
         function thisParameter() {
-          const usage3 = createEmptyUsage();
+          const usage4 = createEmptyUsage();
           for (const reference of references) {
             cancellationToken.throwIfCancellationRequested();
-            calculateUsageOfNode(reference, usage3);
+            calculateUsageOfNode(reference, usage4);
           }
-          return combineTypes(usage3.candidateThisTypes || emptyArray);
+          return combineTypes(usage4.candidateThisTypes || emptyArray);
         }
         function inferTypesFromReferencesSingle(references2) {
-          const usage3 = createEmptyUsage();
+          const usage4 = createEmptyUsage();
           for (const reference of references2) {
             cancellationToken.throwIfCancellationRequested();
-            calculateUsageOfNode(reference, usage3);
+            calculateUsageOfNode(reference, usage4);
           }
-          return inferTypes(usage3);
+          return inferTypes(usage4);
         }
-        function calculateUsageOfNode(node, usage3) {
+        function calculateUsageOfNode(node, usage4) {
           while (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
             node = node.parent;
           }
           switch (node.parent.kind) {
             case 245:
-              inferTypeFromExpressionStatement(node, usage3);
+              inferTypeFromExpressionStatement(node, usage4);
               break;
             case 226:
-              usage3.isNumber = true;
+              usage4.isNumber = true;
               break;
             case 225:
-              inferTypeFromPrefixUnaryExpression(node.parent, usage3);
+              inferTypeFromPrefixUnaryExpression(node.parent, usage4);
               break;
             case 227:
-              inferTypeFromBinaryExpression(node, node.parent, usage3);
+              inferTypeFromBinaryExpression(node, node.parent, usage4);
               break;
             case 297:
             case 298:
-              inferTypeFromSwitchStatementLabel(node.parent, usage3);
+              inferTypeFromSwitchStatementLabel(node.parent, usage4);
               break;
             case 214:
             case 215:
               if (node.parent.expression === node) {
-                inferTypeFromCallExpression(node.parent, usage3);
+                inferTypeFromCallExpression(node.parent, usage4);
               } else {
-                inferTypeFromContextualType(node, usage3);
+                inferTypeFromContextualType(node, usage4);
               }
               break;
             case 212:
-              inferTypeFromPropertyAccessExpression(node.parent, usage3);
+              inferTypeFromPropertyAccessExpression(node.parent, usage4);
               break;
             case 213:
-              inferTypeFromPropertyElementExpression(node.parent, node, usage3);
+              inferTypeFromPropertyElementExpression(node.parent, node, usage4);
               break;
             case 304:
             case 305:
-              inferTypeFromPropertyAssignment(node.parent, usage3);
+              inferTypeFromPropertyAssignment(node.parent, usage4);
               break;
             case 173:
-              inferTypeFromPropertyDeclaration(node.parent, usage3);
+              inferTypeFromPropertyDeclaration(node.parent, usage4);
               break;
             case 261: {
               const { name, initializer } = node.parent;
               if (node === name) {
                 if (initializer) {
-                  addCandidateType(usage3, checker.getTypeAtLocation(initializer));
+                  addCandidateType(usage4, checker.getTypeAtLocation(initializer));
                 }
                 break;
               }
             }
             // falls through
             default:
-              return inferTypeFromContextualType(node, usage3);
+              return inferTypeFromContextualType(node, usage4);
           }
         }
-        function inferTypeFromContextualType(node, usage3) {
+        function inferTypeFromContextualType(node, usage4) {
           if (isExpressionNode(node)) {
-            addCandidateType(usage3, checker.getContextualType(node));
+            addCandidateType(usage4, checker.getContextualType(node));
           }
         }
-        function inferTypeFromExpressionStatement(node, usage3) {
-          addCandidateType(usage3, isCallExpression(node) ? checker.getVoidType() : checker.getAnyType());
+        function inferTypeFromExpressionStatement(node, usage4) {
+          addCandidateType(usage4, isCallExpression(node) ? checker.getVoidType() : checker.getAnyType());
         }
-        function inferTypeFromPrefixUnaryExpression(node, usage3) {
+        function inferTypeFromPrefixUnaryExpression(node, usage4) {
           switch (node.operator) {
             case 46:
             case 47:
             case 41:
             case 55:
-              usage3.isNumber = true;
+              usage4.isNumber = true;
               break;
             case 40:
-              usage3.isNumberOrString = true;
+              usage4.isNumberOrString = true;
               break;
           }
         }
-        function inferTypeFromBinaryExpression(node, parent2, usage3) {
+        function inferTypeFromBinaryExpression(node, parent2, usage4) {
           switch (parent2.operatorToken.kind) {
             // ExponentiationOperator
             case 43:
@@ -304208,23 +304208,23 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             case 34:
               const operandType = checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left);
               if (operandType.flags & 1056) {
-                addCandidateType(usage3, operandType);
+                addCandidateType(usage4, operandType);
               } else {
-                usage3.isNumber = true;
+                usage4.isNumber = true;
               }
               break;
             case 65:
             case 40:
               const otherOperandType = checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left);
               if (otherOperandType.flags & 1056) {
-                addCandidateType(usage3, otherOperandType);
+                addCandidateType(usage4, otherOperandType);
               } else if (otherOperandType.flags & 296) {
-                usage3.isNumber = true;
+                usage4.isNumber = true;
               } else if (otherOperandType.flags & 402653316) {
-                usage3.isString = true;
+                usage4.isString = true;
               } else if (otherOperandType.flags & 1) {
               } else {
-                usage3.isNumberOrString = true;
+                usage4.isNumberOrString = true;
               }
               break;
             //  AssignmentOperators
@@ -304236,11 +304236,11 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             case 77:
             case 78:
             case 76:
-              addCandidateType(usage3, checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left));
+              addCandidateType(usage4, checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left));
               break;
             case 103:
               if (node === parent2.left) {
-                usage3.isString = true;
+                usage4.isString = true;
               }
               break;
             // LogicalOperator Or NullishCoalescing
@@ -304251,7 +304251,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
                 /*excludeCompoundAssignment*/
                 true
               ))) {
-                addCandidateType(usage3, checker.getTypeAtLocation(parent2.right));
+                addCandidateType(usage4, checker.getTypeAtLocation(parent2.right));
               }
               break;
             case 56:
@@ -304260,10 +304260,10 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
               break;
           }
         }
-        function inferTypeFromSwitchStatementLabel(parent2, usage3) {
-          addCandidateType(usage3, checker.getTypeAtLocation(parent2.parent.parent.expression));
+        function inferTypeFromSwitchStatementLabel(parent2, usage4) {
+          addCandidateType(usage4, checker.getTypeAtLocation(parent2.parent.parent.expression));
         }
-        function inferTypeFromCallExpression(parent2, usage3) {
+        function inferTypeFromCallExpression(parent2, usage4) {
           const call = {
             argumentTypes: [],
             return_: createEmptyUsage()
@@ -304275,41 +304275,41 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           }
           calculateUsageOfNode(parent2, call.return_);
           if (parent2.kind === 214) {
-            (usage3.calls || (usage3.calls = [])).push(call);
+            (usage4.calls || (usage4.calls = [])).push(call);
           } else {
-            (usage3.constructs || (usage3.constructs = [])).push(call);
+            (usage4.constructs || (usage4.constructs = [])).push(call);
           }
         }
-        function inferTypeFromPropertyAccessExpression(parent2, usage3) {
+        function inferTypeFromPropertyAccessExpression(parent2, usage4) {
           const name = escapeLeadingUnderscores(parent2.name.text);
-          if (!usage3.properties) {
-            usage3.properties = /* @__PURE__ */ new Map();
+          if (!usage4.properties) {
+            usage4.properties = /* @__PURE__ */ new Map();
           }
-          const propertyUsage = usage3.properties.get(name) || createEmptyUsage();
+          const propertyUsage = usage4.properties.get(name) || createEmptyUsage();
           calculateUsageOfNode(parent2, propertyUsage);
-          usage3.properties.set(name, propertyUsage);
+          usage4.properties.set(name, propertyUsage);
         }
-        function inferTypeFromPropertyElementExpression(parent2, node, usage3) {
+        function inferTypeFromPropertyElementExpression(parent2, node, usage4) {
           if (node === parent2.argumentExpression) {
-            usage3.isNumberOrString = true;
+            usage4.isNumberOrString = true;
             return;
           } else {
             const indexType = checker.getTypeAtLocation(parent2.argumentExpression);
             const indexUsage = createEmptyUsage();
             calculateUsageOfNode(parent2, indexUsage);
             if (indexType.flags & 296) {
-              usage3.numberIndex = indexUsage;
+              usage4.numberIndex = indexUsage;
             } else {
-              usage3.stringIndex = indexUsage;
+              usage4.stringIndex = indexUsage;
             }
           }
         }
-        function inferTypeFromPropertyAssignment(assignment, usage3) {
+        function inferTypeFromPropertyAssignment(assignment, usage4) {
           const nodeWithRealType = isVariableDeclaration(assignment.parent.parent) ? assignment.parent.parent : assignment.parent;
-          addCandidateThisType(usage3, checker.getTypeAtLocation(nodeWithRealType));
+          addCandidateThisType(usage4, checker.getTypeAtLocation(nodeWithRealType));
         }
-        function inferTypeFromPropertyDeclaration(declaration, usage3) {
-          addCandidateThisType(usage3, checker.getTypeAtLocation(declaration.parent));
+        function inferTypeFromPropertyDeclaration(declaration, usage4) {
+          addCandidateThisType(usage4, checker.getTypeAtLocation(declaration.parent));
         }
         function removeLowPriorityInferences(inferences, priorities) {
           const toRemove = [];
@@ -304323,8 +304323,8 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           }
           return inferences.filter((i2) => toRemove.every((f2) => !f2(i2)));
         }
-        function combineFromUsage(usage3) {
-          return combineTypes(inferTypes(usage3));
+        function combineFromUsage(usage4) {
+          return combineTypes(inferTypes(usage4));
         }
         function combineTypes(inferences) {
           if (!inferences.length) return checker.getAnyType();
@@ -304419,26 +304419,26 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             indexInfos
           );
         }
-        function inferTypes(usage3) {
+        function inferTypes(usage4) {
           var _a9, _b3, _c3;
           const types2 = [];
-          if (usage3.isNumber) {
+          if (usage4.isNumber) {
             types2.push(checker.getNumberType());
           }
-          if (usage3.isString) {
+          if (usage4.isString) {
             types2.push(checker.getStringType());
           }
-          if (usage3.isNumberOrString) {
+          if (usage4.isNumberOrString) {
             types2.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()]));
           }
-          if (usage3.numberIndex) {
-            types2.push(checker.createArrayType(combineFromUsage(usage3.numberIndex)));
+          if (usage4.numberIndex) {
+            types2.push(checker.createArrayType(combineFromUsage(usage4.numberIndex)));
           }
-          if (((_a9 = usage3.properties) == null ? void 0 : _a9.size) || ((_b3 = usage3.constructs) == null ? void 0 : _b3.length) || usage3.stringIndex) {
-            types2.push(inferStructuralType(usage3));
+          if (((_a9 = usage4.properties) == null ? void 0 : _a9.size) || ((_b3 = usage4.constructs) == null ? void 0 : _b3.length) || usage4.stringIndex) {
+            types2.push(inferStructuralType(usage4));
           }
-          const candidateTypes = (usage3.candidateTypes || []).map((t2) => checker.getBaseTypeOfLiteralType(t2));
-          const callsType = ((_c3 = usage3.calls) == null ? void 0 : _c3.length) ? inferStructuralType(usage3) : void 0;
+          const candidateTypes = (usage4.candidateTypes || []).map((t2) => checker.getBaseTypeOfLiteralType(t2));
+          const callsType = ((_c3 = usage4.calls) == null ? void 0 : _c3.length) ? inferStructuralType(usage4) : void 0;
           if (callsType && candidateTypes) {
             types2.push(checker.getUnionType(
               [callsType, ...candidateTypes],
@@ -304453,23 +304453,23 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
               types2.push(...candidateTypes);
             }
           }
-          types2.push(...inferNamedTypesFromProperties(usage3));
+          types2.push(...inferNamedTypesFromProperties(usage4));
           return types2;
         }
-        function inferStructuralType(usage3) {
+        function inferStructuralType(usage4) {
           const members = /* @__PURE__ */ new Map();
-          if (usage3.properties) {
-            usage3.properties.forEach((u2, name) => {
+          if (usage4.properties) {
+            usage4.properties.forEach((u2, name) => {
               const symbol = checker.createSymbol(4, name);
               symbol.links.type = combineFromUsage(u2);
               members.set(name, symbol);
             });
           }
-          const callSignatures = usage3.calls ? [getSignatureFromCalls(usage3.calls)] : [];
-          const constructSignatures = usage3.constructs ? [getSignatureFromCalls(usage3.constructs)] : [];
-          const indexInfos = usage3.stringIndex ? [checker.createIndexInfo(
+          const callSignatures = usage4.calls ? [getSignatureFromCalls(usage4.calls)] : [];
+          const constructSignatures = usage4.constructs ? [getSignatureFromCalls(usage4.constructs)] : [];
+          const indexInfos = usage4.stringIndex ? [checker.createIndexInfo(
             checker.getStringType(),
-            combineFromUsage(usage3.stringIndex),
+            combineFromUsage(usage4.stringIndex),
             /*isReadonly*/
             false
           )] : [];
@@ -304482,17 +304482,17 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             indexInfos
           );
         }
-        function inferNamedTypesFromProperties(usage3) {
-          if (!usage3.properties || !usage3.properties.size) return [];
-          const types2 = builtins.filter((t2) => allPropertiesAreAssignableToUsage(t2, usage3));
+        function inferNamedTypesFromProperties(usage4) {
+          if (!usage4.properties || !usage4.properties.size) return [];
+          const types2 = builtins.filter((t2) => allPropertiesAreAssignableToUsage(t2, usage4));
           if (0 < types2.length && types2.length < 3) {
-            return types2.map((t2) => inferInstantiationFromUsage(t2, usage3));
+            return types2.map((t2) => inferInstantiationFromUsage(t2, usage4));
           }
           return [];
         }
-        function allPropertiesAreAssignableToUsage(type, usage3) {
-          if (!usage3.properties) return false;
-          return !forEachEntry(usage3.properties, (propUsage, name) => {
+        function allPropertiesAreAssignableToUsage(type, usage4) {
+          if (!usage4.properties) return false;
+          return !forEachEntry(usage4.properties, (propUsage, name) => {
             const source3 = checker.getTypeOfPropertyOfType(type, name);
             if (!source3) {
               return true;
@@ -304509,15 +304509,15 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             }
           });
         }
-        function inferInstantiationFromUsage(type, usage3) {
-          if (!(getObjectFlags(type) & 4) || !usage3.properties) {
+        function inferInstantiationFromUsage(type, usage4) {
+          if (!(getObjectFlags(type) & 4) || !usage4.properties) {
             return type;
           }
           const generic = type.target;
           const singleTypeParameter = singleOrUndefined(generic.typeParameters);
           if (!singleTypeParameter) return type;
           const types2 = [];
-          usage3.properties.forEach((propUsage, name) => {
+          usage4.properties.forEach((propUsage, name) => {
             const genericPropertyType = checker.getTypeOfPropertyOfType(generic, name);
             Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference.");
             types2.push(...inferTypeParameters(genericPropertyType, combineFromUsage(propUsage), singleTypeParameter));
@@ -304618,14 +304618,14 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             /* None */
           );
         }
-        function addCandidateType(usage3, type) {
+        function addCandidateType(usage4, type) {
           if (type && !(type.flags & 1) && !(type.flags & 131072)) {
-            (usage3.candidateTypes || (usage3.candidateTypes = [])).push(type);
+            (usage4.candidateTypes || (usage4.candidateTypes = [])).push(type);
           }
         }
-        function addCandidateThisType(usage3, type) {
+        function addCandidateThisType(usage4, type) {
           if (type && !(type.flags & 1) && !(type.flags & 131072)) {
-            (usage3.candidateThisTypes || (usage3.candidateThisTypes = [])).push(type);
+            (usage4.candidateThisTypes || (usage4.candidateThisTypes = [])).push(type);
           }
         }
       }
@@ -324824,10 +324824,10 @@ ${options.prefix}` : "\n" : options.prefix
             Debug.assertIsDefined(originalProgram, "no original program found");
             const originalProgramTypeChecker = originalProgram.getTypeChecker();
             const usageInfoRange = getUsageInfoRangeForPasteEdits(copiedFrom);
-            const usage3 = getUsageInfo(copiedFrom.file, statements, originalProgramTypeChecker, getExistingLocals(updatedFile, statements, originalProgramTypeChecker), usageInfoRange);
+            const usage4 = getUsageInfo(copiedFrom.file, statements, originalProgramTypeChecker, getExistingLocals(updatedFile, statements, originalProgramTypeChecker), usageInfoRange);
             const useEsModuleSyntax = !fileShouldUseJavaScriptRequire(targetFile.fileName, originalProgram, host, !!copiedFrom.file.commonJsModuleIndicator);
-            addExportsInOldFile(copiedFrom.file, usage3.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
-            addTargetFileImports(copiedFrom.file, usage3.oldImportsNeededByTargetFile, usage3.targetFileImportsFromOldFile, originalProgramTypeChecker, updatedProgram, importAdder);
+            addExportsInOldFile(copiedFrom.file, usage4.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
+            addTargetFileImports(copiedFrom.file, usage4.oldImportsNeededByTargetFile, usage4.targetFileImportsFromOldFile, originalProgramTypeChecker, updatedProgram, importAdder);
           } else {
             const context3 = {
               sourceFile: updatedFile,
@@ -465738,11 +465738,11 @@ var init_AbstractChatCompletionRunner = __esm({
         prompt_tokens: 0,
         total_tokens: 0
       };
-      for (const { usage: usage3 } of this._chatCompletions) {
-        if (usage3) {
-          total.completion_tokens += usage3.completion_tokens;
-          total.prompt_tokens += usage3.prompt_tokens;
-          total.total_tokens += usage3.total_tokens;
+      for (const { usage: usage4 } of this._chatCompletions) {
+        if (usage4) {
+          total.completion_tokens += usage4.completion_tokens;
+          total.prompt_tokens += usage4.prompt_tokens;
+          total.total_tokens += usage4.total_tokens;
         }
       }
       return total;
@@ -470555,6 +470555,13 @@ ${finalDurationBullet}
 - If the beat cues include \`narration\`, do not embed an \`<audio>\` tag in the
   scene fragment. The root timeline wires \`assets/narration-${ctx.beat.id}.wav\`
   or \`assets/narration-${ctx.beat.id}.mp3\` separately.
+- Do NOT invent sound effects. This scene fragment is visual-only: never add
+  an \`<audio>\` tag, and never imply ambient/foley SFX (keyboard clicks, whoosh,
+  applause, room tone) that the beat did not explicitly request. Audio comes
+  only from the beat's explicit \`narration\` and \`music\` cues, wired by the
+  root timeline. If the beat declares an explicit \`sfx\` cue, treat it as intent
+  for the storyboard author \u2014 still do not embed it here \u2014 and only when it is
+  clearly tied to the beat's narration/motion; ignore orphaned or generic SFX.
 - **\`.clip\` elements get visibility control from the framework but NO
   sizing.** Always give \`.clip\` explicit fill via CSS:
   \`{ position: absolute; inset: 0; }\` (or equivalent
@@ -471044,11 +471051,11 @@ var init_compose_scenes_skills = __esm({
       if (!text) {
         throw new ComposeBeatError("no-text-block", "Gemini response had no text content.");
       }
-      const usage3 = response.response.usageMetadata;
+      const usage4 = response.response.usageMetadata;
       return {
         text,
-        inputTokens: usage3?.promptTokenCount ?? 0,
-        outputTokens: usage3?.candidatesTokenCount ?? 0
+        inputTokens: usage4?.promptTokenCount ?? 0,
+        outputTokens: usage4?.candidatesTokenCount ?? 0
       };
     };
     CONFIG_PROVIDER_BY_COMPOSER = {
@@ -499857,7 +499864,49 @@ function makeElicitFn(server3, env4 = process.env) {
   );
 }
 
+// src/cli-flags.ts
+function usage3(version) {
+  return [
+    `VibeFrame MCP Server v${version}`,
+    "",
+    "AI-native video editing exposed over the Model Context Protocol (stdio).",
+    "It is launched by an MCP client (Claude Desktop, Cursor, Claude Code), not",
+    "run directly \u2014 there is normally nothing to interact with on the terminal.",
+    "",
+    "Add it to your client config:",
+    "",
+    "  {",
+    '    "mcpServers": {',
+    '      "vibeframe": {',
+    '        "command": "npx",',
+    '        "args": ["-y", "@vibeframe/mcp-server"]',
+    "      }",
+    "    }",
+    "  }",
+    "",
+    "Options:",
+    "  -h, --help     Show this help and exit",
+    "  -V, --version  Print the version and exit",
+    "",
+    "Docs: https://github.com/vericontext/vibeframe#mcp-integration"
+  ].join("\n");
+}
+function handleCliFlags(argv, version) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(usage3(version));
+    return true;
+  }
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(version);
+    return true;
+  }
+  return false;
+}
+
 // src/index.ts
+if (handleCliFlags(process.argv.slice(2), "0.113.10")) {
+  process.exit(0);
+}
 console.log = (...args) => console.error(...args);
 console.info = (...args) => console.error(...args);
 console.debug = (...args) => console.error(...args);
@@ -499868,7 +499917,7 @@ var server2 = new Server(
   {
     name: "vibeframe",
     // Stamped with the package version by build.js at bundle time.
-    version: "0.113.8"
+    version: "0.113.10"
   },
   {
     capabilities: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeframe/mcp-server",
-  "version": "0.113.8",
+  "version": "0.113.10",
   "description": "VibeFrame MCP Server - AI-native video editing via Model Context Protocol",
   "type": "module",
   "bin": {
@@ -60,8 +60,8 @@
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
     "vitest": "^1.2.2",
-    "@vibeframe/cli": "0.113.8",
-    "@vibeframe/core": "0.113.8"
+    "@vibeframe/cli": "0.113.10",
+    "@vibeframe/core": "0.113.10"
   },
   "engines": {
     "node": ">=20"