gt 2.14.33 → 2.14.34

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.14.34
+
+### Patch Changes
+
+- [#1385](https://github.com/generaltranslation/gt/pull/1385) [`bcb2b91`](https://github.com/generaltranslation/gt/commit/bcb2b91581d1edb134a451f9713c3a899e32282a) Thanks [@bgub](https://github.com/bgub)! - Warn when duplicate source update IDs include hashless entries.
+
+- [#1379](https://github.com/generaltranslation/gt/pull/1379) [`e88fd39`](https://github.com/generaltranslation/gt/commit/e88fd399683868d5af1fe2b0ba2974fe5b17d7a7) Thanks [@bgub](https://github.com/bgub)! - Tighten public and API metadata types, and handle metadata entries without hashes in the CLI.
+
+- Updated dependencies [[`e88fd39`](https://github.com/generaltranslation/gt/commit/e88fd399683868d5af1fe2b0ba2974fe5b17d7a7), [`95f852a`](https://github.com/generaltranslation/gt/commit/95f852ae086ac79d2c446f4d3072d8fd18688796)]:
+  - generaltranslation@8.2.13
+  - @generaltranslation/python-extractor@0.2.19
+
 ## 2.14.33
 
 ### Patch Changes

package/dist/cli/inline.js

@@ -77,7 +77,7 @@ export class InlineCLI extends BaseCLI {
             if (id) {
                 newData[id] = source;
             }
-            else {
+            else if (hash) {
                 newData[hash] = source;
             }
         }

package/dist/formats/files/collectFiles.js

@@ -29,7 +29,7 @@ export async function collectFiles(options, settings, library) {
                     fileData[id] = source;
                     fileMetadata[id] = metadata;
                 }
-                else {
+                else if (hash) {
                     fileData[hash] = source;
                     fileMetadata[hash] = metadata;
                 }

package/dist/formats/json/extractJson.js

@@ -80,7 +80,8 @@ export function extractJson(localContent, inputPath, options, targetLocale, defa
                 const extractedValues = flattenJsonWithStringFilter(sourceItem, sourceObjectOptions.include);
                 // Use default locale key
                 const outputKey = i < defaultKeys.length ? defaultKeys[i] : targetEntries[i][0];
-                compositeResult[sourceObjectPointer][outputKey] = extractedValues;
+                compositeResult[sourceObjectPointer][outputKey] =
+                    extractedValues;
             }
         }
         else {
@@ -89,8 +90,9 @@ export function extractJson(localContent, inputPath, options, targetLocale, defa
                 logger.warn(`Source object value is not an object at path: ${sourceObjectPointer}`);
                 continue;
             }
+            const sourceObjectRecord = sourceObjectValue;
             // Find the matching item for the target locale
-            const matchingTargetItem = findMatchingItemObject(canonicalTargetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            const matchingTargetItem = findMatchingItemObject(canonicalTargetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
             if (!matchingTargetItem.sourceItem) {
                 logger.warn(`No matching item found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
                 continue;

package/dist/formats/json/flattenJson.d.ts

@@ -1,14 +1,15 @@
+import type { JSONValue } from '../../types/data/json.js';
 /**
  * Flattens a JSON object according to a list of JSON paths.
  * @param json - The JSON object to flatten
  * @param jsonPaths - The list of JSON paths to flatten
  * @returns A mapping of json pointers to their values
  */
-export declare function flattenJson(json: any, jsonPaths: string[]): Record<string, any>;
+export declare function flattenJson(json: unknown, jsonPaths: string[]): Record<string, JSONValue>;
 /**
  * Flattens a JSON object according to a list of JSON paths, only including strings
  * @param json - The JSON object to flatten
  * @param jsonPaths - The list of JSON paths to flatten
  * @returns A mapping of json pointers to their values
  */
-export declare function flattenJsonWithStringFilter(json: any, jsonPaths: string[]): Record<string, any>;
+export declare function flattenJsonWithStringFilter(json: unknown, jsonPaths: string[]): Record<string, string>;

package/dist/formats/json/flattenJson.js

@@ -1,5 +1,5 @@
-import { JSONPath } from 'jsonpath-plus';
 import { logger } from '../../console/logger.js';
+import { getJSONPathMatches } from './jsonPath.js';
 /**
  * Flattens a JSON object according to a list of JSON paths.
  * @param json - The JSON object to flatten
@@ -10,13 +10,7 @@ export function flattenJson(json, jsonPaths) {
     const extractedJson = {};
     for (const jsonPath of jsonPaths) {
         try {
-            const results = JSONPath({
-                json,
-                path: jsonPath,
-                resultType: 'all',
-                flatten: true,
-                wrap: true,
-            });
+            const results = getJSONPathMatches(json, jsonPath);
             if (!results || results.length === 0) {
                 continue;
             }
@@ -40,13 +34,7 @@ export function flattenJsonWithStringFilter(json, jsonPaths) {
     const extractedJson = {};
     for (const jsonPath of jsonPaths) {
         try {
-            const results = JSONPath({
-                json,
-                path: jsonPath,
-                resultType: 'all',
-                flatten: true,
-                wrap: true,
-            });
+            const results = getJSONPathMatches(json, jsonPath);
             if (!results || results.length === 0) {
                 continue;
             }

package/dist/formats/json/jsonPath.d.ts

@@ -0,0 +1,8 @@
+import type { JSONValue } from '../../types/data/json.js';
+export type JSONPathMatch = {
+    pointer: string;
+    value: JSONValue;
+    parentProperty: string | number | null;
+};
+export declare function getJSONPathMatches(json: JSONValue, path: string): JSONPathMatch[] | undefined;
+export declare function getJSONPathValues(json: JSONValue, path: string): JSONValue[] | undefined;

package/dist/formats/json/jsonPath.js

@@ -0,0 +1,19 @@
+import { JSONPath } from 'jsonpath-plus';
+const jsonPathOptions = (json, path) => ({
+    json,
+    path,
+    flatten: true,
+    wrap: true,
+});
+export function getJSONPathMatches(json, path) {
+    return JSONPath({
+        ...jsonPathOptions(json, path),
+        resultType: 'all',
+    });
+}
+export function getJSONPathValues(json, path) {
+    return JSONPath({
+        ...jsonPathOptions(json, path),
+        resultType: 'value',
+    });
+}

package/dist/formats/json/jsonPointer.d.ts

@@ -0,0 +1,4 @@
+import type { JSONValue } from '../../types/data/json.js';
+export declare function getJSONPointerValue(json: JSONValue, pointer: string): JSONValue;
+export declare function setJSONPointerValue(json: JSONValue, pointer: string, value: JSONValue): void;
+export declare function deleteJSONPointerValue(json: JSONValue, pointer: string): void;

package/dist/formats/json/jsonPointer.js

@@ -0,0 +1,20 @@
+import JSONPointer from 'jsonpointer';
+export function getJSONPointerValue(json, pointer) {
+    return JSONPointer.get(json, pointer);
+}
+export function setJSONPointerValue(json, pointer, value) {
+    JSONPointer.set(json, pointer, value);
+}
+export function deleteJSONPointerValue(json, pointer) {
+    const lastSlash = pointer.lastIndexOf('/');
+    if (lastSlash < 0)
+        return;
+    const parentPointer = pointer.substring(0, lastSlash) || '';
+    const leafKey = pointer.substring(lastSlash + 1);
+    const parent = parentPointer
+        ? getJSONPointerValue(json, parentPointer)
+        : json;
+    if (parent && typeof parent === 'object' && leafKey in parent) {
+        delete parent[leafKey];
+    }
+}

package/dist/formats/json/mergeJson.d.ts

@@ -1,4 +1,5 @@
 import { AdditionalOptions, SourceObjectOptions } from '../../types/index.js';
+import type { JSONValue } from '../../types/data/json.js';
 export declare function mergeJson(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
     translatedContent: string;
     targetLocale: string;
@@ -10,4 +11,4 @@ export declare function mergeJson(originalContent: string, inputPath: string, op
  * @param targetLocale - The target locale
  * @param defaultLocale - The default locale
  */
-export declare function applyTransformations(sourceItem: any, transform: SourceObjectOptions['transform'], targetLocale: string, defaultLocale: string): void;
+export declare function applyTransformations(sourceItem: JSONValue, transform: SourceObjectOptions['transform'], targetLocale: string, defaultLocale: string): void;

package/dist/formats/json/mergeJson.js

@@ -1,12 +1,12 @@
-import JSONPointer from 'jsonpointer';
 import { exitSync } from '../../console/logging.js';
 import { logger } from '../../console/logger.js';
 import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getIdentifyingLocaleProperty, getSourceObjectOptionsArray, validateJsonSchema, } from './utils.js';
-import { JSONPath } from 'jsonpath-plus';
 import { getLocaleProperties } from 'generaltranslation';
 import { replaceLocalePlaceholders } from '../utils.js';
 import { gt } from '../../utils/gt.js';
 import { applyStructuralTransforms, unapplyStructuralTransforms, } from './transformJson.js';
+import { getJSONPathMatches, getJSONPathValues } from './jsonPath.js';
+import { getJSONPointerValue, setJSONPointerValue } from './jsonPointer.js';
 export function mergeJson(originalContent, inputPath, options, targets, defaultLocale, localeOrder = []) {
     const jsonSchema = validateJsonSchema(options, inputPath);
     if (!jsonSchema) {
@@ -39,10 +39,10 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
             const translatedJson = JSON.parse(target.translatedContent);
             for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) {
                 try {
-                    const value = JSONPointer.get(mergedJson, jsonPointer);
+                    const value = getJSONPointerValue(mergedJson, jsonPointer);
                     if (!value)
                         continue;
-                    JSONPointer.set(mergedJson, jsonPointer, translatedValue);
+                    setJSONPointerValue(mergedJson, jsonPointer, translatedValue);
                 }
                 catch {
                     /* empty */
@@ -146,18 +146,18 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                     const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(useCanonicalLocaleKeys
                         ? gt.resolveCanonicalLocale(target.targetLocale)
                         : target.targetLocale, sourceObjectPointer, sourceObjectOptions);
-                    JSONPointer.set(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
-                    for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetItem || {})) {
+                    setJSONPointerValue(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
+                    for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries((targetItem || {}))) {
                         const valueToSet = useCanonicalLocaleKeys &&
                             defaultLocaleKeyPointer &&
                             translatedKeyJsonPointer === defaultLocaleKeyPointer
                             ? targetLocaleKeyProperty
                             : translatedValue;
                         try {
-                            const value = JSONPointer.get(mutatedSourceItem, translatedKeyJsonPointer);
+                            const value = getJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer);
                             if (!value)
                                 continue;
-                            JSONPointer.set(mutatedSourceItem, translatedKeyJsonPointer, valueToSet);
+                            setJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer, valueToSet);
                         }
                         catch {
                             /* empty */
@@ -176,7 +176,7 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
             const filteredSourceObjectValue = sourceObjectValue.filter((_, index) => !indiciesToRemove.has(index));
             // 10. Add all items to the original JSON
             filteredSourceObjectValue.push(...itemsToAdd);
-            JSONPointer.set(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, canonicalLocaleOrder, sourceObjectPointer, canonicalDefaultLocale));
+            setJSONPointerValue(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, canonicalLocaleOrder, sourceObjectPointer, canonicalDefaultLocale));
         }
         else {
             // Validate type
@@ -184,8 +184,9 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 logger.error(`Source object value is not an object at path: ${sourceObjectPointer}`);
                 return exitSync(1);
             }
+            const sourceObjectRecord = sourceObjectValue;
             // Validate localeProperty
-            const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
             // Validate source item exists
             if (!matchingDefaultLocaleItem.sourceItem) {
                 logger.error(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
@@ -209,12 +210,12 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 // 2. Find the source item for the target locale
                 const matchingTargetItem = findMatchingItemObject(useCanonicalLocaleKeys
                     ? gt.resolveCanonicalLocale(target.targetLocale)
-                    : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+                    : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
                 const mutateSourceItemKey = matchingTargetItem.keyParentProperty;
                 // If the source item is a string, use the translated string directly
                 if (typeof defaultLocaleSourceItem === 'string') {
                     if (typeof targetItems === 'string') {
-                        sourceObjectValue[mutateSourceItemKey] = targetItems;
+                        sourceObjectRecord[mutateSourceItemKey] = targetItems;
                     }
                     // If no translation found, leave the locale slot unchanged
                     continue;
@@ -224,7 +225,9 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 const mutateSourceItem = structuredClone(defaultLocaleSourceItem);
                 // 3. Merge the target items with the source item (if there are transformations to perform)
                 const mergedItems = {
-                    ...(sourceObjectOptions.transform ? defaultLocaleSourceItem : {}),
+                    ...(sourceObjectOptions.transform
+                        ? defaultLocaleSourceItem
+                        : {}),
                     ...targetItems,
                 };
                 // 4. Validate that the mergedItems is not empty
@@ -235,10 +238,10 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 // 5. Override the source item with the translated values
                 for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(mergedItems || {})) {
                     try {
-                        const value = JSONPointer.get(mutateSourceItem, translatedKeyJsonPointer);
+                        const value = getJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer);
                         if (!value)
                             continue;
-                        JSONPointer.set(mutateSourceItem, translatedKeyJsonPointer, translatedValue);
+                        setJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer, translatedValue);
                     }
                     catch {
                         /* empty */
@@ -247,9 +250,9 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 // 6. Apply additional mutations to the sourceItem
                 applyTransformations(mutateSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
                 // 7. Merge the source item with the original JSON
-                sourceObjectValue[mutateSourceItemKey] = mutateSourceItem;
+                sourceObjectRecord[mutateSourceItemKey] = mutateSourceItem;
             }
-            JSONPointer.set(mergedJson, sourceObjectPointer, sourceObjectValue);
+            setJSONPointerValue(mergedJson, sourceObjectPointer, sourceObjectValue);
         }
     }
     if (jsonSchema.structuralTransform && jsonSchema.composite) {
@@ -265,13 +268,7 @@ function sortByLocaleOrder(items, sourceObjectOptions, localeOrder, sourceObject
     const itemsWithLocale = items.map((item) => {
         let localeValue;
         try {
-            const values = JSONPath({
-                json: item,
-                path: sourceObjectOptions.key,
-                resultType: 'value',
-                flatten: true,
-                wrap: true,
-            });
+            const values = getJSONPathValues(item, sourceObjectOptions.key);
             const value = values?.[0];
             if (typeof value === 'string') {
                 localeValue = value;
@@ -350,13 +347,7 @@ export function applyTransformations(sourceItem, transform, targetLocale, defaul
             typeof transformOptions.replace !== 'string') {
             continue;
         }
-        const results = JSONPath({
-            json: sourceItem,
-            path: transformPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
+        const results = getJSONPathMatches(sourceItem, transformPath);
         if (!results || results.length === 0) {
             continue;
         }
@@ -379,7 +370,7 @@ export function applyTransformations(sourceItem, transform, targetLocale, defaul
                 result.value = replaceString;
             }
             // Update the actual sourceItem using JSONPointer
-            JSONPointer.set(sourceItem, result.pointer, result.value);
+            setJSONPointerValue(sourceItem, result.pointer, result.value);
         });
     }
 }

package/dist/formats/json/parseJson.js

@@ -1,9 +1,9 @@
 import { flattenJson, flattenJsonWithStringFilter } from './flattenJson.js';
-import { JSONPath } from 'jsonpath-plus';
 import { exitSync } from '../../console/logging.js';
 import { logger } from '../../console/logger.js';
 import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, validateJsonSchema, } from './utils.js';
 import { applyStructuralTransforms } from './transformJson.js';
+import { getJSONPathMatches } from './jsonPath.js';
 // Parse a JSON file according to a JSON schema
 export function parseJson(content, filePath, options, defaultLocale, filterStrings = true) {
     const jsonSchema = validateJsonSchema(options, filePath);
@@ -63,13 +63,7 @@ export function parseJson(content, filePath, options, defaultLocale, filterStrin
                 const matchingItemsToTranslate = [];
                 for (const include of sourceObjectOptions.include) {
                     try {
-                        const matchingItems = JSONPath({
-                            json: sourceItem,
-                            path: include,
-                            resultType: 'all',
-                            flatten: true,
-                            wrap: true,
-                        });
+                        const matchingItems = getJSONPathMatches(sourceItem, include);
                         if (matchingItems) {
                             matchingItemsToTranslate.push(...matchingItems);
                         }
@@ -81,10 +75,7 @@ export function parseJson(content, filePath, options, defaultLocale, filterStrin
                 // Filter out the key pointer
                 sourceItemsToTranslate[arrayPointer] = Object.fromEntries(matchingItemsToTranslate
                     .filter((item) => item.pointer !== keyPointer)
-                    .map((item) => [
-                    item.pointer,
-                    item.value,
-                ]));
+                    .map((item) => [item.pointer, item.value]));
             }
             // Add the items to translate to the result
             sourceObjectsToTranslate[sourceObjectPointer] = sourceItemsToTranslate;
@@ -96,8 +87,9 @@ export function parseJson(content, filePath, options, defaultLocale, filterStrin
                 logger.error(`Source object value is not an object at path: ${sourceObjectPointer}`);
                 return exitSync(1);
             }
+            const sourceObjectRecord = sourceObjectValue;
             // Validate localeProperty
-            const matchingItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            const matchingItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
             // Validate source item exists
             if (!matchingItem.sourceItem) {
                 logger.error(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);

package/dist/formats/json/transformJson.d.ts

@@ -1,13 +1,14 @@
 import { StructuralTransform, SourceObjectOptions } from '../../types/index.js';
+import type { JSONValue } from '../../types/data/json.js';
 /**
  * Apply structural transforms: copy values from sourcePointer to destinationPointer
  * for each entry resolved by the composite config's parent paths.
  * Mutates json in-place.
  */
-export declare function applyStructuralTransforms(json: any, transforms: StructuralTransform[], compositeConfig: Record<string, SourceObjectOptions>): any;
+export declare function applyStructuralTransforms(json: JSONValue, transforms: StructuralTransform[], compositeConfig: Record<string, SourceObjectOptions>): JSONValue;
 /**
  * Unapply structural transforms: delete the value at destinationPointer
  * for each entry resolved by the composite config's parent paths.
  * Leaves sourcePointer untouched. Mutates json in-place.
  */
-export declare function unapplyStructuralTransforms(json: any, transforms: StructuralTransform[], compositeConfig: Record<string, SourceObjectOptions>): any;
+export declare function unapplyStructuralTransforms(json: JSONValue, transforms: StructuralTransform[], compositeConfig: Record<string, SourceObjectOptions>): JSONValue;

package/dist/formats/json/transformJson.js

@@ -1,5 +1,5 @@
-import JSONPointer from 'jsonpointer';
-import { JSONPath } from 'jsonpath-plus';
+import { getJSONPathMatches } from './jsonPath.js';
+import { deleteJSONPointerValue, getJSONPointerValue, setJSONPointerValue, } from './jsonPointer.js';
 /**
  * Derive entry parent paths from composite sourceObjectPaths by trimming the last segment.
  * e.g., "$.*.translations" → "$.*"
@@ -22,13 +22,7 @@ function deriveEntryPaths(compositeConfig) {
 export function applyStructuralTransforms(json, transforms, compositeConfig) {
     const entryPaths = deriveEntryPaths(compositeConfig);
     for (const entryPath of entryPaths) {
-        const entries = JSONPath({
-            json,
-            path: entryPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
+        const entries = getJSONPathMatches(json, entryPath);
         if (!entries)
             continue;
         for (const entry of entries) {
@@ -36,9 +30,9 @@ export function applyStructuralTransforms(json, transforms, compositeConfig) {
             if (typeof entryObj !== 'object' || entryObj === null)
                 continue;
             for (const transform of transforms) {
-                const sourceValue = JSONPointer.get(entryObj, transform.sourcePointer);
+                const sourceValue = getJSONPointerValue(entryObj, transform.sourcePointer);
                 if (sourceValue !== undefined) {
-                    JSONPointer.set(entryObj, transform.destinationPointer, sourceValue);
+                    setJSONPointerValue(entryObj, transform.destinationPointer, sourceValue);
                 }
             }
         }
@@ -53,13 +47,7 @@ export function applyStructuralTransforms(json, transforms, compositeConfig) {
 export function unapplyStructuralTransforms(json, transforms, compositeConfig) {
     const entryPaths = deriveEntryPaths(compositeConfig);
     for (const entryPath of entryPaths) {
-        const entries = JSONPath({
-            json,
-            path: entryPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
+        const entries = getJSONPathMatches(json, entryPath);
         if (!entries)
             continue;
         for (const entry of entries) {
@@ -67,20 +55,8 @@ export function unapplyStructuralTransforms(json, transforms, compositeConfig) {
             if (typeof entryObj !== 'object' || entryObj === null)
                 continue;
             for (const transform of transforms) {
-                // Navigate to parent of destinationPointer and delete the leaf key
-                const pointer = transform.destinationPointer;
-                const lastSlash = pointer.lastIndexOf('/');
-                if (lastSlash < 0)
-                    continue;
-                const parentPointer = pointer.substring(0, lastSlash) || '';
-                const leafKey = pointer.substring(lastSlash + 1);
                 try {
-                    const parent = parentPointer
-                        ? JSONPointer.get(entryObj, parentPointer)
-                        : entryObj;
-                    if (parent && typeof parent === 'object' && leafKey in parent) {
-                        delete parent[leafKey];
-                    }
+                    deleteJSONPointerValue(entryObj, transform.destinationPointer);
                 }
                 catch {
                     /* entry may not have the destination path */

package/dist/formats/json/utils.d.ts

@@ -1,12 +1,18 @@
 import { AdditionalOptions, JsonSchema, SourceObjectOptions } from '../../types/index.js';
-export declare function findMatchingItemArray(locale: string, sourceObjectOptions: SourceObjectOptions, sourceObjectPointer: string, sourceObjectValue: any): Record<string, {
-    sourceItem: any;
-    keyParentProperty: string;
+import type { JSONObject, JSONValue } from '../../types/data/json.js';
+type MatchingArrayItem = {
+    sourceItem: JSONValue;
+    keyParentProperty: string | number;
     keyPointer: string;
     index: number;
+};
+type SourceObjectPointerMap = Record<string, {
+    sourceObjectValue: JSONValue;
+    sourceObjectOptions: SourceObjectOptions;
 }>;
-export declare function findMatchingItemObject(locale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions, sourceObjectValue: any): {
-    sourceItem: any | undefined;
+export declare function findMatchingItemArray(locale: string, sourceObjectOptions: SourceObjectOptions, sourceObjectPointer: string, sourceObjectValue: JSONValue[]): Record<string, MatchingArrayItem>;
+export declare function findMatchingItemObject(locale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions, sourceObjectValue: JSONObject): {
+    sourceItem: JSONValue | undefined;
     keyParentProperty: string;
 };
 /**
@@ -40,10 +46,7 @@ export declare function getSourceObjectOptionsObject(defaultLocale: string, sour
  */
 export declare function generateSourceObjectPointers(jsonSchema: {
     [sourceObjectPath: string]: SourceObjectOptions;
-}, originalJson: any): Record<string, {
-    sourceObjectValue: any;
-    sourceObjectOptions: SourceObjectOptions;
-}>;
+}, originalJson: JSONValue): SourceObjectPointerMap;
 /**
  * Validate the json schema for composite or include schemas
  * @param options - Additional options containing jsonSchema config
@@ -56,4 +59,5 @@ export declare function validateJsonSchema(options: AdditionalOptions, filePath:
  * Detect unsupported fields (e.g. $ref) in Mintlify docs.json files.
  * Logs a warning listing the fields found.
  */
-export declare function detectMintlifyUnsupportedFields(json: any, filePath: string): void;
+export declare function detectMintlifyUnsupportedFields(json: JSONValue, filePath: string): void;
+export {};

package/dist/formats/json/utils.js

@@ -1,11 +1,11 @@
 import { getLocaleProperties } from 'generaltranslation';
 import { exitSync } from '../../console/logging.js';
 import { logger } from '../../console/logger.js';
-import { JSONPath } from 'jsonpath-plus';
 import { flattenJson } from './flattenJson.js';
 import chalk from 'chalk';
 import path from 'node:path';
 import micromatch from 'micromatch';
+import { getJSONPathMatches } from './jsonPath.js';
 const { isMatch } = micromatch;
 // Find the matching source item in an array
 // where the key matches the identifying locale property
@@ -16,13 +16,7 @@ export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectP
     const matchingItems = {};
     for (const [index, item] of sourceObjectValue.entries()) {
         // Get the key candidates
-        const keyCandidates = JSONPath({
-            json: item,
-            path: localeKeyJsonPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
+        const keyCandidates = getJSONPathMatches(item, localeKeyJsonPath);
         if (!keyCandidates) {
             logger.error(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
             return exitSync(1);
@@ -40,10 +34,15 @@ export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectP
             // Validate the key is the identifying locale property
             continue;
         }
+        const keyParentProperty = keyCandidates[0].parentProperty;
+        if (keyParentProperty === null) {
+            logger.error(`Source item at path: ${sourceObjectPointer} has a root-level key match with path: ${localeKeyJsonPath}`);
+            return exitSync(1);
+        }
         // Map the index to the source item
         matchingItems[`/${index}`] = {
             sourceItem: item,
-            keyParentProperty: keyCandidates[0].parentProperty,
+            keyParentProperty,
             keyPointer: keyCandidates[0].pointer,
             index,
         };
@@ -174,15 +173,16 @@ function findMintlifyUnsupportedFields(value, fieldNames, pointer = '') {
         return results;
     }
     // Check if this object contains an unsupported field
+    const objectValue = value;
     for (const field of fieldNames) {
-        if (typeof value[field] === 'string') {
-            return [{ pointer, field, fieldValue: value[field] }];
+        if (typeof objectValue[field] === 'string') {
+            return [{ pointer, field, fieldValue: objectValue[field] }];
         }
     }
     // Recurse into child properties
     const results = [];
-    for (const key of Object.keys(value)) {
-        results.push(...findMintlifyUnsupportedFields(value[key], fieldNames, `${pointer}/${key}`));
+    for (const key of Object.keys(objectValue)) {
+        results.push(...findMintlifyUnsupportedFields(objectValue[key], fieldNames, `${pointer}/${key}`));
     }
     return results;
 }

package/dist/fs/copyFile.d.ts

@@ -1,7 +1,9 @@
-import { Settings } from '../types/index.js';
+import type { Settings } from '../types/index.js';
+type CopyFileSettings = Pick<Settings, 'defaultLocale' | 'locales' | 'options'>;
 /**
  * Copy a file to target locale without translation
  *
  * This is a naive approach, does not allow for wild cards
  */
-export default function copyFile(settings: Settings): Promise<void>;
+export default function copyFile(settings: CopyFileSettings): Promise<void>;
+export {};

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.14.33";
+export declare const PACKAGE_VERSION = "2.14.34";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.14.33';
+export const PACKAGE_VERSION = '2.14.34';

package/dist/translation/parse.js

@@ -59,23 +59,42 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
     updates = [...updates, ...newUpdates];
     // Metadata addition and validation
     const idHashMap = new Map();
+    const hashlessIds = new Set();
+    const warnedHashlessDuplicateIds = new Set();
     const duplicateIds = new Set();
+    const warnHashlessDuplicateId = (id) => {
+        if (warnedHashlessDuplicateIds.has(id))
+            return;
+        warnings.push(`Duplicate id ${chalk.blue(id)} includes at least one entry without a hash. Hashless duplicate IDs cannot be compared, and later entries may overwrite earlier entries.`);
+        warnedHashlessDuplicateIds.add(id);
+    };
     updates = updates.map((update) => {
-        if (!update.metadata.id)
+        const { id, hash } = update.metadata;
+        if (!id)
             return update;
-        const existingHash = idHashMap.get(update.metadata.id);
-        if (existingHash) {
-            if (existingHash !== update.metadata.hash) {
-                errors.push(`Hashes don't match on two components with the same id: ${chalk.blue(update.metadata.id)}. Check your ${chalk.green('<T>')} tags and dictionary entries and make sure you're not accidentally duplicating IDs.`);
-                duplicateIds.add(update.metadata.id);
+        if (!hash) {
+            if (hashlessIds.has(id) || idHashMap.has(id)) {
+                warnHashlessDuplicateId(id);
+            }
+            hashlessIds.add(id);
+            return update;
+        }
+        if (hashlessIds.has(id)) {
+            warnHashlessDuplicateId(id);
+        }
+        const existingHash = idHashMap.get(id);
+        if (existingHash !== undefined) {
+            if (existingHash !== hash) {
+                errors.push(`Hashes don't match on two components with the same id: ${chalk.blue(id)}. Check your ${chalk.green('<T>')} tags and dictionary entries and make sure you're not accidentally duplicating IDs.`);
+                duplicateIds.add(id);
             }
         }
         else {
-            idHashMap.set(update.metadata.id, update.metadata.hash);
+            idHashMap.set(id, hash);
         }
         return update;
     });
     // Filter out updates with duplicate IDs
-    updates = updates.filter((update) => !duplicateIds.has(update.metadata.id));
+    updates = updates.filter((update) => !update.metadata.id || !duplicateIds.has(update.metadata.id));
     return { updates, errors, warnings };
 }

package/dist/types/data/json.d.ts

@@ -1,6 +1,5 @@
-type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+export type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
 export type JSONObject = {
     [key: string]: JSONValue;
 };
 export type JSONArray = JSONValue[];
-export {};

package/dist/types/index.d.ts

@@ -206,6 +206,10 @@ export type Settings = {
     branchOptions: BranchOptions;
     sharedStaticAssets?: SharedStaticAssetsConfig;
 };
+export type StaticLocalizationFiles = Pick<Settings['files'], 'placeholderPaths' | 'resolvedPaths'> & Partial<Pick<Settings['files'], 'transformPaths' | 'transformFormats'>>;
+export type StaticLocalizationSettings = Pick<Settings, 'defaultLocale' | 'locales' | 'options'> & {
+    files?: StaticLocalizationFiles | null;
+};
 export type BranchOptions = {
     currentBranch?: string;
     autoDetectBranches?: boolean;

package/dist/utils/addExplicitAnchorIds.d.ts

@@ -1,3 +1,7 @@
+import type { AdditionalOptions } from '../types/index.js';
+type AnchorIdSettings = {
+    options?: Pick<AdditionalOptions, 'experimentalAddHeaderAnchorIds'>;
+};
 /**
  * Represents a heading with its position and metadata
  */
@@ -14,7 +18,7 @@ export declare function extractHeadingInfo(mdxContent: string): HeadingInfo[];
 /**
  * Applies anchor IDs to translated content based on source heading mapping
  */
-export declare function addExplicitAnchorIds(translatedContent: string, sourceHeadingMap: HeadingInfo[], settings?: any, sourcePath?: string, translatedPath?: string, fileTypeHint?: 'md' | 'mdx'): {
+export declare function addExplicitAnchorIds(translatedContent: string, sourceHeadingMap: HeadingInfo[], settings?: AnchorIdSettings, sourcePath?: string, translatedPath?: string, fileTypeHint?: 'md' | 'mdx'): {
     content: string;
     hasChanges: boolean;
     addedIds: Array<{
@@ -22,3 +26,4 @@ export declare function addExplicitAnchorIds(translatedContent: string, sourceHe
         id: string;
     }>;
 };
+export {};

package/dist/utils/localizeRelativeAssets.d.ts

@@ -1,8 +1,9 @@
-import { Settings } from '../types/index.js';
+import type { StaticLocalizationSettings } from '../types/index.js';
 type RewriteResult = {
     content: string;
     hasChanges: boolean;
 };
+export type RelativeAssetSettings = StaticLocalizationSettings;
 export declare function localizeRelativeAssetsForContent(content: string, sourcePath: string, targetPath: string, cwd: string): RewriteResult;
-export default function localizeRelativeAssets(settings: Settings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
+export default function localizeRelativeAssets(settings: RelativeAssetSettings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
 export {};

package/dist/utils/localizeRelativeAssets.js

@@ -81,24 +81,25 @@ export function localizeRelativeAssetsForContent(content, sourcePath, targetPath
         return newPath + suffix;
     };
     visit(ast, (node) => {
-        if (node.type === 'image' && typeof node.url === 'string') {
-            const newUrl = maybeRewrite(node.url);
+        const assetNode = node;
+        if (assetNode.type === 'image' && typeof assetNode.url === 'string') {
+            const newUrl = maybeRewrite(assetNode.url);
             if (newUrl)
-                node.url = newUrl;
+                assetNode.url = newUrl;
             return;
         }
-        if ((node.type === 'mdxJsxFlowElement' ||
-            node.type === 'mdxJsxTextElement') &&
-            node.name === 'img' &&
-            Array.isArray(node.attributes)) {
-            for (const attr of node.attributes) {
-                if (attr &&
-                    attr.type === 'mdxJsxAttribute' &&
-                    attr.name === 'src' &&
-                    typeof attr.value === 'string') {
-                    const newUrl = maybeRewrite(attr.value);
+        if ((assetNode.type === 'mdxJsxFlowElement' ||
+            assetNode.type === 'mdxJsxTextElement') &&
+            assetNode.name === 'img' &&
+            Array.isArray(assetNode.attributes)) {
+            for (const attr of assetNode.attributes) {
+                const attribute = attr;
+                if (attribute.type === 'mdxJsxAttribute' &&
+                    attribute.name === 'src' &&
+                    typeof attribute.value === 'string') {
+                    const newUrl = maybeRewrite(attribute.value);
                     if (newUrl)
-                        attr.value = newUrl;
+                        attribute.value = newUrl;
                 }
             }
         }
@@ -136,7 +137,7 @@ export default async function localizeRelativeAssets(settings, targetLocales, in
     }
     const { resolvedPaths: sourceFiles } = settings.files;
     const locales = targetLocales || settings.locales;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.files.transformFormats, settings.locales, settings.defaultLocale);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths ?? {}, settings.files.transformFormats ?? {}, settings.locales, settings.defaultLocale);
     const cwd = process.cwd();
     const processPromises = Object.entries(fileMapping)
         .filter(([locale]) => locales.includes(locale))

package/dist/utils/localizeStaticImports.d.ts

@@ -1,4 +1,5 @@
-import { Settings } from '../types/index.js';
+import type { StaticLocalizationSettings } from '../types/index.js';
+export type StaticImportSettings = StaticLocalizationSettings;
 /**
  * Localizes static imports in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,4 +13,4 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticImports(settings: Settings, includeFiles?: Set<string>): Promise<void>;
+export default function localizeStaticImports(settings: StaticImportSettings, includeFiles?: Set<string>): Promise<void>;

package/dist/utils/localizeStaticImports.js

@@ -28,7 +28,7 @@ export default async function localizeStaticImports(settings, includeFiles) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.files.transformFormats, settings.locales, settings.defaultLocale);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths ?? {}, settings.files.transformFormats ?? {}, settings.locales, settings.defaultLocale);
     // Process all file types at once with a single call
     const processPromises = [];
     // First, process default locale files (from source files)

package/dist/utils/localizeStaticUrls.d.ts

@@ -1,4 +1,5 @@
-import { Settings } from '../types/index.js';
+import type { StaticLocalizationSettings } from '../types/index.js';
+export type StaticUrlSettings = StaticLocalizationSettings;
 /**
  * Localizes static urls in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,7 +13,7 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticUrls(settings: Settings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
+export default function localizeStaticUrls(settings: StaticUrlSettings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
 /**
  * Main URL transformation function that delegates to specific scenarios
  */

package/dist/utils/localizeStaticUrls.js

@@ -31,7 +31,7 @@ export default async function localizeStaticUrls(settings, targetLocales, includ
     const { resolvedPaths: sourceFiles } = settings.files;
     // Use filtered locales if provided, otherwise use all locales
     const locales = targetLocales || settings.locales;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.files.transformFormats, settings.locales, // Always use all locales for mapping, filter later
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths ?? {}, settings.files.transformFormats ?? {}, settings.locales, // Always use all locales for mapping, filter later
     settings.defaultLocale);
     // Process all file types at once with a single call
     const processPromises = [];

package/dist/utils/sharedStaticAssets.js

@@ -38,11 +38,9 @@ async function moveFile(src, dest) {
         await fs.promises.rename(src, dest);
     }
     catch (err) {
+        const code = err?.code;
         // Fallback to copy+unlink for cross-device or existing files
-        if (err &&
-            (err.code === 'EXDEV' ||
-                err.code === 'EEXIST' ||
-                err.code === 'ENOTEMPTY')) {
+        if (code === 'EXDEV' || code === 'EEXIST' || code === 'ENOTEMPTY') {
             const data = await fs.promises.readFile(src);
             await ensureDir(path.dirname(dest));
             await fs.promises.writeFile(dest, data);
@@ -53,7 +51,7 @@ async function moveFile(src, dest) {
                 // Ignore cleanup errors for source files that were already moved.
             }
         }
-        else if (err && err.code === 'ENOENT') {
+        else if (code === 'ENOENT') {
             // already moved or missing; ignore
             return;
         }
@@ -148,32 +146,33 @@ function rewriteMdxContent(content, filePath, pathMap) {
         return null;
     };
     visit(ast, (node) => {
+        const assetNode = node;
         // Markdown image: ![alt](url)
-        if (node.type === 'image' && typeof node.url === 'string') {
-            const newUrl = maybeRewrite(node.url);
+        if (assetNode.type === 'image' && typeof assetNode.url === 'string') {
+            const newUrl = maybeRewrite(assetNode.url);
             if (newUrl)
-                node.url = newUrl;
+                assetNode.url = newUrl;
             return;
         }
         // Markdown link: [text](url) — useful for PDFs and other downloadable assets
-        if (node.type === 'link' && typeof node.url === 'string') {
-            const newUrl = maybeRewrite(node.url);
+        if (assetNode.type === 'link' && typeof assetNode.url === 'string') {
+            const newUrl = maybeRewrite(assetNode.url);
             if (newUrl)
-                node.url = newUrl;
+                assetNode.url = newUrl;
             return;
         }
         // MDX <img src="..." />
-        if ((node.type === 'mdxJsxFlowElement' ||
-            node.type === 'mdxJsxTextElement') &&
-            Array.isArray(node.attributes)) {
-            for (const attr of node.attributes) {
-                if (attr &&
-                    attr.type === 'mdxJsxAttribute' &&
-                    (attr.name === 'src' || attr.name === 'href') &&
-                    typeof attr.value === 'string') {
-                    const newUrl = maybeRewrite(attr.value);
+        if ((assetNode.type === 'mdxJsxFlowElement' ||
+            assetNode.type === 'mdxJsxTextElement') &&
+            Array.isArray(assetNode.attributes)) {
+            for (const attr of assetNode.attributes) {
+                const attribute = attr;
+                if (attribute.type === 'mdxJsxAttribute' &&
+                    (attribute.name === 'src' || attribute.name === 'href') &&
+                    typeof attribute.value === 'string') {
+                    const newUrl = maybeRewrite(attribute.value);
                     if (newUrl)
-                        attr.value = newUrl;
+                        attribute.value = newUrl;
                 }
             }
         }

package/dist/workflows/steps/BranchStep.d.ts

@@ -1,13 +1,16 @@
 import { WorkflowStep } from './WorkflowStep.js';
-import { GT } from 'generaltranslation';
-import { Settings } from '../../types/index.js';
+import type { GT } from 'generaltranslation';
+import type { Settings } from '../../types/index.js';
 import { BranchData } from '../../types/branch.js';
+type BranchStepClient = Pick<GT, 'queryBranchData' | 'createBranch'>;
+type BranchStepSettings = Pick<Settings, 'branchOptions'>;
 export declare class BranchStep extends WorkflowStep<null, BranchData | null> {
     private spinner;
     private branchData;
     private settings;
     private gt;
-    constructor(gt: GT, settings: Settings);
+    constructor(gt: BranchStepClient, settings: BranchStepSettings);
     run(): Promise<BranchData | null>;
     wait(): Promise<void>;
 }
+export {};

package/dist/workflows/steps/UploadSourcesStep.d.ts

@@ -1,9 +1,11 @@
 import type { FileToUpload } from 'generaltranslation/types';
 import { WorkflowStep } from './WorkflowStep.js';
-import { GT } from 'generaltranslation';
-import { Settings } from '../../types/index.js';
+import type { GT } from 'generaltranslation';
+import type { Settings } from '../../types/index.js';
 import { BranchData } from '../../types/branch.js';
 import type { FileReference } from 'generaltranslation/types';
+type UploadSourcesClient = Pick<GT, 'queryFileData' | 'getOrphanedFiles' | 'processFileMoves' | 'uploadSourceFiles'>;
+type UploadSourcesSettings = Pick<Settings, 'defaultLocale' | 'modelProvider'>;
 export declare class UploadSourcesStep extends WorkflowStep<{
     files: FileToUpload[];
     branchData: BranchData;
@@ -12,7 +14,7 @@ export declare class UploadSourcesStep extends WorkflowStep<{
     private settings;
     private spinner;
     private result;
-    constructor(gt: GT, settings: Settings);
+    constructor(gt: UploadSourcesClient, settings: UploadSourcesSettings);
     /**
      * Detects file moves by comparing local files against orphaned files.
      * A move is detected when a local file has the same versionId (content hash)
@@ -25,3 +27,4 @@ export declare class UploadSourcesStep extends WorkflowStep<{
     }): Promise<FileReference[]>;
     wait(): Promise<void>;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.14.33",
+  "version": "2.14.34",
   "main": "dist/index.js",
   "bin": "bin/main.js",
   "files": [
@@ -111,8 +111,8 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "@generaltranslation/python-extractor": "0.2.18",
-    "generaltranslation": "8.2.12",
+    "@generaltranslation/python-extractor": "0.2.19",
+    "generaltranslation": "8.2.13",
     "gt-remark": "1.0.7"
   },
   "devDependencies": {
@@ -123,7 +123,7 @@
     "@types/mdast": "^4.0.0",
     "@types/micromatch": "^4.0.9",
     "@types/mock-require": "^2.0.3",
-    "@types/node": "^22.5.1",
+    "@types/node": "^22.13.5",
     "@types/react": "^18.3.4",
     "@types/resolve": "^1.20.2",
     "eslint": "^9.20.0",
@@ -133,14 +133,15 @@
     "prettier": "^3.4.2",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.5.4",
-    "vitest": "^2.0.0"
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
   },
   "scripts": {
-    "build": "node scripts/generate-version.js && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions",
+    "generate-version": "node scripts/generate-version.js",
+    "build": "pnpm run generate-version && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions",
     "build:clean": "sh ../../scripts/clean.sh && pnpm bin:restore && rm -rf binaries && pnpm run build",
     "build:release": "pnpm run build:clean",
-    "build:bin": "node scripts/generate-version.js && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions && sh scripts/build-exe.sh all",
+    "build:bin": "pnpm run generate-version && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions && sh scripts/build-exe.sh all",
     "build:bin:clean": "sh ../../scripts/clean.sh && rm -rf binaries && pnpm run build:bin",
     "build:bin:release": "pnpm run build:bin:clean && pnpm run build:bin",
     "build:bin:darwin-x64": "sh scripts/build-exe.sh darwin-x64",
@@ -148,8 +149,8 @@
     "build:bin:linux-x64": "sh scripts/build-exe.sh linux-x64",
     "build:bin:linux-arm64": "sh scripts/build-exe.sh linux-arm64",
     "build:bin:windows-x64": "sh scripts/build-exe.sh windows-x64",
-    "test": "vitest run --config=./vitest.config.ts",
-    "test:watch": "vitest --config=./vitest.config.ts",
+    "test": "pnpm run generate-version && vitest run --config=./vitest.config.ts",
+    "test:watch": "pnpm run generate-version && vitest --config=./vitest.config.ts",
     "release": "pnpm run release:normal && pnpm run release:bin",
     "release:normal": "pnpm run build:clean && pnpm publish",
     "release:bin": "pnpm run bin:prep && pnpm run build:bin:clean && pnpm publish --tag bin --no-git-checks && pnpm run bin:restore && pnpm run build:clean",
@@ -158,6 +159,6 @@
     "release:latest": "pnpm run build:clean && pnpm publish --tag latest",
     "bin:restore": "node scripts/restore-package-json.js",
     "bin:prep": "node scripts/prepare-binary-release.js",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "pnpm run generate-version && tsc --noEmit"
   }
 }