gt 2.10.4 → 2.10.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.10.5
+
+### Patch Changes
+
+- [#1116](https://github.com/generaltranslation/gt/pull/1116) [`31d7229`](https://github.com/generaltranslation/gt/commit/31d7229e3893b712e2007369e8b3d219bcc9bde8) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Adding v2 of `gt-lock.json`
+
 ## 2.10.4
 
 ### Patch Changes

package/dist/api/collectUserEditDiffs.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getDownloadedVersions } from '../fs/config/downloadedVersions.js';
+import { readLockfile, } from '../fs/config/downloadedVersions.js';
 import { createFileMapping } from '../formats/files/fileMapping.js';
 import { getGitUnifiedDiff } from '../utils/gitDiff.js';
 import { gt } from '../utils/gt.js';
@@ -8,26 +8,15 @@ import os from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { hashStringSync } from '../utils/hash.js';
 import { extractJson } from '../formats/json/extractJson.js';
-const findLatestDownloadedVersion = (downloadedVersions, branchId, fileId, locale) => {
-    const versionsForFile = downloadedVersions.entries?.[branchId]?.[fileId] ?? undefined;
-    if (!versionsForFile)
+import { extractYaml } from '../formats/yaml/extractYaml.js';
+const findLatestDownloadedVersion = (entryMap, fileId, locale) => {
+    const entry = entryMap.get(fileId);
+    if (!entry)
         return null;
-    let latest = null;
-    for (const [versionId, locales] of Object.entries(versionsForFile)) {
-        const entry = locales?.[locale];
-        if (!entry)
-            continue;
-        const updatedAt = entry.updatedAt
-            ? Date.parse(entry.updatedAt)
-            : Number.NEGATIVE_INFINITY;
-        const latestUpdatedAt = latest?.entry.updatedAt
-            ? Date.parse(latest.entry.updatedAt)
-            : Number.NEGATIVE_INFINITY;
-        if (!latest || updatedAt > latestUpdatedAt) {
-            latest = { versionId, entry };
-        }
-    }
-    return latest;
+    const translation = entry.translations[locale];
+    if (!translation)
+        return null;
+    return { versionId: entry.versionId, entry: translation };
 };
 /**
  * Collects local user edits by diffing the latest downloaded server translation version
@@ -40,7 +29,7 @@ export async function collectAndSendUserEditDiffs(files, settings) {
         return;
     const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
     const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
+    const { entryMap } = readLockfile(settings);
     const tempDir = path.join(os.tmpdir(), randomUUID());
     if (!fs.existsSync(tempDir))
         fs.mkdirSync(tempDir, { recursive: true });
@@ -52,7 +41,7 @@ export async function collectAndSendUserEditDiffs(files, settings) {
                 continue;
             if (!fs.existsSync(outputPath))
                 continue;
-            const latestDownloaded = findLatestDownloadedVersion(downloadedVersions, uploadedFile.branchId, uploadedFile.fileId, locale);
+            const latestDownloaded = findLatestDownloadedVersion(entryMap, uploadedFile.fileId, locale);
             if (!latestDownloaded)
                 continue;
             const downloadedVersion = latestDownloaded.entry;
@@ -137,6 +126,14 @@ export async function collectAndSendUserEditDiffs(files, settings) {
                             localContent = extractedContent;
                         }
                     }
+                    else if ((c.fileName.endsWith('.yaml') || c.fileName.endsWith('.yml')) &&
+                        settings.options?.yamlSchema &&
+                        c.locale !== settings.defaultLocale) {
+                        const extractedContent = extractYaml(rawLocalContent, c.fileName, settings.options);
+                        if (extractedContent) {
+                            localContent = extractedContent;
+                        }
+                    }
                     collectedDiffs.push({
                         fileName: c.fileName,
                         locale: c.locale,

package/dist/api/downloadFileBatch.js

@@ -5,12 +5,37 @@ import { gt } from '../utils/gt.js';
 import { validateJsonSchema } from '../formats/json/utils.js';
 import { validateYamlSchema } from '../formats/yaml/utils.js';
 import { mergeJson } from '../formats/json/mergeJson.js';
+import { extractJson } from '../formats/json/extractJson.js';
 import mergeYaml from '../formats/yaml/mergeYaml.js';
-import { getDownloadedVersions, saveDownloadedVersions, ensureNestedObject, } from '../fs/config/downloadedVersions.js';
+import { extractYaml } from '../formats/yaml/extractYaml.js';
+import { readLockfile, writeLockfile, findOrCreateEntry, } from '../fs/config/downloadedVersions.js';
 import { recordDownloaded } from '../state/recentDownloads.js';
 import { recordWarning } from '../state/translateWarnings.js';
-import { hashStringSync } from '../utils/hash.js';
 import stringify from 'fast-json-stable-stringify';
+/**
+ * Merges translated content with the current source file for schema-based formats.
+ */
+function mergeWithSource(translatedContent, locale, inputPath, options) {
+    if (!options.options)
+        return translatedContent;
+    const jsonSchema = options.options.jsonSchema
+        ? validateJsonSchema(options.options, inputPath)
+        : null;
+    const yamlSchema = !jsonSchema && options.options.yamlSchema
+        ? validateYamlSchema(options.options, inputPath)
+        : null;
+    if (!jsonSchema && !yamlSchema)
+        return translatedContent;
+    const sourceContent = fs.readFileSync(inputPath, 'utf8');
+    if (!sourceContent)
+        return translatedContent;
+    if (jsonSchema) {
+        return mergeJson(sourceContent, inputPath, options.options, [{ translatedContent, targetLocale: locale }], options.defaultLocale, options.locales)[0];
+    }
+    else {
+        return mergeYaml(sourceContent, inputPath, options.options, [{ translatedContent, targetLocale: locale }], options.defaultLocale)[0];
+    }
+}
 /**
  * Downloads multiple translation files in a single batch request
  * @param files - Array of files to download with their output paths
@@ -20,7 +45,7 @@ import stringify from 'fast-json-stable-stringify';
  */
 export async function downloadFileBatch(fileTracker, files, options, forceDownload = false) {
     // Local record of what version was last downloaded for each fileName:locale
-    const downloadedVersions = getDownloadedVersions(options.configDirectory);
+    const { data: downloadedVersions, entryMap, originalV1, } = readLockfile(options);
     let didUpdateDownloadedLock = false;
     // Create a map of requested file keys to the file object
     const requestedFileMap = new Map(files.map((file) => [
@@ -69,58 +94,37 @@ export async function downloadFileBatch(fileTracker, files, options, forceDownlo
                     fs.mkdirSync(dir, { recursive: true });
                 }
                 // If a local translation already exists for the same source version, skip overwrite
-                const downloadedVersion = downloadedVersions.entries[branchId]?.[fileId]?.[versionId]?.[locale];
+                const existingEntry = entryMap.get(fileId);
+                const downloadedTranslation = existingEntry?.versionId === versionId
+                    ? existingEntry.translations[locale]
+                    : undefined;
                 const fileExists = fs.existsSync(outputPath);
-                let sourceChanged = false;
-                if (downloadedVersion?.sourceHash) {
+                if (!forceDownload && fileExists && downloadedTranslation) {
+                    // For schema-based files, re-merge with current source in case
+                    // non-translatable fields changed (skip the API download, not the merge)
                     try {
-                        const currentSourceContent = fs.readFileSync(inputPath, 'utf8');
-                        const currentSourceHash = hashStringSync(currentSourceContent);
-                        sourceChanged = currentSourceHash !== downloadedVersion.sourceHash;
+                        const existingContent = fs.readFileSync(outputPath, 'utf8');
+                        const jsonExtracted = options.options?.jsonSchema
+                            ? extractJson(existingContent, inputPath, options.options, locale, options.defaultLocale)
+                            : null;
+                        const extracted = jsonExtracted ??
+                            (options.options?.yamlSchema
+                                ? extractYaml(existingContent, inputPath, options.options)
+                                : null);
+                        if (extracted) {
+                            const remerged = mergeWithSource(extracted, locale, inputPath, options);
+                            if (remerged !== existingContent) {
+                                await fs.promises.writeFile(outputPath, remerged);
+                            }
+                        }
                     }
                     catch {
-                        sourceChanged = true;
+                        // If re-merge fails, still count as skipped — not worth failing the download
                     }
-                }
-                if (!forceDownload &&
-                    !sourceChanged &&
-                    fileExists &&
-                    downloadedVersion) {
                     result.skipped.push(requestedFile);
                     continue;
                 }
-                let data = file.data;
-                let sourceContentHash;
-                if (options.options?.jsonSchema && locale) {
-                    const jsonSchema = validateJsonSchema(options.options, inputPath);
-                    if (jsonSchema) {
-                        const originalContent = fs.readFileSync(inputPath, 'utf8');
-                        if (originalContent) {
-                            sourceContentHash = hashStringSync(originalContent);
-                            data = mergeJson(originalContent, inputPath, options.options, [
-                                {
-                                    translatedContent: file.data,
-                                    targetLocale: locale,
-                                },
-                            ], options.defaultLocale, options.locales)[0];
-                        }
-                    }
-                }
-                if (options.options?.yamlSchema && locale) {
-                    const yamlSchema = validateYamlSchema(options.options, inputPath);
-                    if (yamlSchema) {
-                        const originalContent = fs.readFileSync(inputPath, 'utf8');
-                        if (originalContent) {
-                            sourceContentHash = hashStringSync(originalContent);
-                            data = mergeYaml(originalContent, inputPath, options.options, [
-                                {
-                                    translatedContent: file.data,
-                                    targetLocale: locale,
-                                },
-                            ], options.defaultLocale)[0];
-                        }
-                    }
-                }
+                let data = mergeWithSource(file.data, locale, inputPath, options);
                 // If the file is a GTJSON file, stable sort the order and format the data
                 if (file.fileFormat === 'GTJSON') {
                     try {
@@ -144,16 +148,12 @@ export async function downloadFileBatch(fileTracker, files, options, forceDownlo
                     inputPath,
                 });
                 result.successful.push(requestedFile);
-                if (branchId && fileId && versionId && locale) {
-                    ensureNestedObject(downloadedVersions.entries, [
-                        branchId,
-                        fileId,
-                        versionId,
-                        locale,
-                    ]);
-                    downloadedVersions.entries[branchId][fileId][versionId][locale] = {
+                if (fileId && versionId && locale) {
+                    const entry = findOrCreateEntry(entryMap, downloadedVersions.entries, fileId, versionId);
+                    entry.fileName = inputPath;
+                    entry.translations[locale] = {
                         updatedAt: new Date().toISOString(),
-                        ...(sourceContentHash ? { sourceHash: sourceContentHash } : {}),
+                        fileName: outputPath,
                     };
                     didUpdateDownloadedLock = true;
                 }
@@ -173,7 +173,7 @@ export async function downloadFileBatch(fileTracker, files, options, forceDownlo
         }
         // Persist any updates to the downloaded map at the end of a successful cycle
         if (didUpdateDownloadedLock) {
-            saveDownloadedVersions(options.configDirectory, downloadedVersions);
+            writeLockfile(downloadedVersions, originalV1);
             didUpdateDownloadedLock = false;
         }
         return result;
@@ -184,7 +184,7 @@ export async function downloadFileBatch(fileTracker, files, options, forceDownlo
     // Mark all files as failed if we get here
     result.failed = [...requestedFileMap.values()];
     if (didUpdateDownloadedLock) {
-        saveDownloadedVersions(options.configDirectory, downloadedVersions);
+        writeLockfile(downloadedVersions, originalV1);
     }
     return result;
 }

package/dist/formats/yaml/extractYaml.d.ts

@@ -0,0 +1,13 @@
+import { AdditionalOptions } from '../../types/index.js';
+/**
+ * Extracts translated values from a fully merged YAML file back into the
+ * flattened JSON pointer format that mergeYaml expects.
+ * This is the inverse of mergeYaml — it takes a merged YAML document and
+ * extracts only the values at the schema's include paths.
+ *
+ * @param localContent - The full YAML content from the user's local file
+ * @param inputPath - The path to the file (used for matching yamlSchema)
+ * @param options - Additional options containing yamlSchema config
+ * @returns The flattened JSON string of translatable values, or null if no extraction needed
+ */
+export declare function extractYaml(localContent: string, inputPath: string, options: AdditionalOptions): string | null;

package/dist/formats/yaml/extractYaml.js

@@ -0,0 +1,33 @@
+import { logger } from '../../console/logger.js';
+import { validateYamlSchema } from './utils.js';
+import { flattenJsonWithStringFilter } from '../json/flattenJson.js';
+import YAML from 'yaml';
+/**
+ * Extracts translated values from a fully merged YAML file back into the
+ * flattened JSON pointer format that mergeYaml expects.
+ * This is the inverse of mergeYaml — it takes a merged YAML document and
+ * extracts only the values at the schema's include paths.
+ *
+ * @param localContent - The full YAML content from the user's local file
+ * @param inputPath - The path to the file (used for matching yamlSchema)
+ * @param options - Additional options containing yamlSchema config
+ * @returns The flattened JSON string of translatable values, or null if no extraction needed
+ */
+export function extractYaml(localContent, inputPath, options) {
+    const yamlSchema = validateYamlSchema(options, inputPath);
+    if (!yamlSchema || !yamlSchema.include) {
+        return null;
+    }
+    let yaml;
+    try {
+        yaml = YAML.parse(localContent);
+    }
+    catch {
+        logger.error(`Invalid YAML file: ${inputPath}`);
+        return null;
+    }
+    const extracted = flattenJsonWithStringFilter(yaml, yamlSchema.include);
+    if (!Object.keys(extracted).length)
+        return null;
+    return JSON.stringify(extracted);
+}

package/dist/fs/config/downloadedVersions.d.ts

@@ -1,21 +1,60 @@
+import type { Settings } from '../../types/index.js';
+export type DownloadedTranslation = {
+    updatedAt?: string;
+    postProcessHash?: string;
+    fileName?: string;
+};
 export type DownloadedVersionEntry = {
+    fileId: string;
+    versionId: string;
+    fileName?: string;
+    translations: {
+        [locale: string]: DownloadedTranslation;
+    };
+};
+export type DownloadedVersions = {
+    version: 2;
+    branchId: string;
+    entries: DownloadedVersionEntry[];
+};
+export type DownloadedVersionEntryV1 = {
     fileName?: string;
     updatedAt?: string;
     postProcessHash?: string;
     sourceHash?: string;
 };
-export type DownloadedVersions = {
+export type DownloadedVersionsV1 = {
     version: number;
     entries: {
         [branchId: string]: {
             [fileId: string]: {
                 [versionId: string]: {
-                    [locale: string]: DownloadedVersionEntry;
+                    [locale: string]: DownloadedVersionEntryV1;
                 };
             };
         };
     };
 };
-export declare function getDownloadedVersions(configDirectory: string): DownloadedVersions;
-export declare function saveDownloadedVersions(configDirectory: string, lock: DownloadedVersions): void;
-export declare function ensureNestedObject(obj: any, path: string[]): any;
+/**
+ * Reads the lockfile and returns v2 data regardless of the on-disk format.
+ * If the file is v1, `originalV1` contains the full v1 data so that
+ * `writeLockfile` can merge changes back without losing other branches.
+ */
+export declare function readLockfile(settings: Settings): {
+    data: DownloadedVersions;
+    entryMap: EntryMap;
+    originalV1: DownloadedVersionsV1 | null;
+};
+/**
+ * Writes the lockfile. If `originalV1` is provided, merges the current
+ * branch's data back into the v1 structure (preserving other branches)
+ * and writes v1 format. Otherwise writes v2.
+ */
+export declare function writeLockfile(data: DownloadedVersions, originalV1: DownloadedVersionsV1 | null): void;
+export type EntryMap = Map<string, DownloadedVersionEntry>;
+export declare function buildEntryMap(entries: DownloadedVersionEntry[]): EntryMap;
+/**
+ * Finds or creates an entry, keeping the map and backing array in sync.
+ * If the fileId exists but versionId changed, replaces it in-place.
+ */
+export declare function findOrCreateEntry(entryMap: EntryMap, entries: DownloadedVersionEntry[], fileId: string, versionId: string): DownloadedVersionEntry;

package/dist/fs/config/downloadedVersions.js

@@ -1,50 +1,167 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { logger } from '../../console/logger.js';
-// New lock file name, use old name for deletion of legacy lock file
 const GT_LOCK_FILE = 'gt-lock.json';
-const LEGACY_DOWNLOADED_VERSIONS_FILE = 'downloaded-versions.json';
-export function getDownloadedVersions(configDirectory) {
+// ── Conversion helpers ──────────────────────────────────────────────
+function convertV1ToV2(v1, branchId) {
+    const branchEntries = v1.entries?.[branchId];
+    if (!branchEntries) {
+        return { version: 2, branchId, entries: [] };
+    }
+    const entries = [];
+    for (const [fileId, versions] of Object.entries(branchEntries)) {
+        const versionIds = Object.keys(versions);
+        if (versionIds.length === 0)
+            continue;
+        // Pick the versionId with the most recent updatedAt, defaulting to the first
+        let latestVersionId = versionIds[0];
+        let latestTime = 0;
+        for (const [versionId, locales] of Object.entries(versions)) {
+            for (const entry of Object.values(locales)) {
+                const t = entry.updatedAt ? Date.parse(entry.updatedAt) : 0;
+                if (t > latestTime) {
+                    latestTime = t;
+                    latestVersionId = versionId;
+                }
+            }
+        }
+        const localeEntries = versions[latestVersionId];
+        const translations = {};
+        for (const [locale, entry] of Object.entries(localeEntries)) {
+            translations[locale] = {
+                ...(entry.updatedAt ? { updatedAt: entry.updatedAt } : {}),
+                ...(entry.postProcessHash
+                    ? { postProcessHash: entry.postProcessHash }
+                    : {}),
+            };
+        }
+        entries.push({
+            fileId,
+            versionId: latestVersionId,
+            translations,
+        });
+    }
+    return { version: 2, branchId, entries };
+}
+function convertV2ToV1Branch(v2) {
+    const branch = {};
+    for (const entry of v2.entries) {
+        if (!branch[entry.fileId]) {
+            branch[entry.fileId] = {};
+        }
+        if (!branch[entry.fileId][entry.versionId]) {
+            branch[entry.fileId][entry.versionId] = {};
+        }
+        for (const [locale, translation] of Object.entries(entry.translations)) {
+            branch[entry.fileId][entry.versionId][locale] = {
+                ...(translation.updatedAt ? { updatedAt: translation.updatedAt } : {}),
+                ...(translation.postProcessHash
+                    ? { postProcessHash: translation.postProcessHash }
+                    : {}),
+            };
+        }
+    }
+    return branch;
+}
+// ── Public API ──────────────────────────────────────────────────────
+/**
+ * Reads the lockfile and returns v2 data regardless of the on-disk format.
+ * If the file is v1, `originalV1` contains the full v1 data so that
+ * `writeLockfile` can merge changes back without losing other branches.
+ */
+export function readLockfile(settings) {
+    let branchId = settings._branchId ?? '';
+    let data;
+    let originalV1 = null;
     try {
-        // Clean up legacy lock files inside the config directory
         const rootPath = path.join(process.cwd(), GT_LOCK_FILE);
-        const legacyPath = path.join(configDirectory, LEGACY_DOWNLOADED_VERSIONS_FILE);
-        try {
-            if (fs.existsSync(legacyPath)) {
-                fs.unlinkSync(legacyPath);
-            }
+        if (!fs.existsSync(rootPath)) {
+            data = { version: 2, branchId, entries: [] };
         }
-        catch { }
-        const filepath = fs.existsSync(rootPath) ? rootPath : null;
-        if (!filepath)
-            return { version: 1, entries: {} };
-        const raw = JSON.parse(fs.readFileSync(filepath, 'utf8'));
-        if (raw && typeof raw === 'object' && raw.version && raw.entries) {
-            return raw;
+        else {
+            const raw = JSON.parse(fs.readFileSync(rootPath, 'utf8'));
+            if (!raw || typeof raw !== 'object' || !raw.entries) {
+                data = { version: 2, branchId, entries: [] };
+            }
+            else if (raw.version === 2 && Array.isArray(raw.entries)) {
+                data = raw;
+                if (branchId)
+                    data.branchId = branchId;
+            }
+            else {
+                originalV1 = raw;
+                if (!branchId) {
+                    const branches = Object.keys(originalV1.entries);
+                    if (branches.length > 0)
+                        branchId = branches[0];
+                }
+                data = convertV1ToV2(originalV1, branchId);
+            }
         }
-        return { version: 1, entries: {} };
     }
     catch (error) {
-        logger.error(`An error occurred while getting downloaded versions: ${error}`);
-        return { version: 1, entries: {} };
+        logger.error(`An error occurred while reading ${GT_LOCK_FILE}: ${error}`);
+        data = { version: 2, branchId, entries: [] };
     }
+    return { data, entryMap: buildEntryMap(data.entries), originalV1 };
 }
-export function saveDownloadedVersions(configDirectory, lock) {
+/**
+ * Writes the lockfile. If `originalV1` is provided, merges the current
+ * branch's data back into the v1 structure (preserving other branches)
+ * and writes v1 format. Otherwise writes v2.
+ */
+export function writeLockfile(data, originalV1) {
     try {
-        // Write the lock file to the repo root
         const filepath = path.join(process.cwd(), GT_LOCK_FILE);
         fs.mkdirSync(path.dirname(filepath), { recursive: true });
-        fs.writeFileSync(filepath, JSON.stringify(lock, null, 2));
+        if (originalV1) {
+            const mergedV1 = {
+                ...originalV1,
+                entries: {
+                    ...originalV1.entries,
+                    [data.branchId]: convertV2ToV1Branch(data),
+                },
+            };
+            fs.writeFileSync(filepath, JSON.stringify(mergedV1, null, 2));
+        }
+        else {
+            fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+        }
     }
     catch (error) {
         logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
     }
 }
-export function ensureNestedObject(obj, path) {
-    return path.reduce((current, key, index) => {
-        if (index === path.length - 1)
-            return current;
-        current[key] = current[key] || {};
-        return current[key];
-    }, obj);
+export function buildEntryMap(entries) {
+    return new Map(entries.map((e) => [e.fileId, e]));
+}
+/**
+ * Finds or creates an entry, keeping the map and backing array in sync.
+ * If the fileId exists but versionId changed, replaces it in-place.
+ */
+export function findOrCreateEntry(entryMap, entries, fileId, versionId) {
+    const existing = entryMap.get(fileId);
+    if (existing) {
+        if (existing.versionId === versionId)
+            return existing;
+        // Version changed — replace in array and map
+        const updated = {
+            fileId,
+            versionId,
+            translations: {},
+        };
+        const idx = entries.indexOf(existing);
+        if (idx !== -1)
+            entries[idx] = updated;
+        entryMap.set(fileId, updated);
+        return updated;
+    }
+    const entry = {
+        fileId,
+        versionId,
+        translations: {},
+    };
+    entries.push(entry);
+    entryMap.set(fileId, entry);
+    return entry;
 }

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.10.4";
+export declare const PACKAGE_VERSION = "2.10.5";

package/dist/generated/version.js

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

package/dist/types/index.d.ts

@@ -162,6 +162,7 @@ export type Settings = {
     stageTranslations: boolean;
     publish: boolean;
     _versionId?: string;
+    _branchId?: string;
     version?: string;
     description?: string;
     src?: string[];

package/dist/utils/persistPostprocessHashes.js

@@ -1,5 +1,5 @@
 import * as fs from 'node:fs';
-import { ensureNestedObject, getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
+import { findOrCreateEntry, readLockfile, writeLockfile, } from '../fs/config/downloadedVersions.js';
 import { hashStringSync } from './hash.js';
 /**
  * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
@@ -8,7 +8,7 @@ export function persistPostProcessHashes(settings, includeFiles, downloadedMeta)
     if (!includeFiles || includeFiles.size === 0 || downloadedMeta.size === 0) {
         return;
     }
-    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
+    const { data, entryMap, originalV1 } = readLockfile(settings);
     let lockUpdated = false;
     for (const filePath of includeFiles) {
         const meta = downloadedMeta.get(filePath);
@@ -18,15 +18,10 @@ export function persistPostProcessHashes(settings, includeFiles, downloadedMeta)
             continue;
         const content = fs.readFileSync(filePath, 'utf8');
         const hash = hashStringSync(content);
-        ensureNestedObject(downloadedVersions.entries, [
-            meta.branchId,
-            meta.fileId,
-            meta.versionId,
-            meta.locale,
-        ]);
-        const existing = downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] || {};
+        const entry = findOrCreateEntry(entryMap, data.entries, meta.fileId, meta.versionId);
+        const existing = entry.translations[meta.locale] || {};
         if (existing.postProcessHash !== hash) {
-            downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] = {
+            entry.translations[meta.locale] = {
                 ...existing,
                 postProcessHash: hash,
             };
@@ -34,6 +29,6 @@ export function persistPostProcessHashes(settings, includeFiles, downloadedMeta)
         }
     }
     if (lockUpdated) {
-        saveDownloadedVersions(settings.configDirectory, downloadedVersions);
+        writeLockfile(data, originalV1);
     }
 }

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

@@ -4,7 +4,8 @@ import { Settings } from '../../types/index.js';
 export declare class UserEditDiffsStep extends WorkflowStep<FileReference[], FileReference[]> {
     private settings;
     private spinner;
-    private completed;
+    private succeeded;
+    private failed;
     constructor(settings: Settings);
     run(files: FileReference[]): Promise<FileReference[]>;
     wait(): Promise<void>;

package/dist/workflows/steps/UserEditDiffsStep.js

@@ -5,7 +5,8 @@ import { collectAndSendUserEditDiffs } from '../../api/collectUserEditDiffs.js';
 export class UserEditDiffsStep extends WorkflowStep {
     settings;
     spinner = logger.createSpinner('dots');
-    completed = false;
+    succeeded = false;
+    failed = false;
     constructor(settings) {
         super();
         this.settings = settings;
@@ -14,17 +15,20 @@ export class UserEditDiffsStep extends WorkflowStep {
         this.spinner.start('Updating translations...');
         try {
             await collectAndSendUserEditDiffs(files, this.settings);
-            this.completed = true;
+            this.succeeded = true;
         }
         catch {
             // Non-fatal; keep going to enqueue
-            this.completed = true;
+            this.failed = true;
         }
         return files;
     }
     async wait() {
-        if (this.completed) {
+        if (this.succeeded) {
             this.spinner.stop(chalk.green('Updated translations'));
         }
+        else if (this.failed) {
+            this.spinner.stop(chalk.yellow('Could not update translations'));
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.10.4",
+  "version": "2.10.5",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [