@postxl/generator 0.74.2 → 1.0.1

package/dist/utils/checksum.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zChecksum = void 0;
+exports.calculateChecksum = calculateChecksum;
+const crypto = __importStar(require("node:crypto"));
+const zod_1 = __importDefault(require("zod"));
+const zip_1 = require("./zip");
+exports.zChecksum = zod_1.default.string().brand('PXL.Checksum');
+/**
+ * Converts a given scalar to a branded checksum type.
+ *
+ * IMPORTANT: This function does not calculate the checksum!
+ */
+const toBrandedChecksum = (input) => exports.zChecksum.parse(input);
+/**
+ * Returns the checksum of the given file
+ */
+async function calculateChecksum(content) {
+    if (Buffer.isBuffer(content)) {
+        if (isBufferZip(content)) {
+            return await calculateZipFileChecksum(content);
+        }
+        return calculateBinaryContentChecksum(content);
+    }
+    return calculateUTF8ContentChecksum(content);
+}
+function calculateUTF8ContentChecksum(content) {
+    const normalized = content
+        .replace(/\r\n/g, '\n') // Normalize Windows line endings to Unix
+        .replace(/\n\r/g, '\n') // Normalize Mac line endings to Unix
+        .replace(/\r/g, '\n') // Normalize Mac line endings to Unix
+        .replace(/\uFEFF/g, ''); // Remove BOM
+    const hash = crypto.createHash('sha256', {});
+    hash.update(normalized);
+    return toBrandedChecksum(hash.digest('hex'));
+}
+function calculateBinaryContentChecksum(content) {
+    const hash = crypto.createHash('sha256', {});
+    hash.update(content);
+    return toBrandedChecksum(hash.digest('hex'));
+}
+/**
+ * Checks if a given buffer represents a zip file.
+ *
+ * Zip files start with a specific signature (magic numbers) -
+ * (0x50, 0x4b) followed by 0x03 0x04 or
+ * (0x50, 0x4b) followed by 0x05 0x06 (empty archive) or
+ * (0x50, 0x4b) followed by 0x07 0x08 (spanned archive).
+ *
+ * See https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
+ * More details: See https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *               in section 4.3.7 (Local file header)
+ * By checking the beginning of the buffer against these signatures, we can infer whether it represents a zip file or not.
+ */
+function isBufferZip(buffer) {
+    if (buffer.length < 4) {
+        return false;
+    }
+    const header = buffer.subarray(0, 4);
+    return (header[0] === 0x50 &&
+        header[1] === 0x4b &&
+        ((header[2] === 0x03 && header[3] === 0x04) ||
+            (header[2] === 0x05 && header[3] === 0x06) ||
+            (header[2] === 0x07 && header[3] === 0x08)));
+}
+/**
+ * Calculates the checksum of the given zip file, ignoring the metadata.
+ * This also ignores Excel specific files (core.xml) as they contain the creation date.
+ *
+ * Details:
+ * Zip files contain a central directory which contains a list of all files
+ * This includes metadata including the file creation time, which means that
+ * the checksum of a zip file can change even if the contents of the files
+ * inside the zip file have not changed.
+ * To avoid this, we calculate the checksum of the contents of the files inside
+ * the zip file, ignoring the metadata.
+ */
+async function calculateZipFileChecksum(content) {
+    const hash = crypto.createHash('sha256', {});
+    const zip = await (0, zip_1.loadZip)(content);
+    const fileNames = Object.keys(zip.files);
+    for (const fileName of fileNames) {
+        // in case filename is core.xml, we skip it as it is a part of an Excel file
+        // and contains the creation date - which results in a different checksum
+        // even if the contents of the file have not changed
+        if (fileName.endsWith('core.xml')) {
+            continue;
+        }
+        const file = zip.file(fileName);
+        if (file) {
+            const fileContent = await file.async('nodebuffer');
+            hash.update(fileContent);
+        }
+    }
+    return toBrandedChecksum(hash.digest('hex'));
+}

package/dist/utils/fs-utils.d.ts

@@ -0,0 +1,34 @@
+import { Result } from '@postxl/utils';
+import * as Path from './path';
+export type FileContent = string | Buffer;
+export declare function isBuffer(x: FileContent): x is Buffer;
+/**
+ * List of files that are read as text.
+ */
+export declare const textExtensions: string[];
+type ReadFileError = {
+    type: 'ReadFileError';
+    message: string;
+    error: Error;
+};
+/**
+ * Reads the content from the given path.
+ *
+ * If the file is text, it will be read as UTF-8 and converted to a string.
+ * Otherwise, it will be read as binary.
+ */
+export declare function readFile(path: Path.PosixPath): Promise<Result<FileContent, ReadFileError>>;
+export type WriteFileError = {
+    type: 'WriteFileError';
+    message: string;
+    error: Error;
+};
+export declare function writeFile(filePath: Path.PosixPath, content: FileContent): Promise<Result<void, WriteFileError>>;
+export type FileErrorTypes = 'ReadFileError' | 'WriteFileError' | 'DeleteFileError';
+export type DeleteFileError = {
+    type: 'DeleteFileError';
+    message: string;
+    error: Error;
+};
+export declare function deleteFile(filePath: Path.PosixPath): Promise<Result<void, DeleteFileError>>;
+export {};

package/dist/utils/fs-utils.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textExtensions = void 0;
+exports.isBuffer = isBuffer;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.deleteFile = deleteFile;
+const fs = __importStar(require("fs/promises"));
+const path_1 = require("path");
+const isbinaryfile_1 = require("isbinaryfile");
+const utils_1 = require("@postxl/utils");
+function isBuffer(x) {
+    return Buffer.isBuffer(x);
+}
+/**
+ * List of files that are read as text.
+ */
+exports.textExtensions = [
+    '.json',
+    '.js',
+    '.ts',
+    '.tsx',
+    '.jsx',
+    '.html',
+    '.css',
+    '.md',
+    '.txt',
+    '.prisma',
+    '.yaml',
+    '.yml',
+    '.graphql',
+    '.gql',
+    '.mdx',
+    '.toml',
+    '.xml',
+    '.svg',
+    '.nvmrc',
+    '.npmignore',
+    '.gitignore',
+    '.sql',
+    '.sh',
+    '.env',
+    '.env.example',
+];
+async function isFileText(path) {
+    const isTextExtension = exports.textExtensions.some((x) => path.endsWith(x));
+    if (isTextExtension) {
+        return true;
+    }
+    try {
+        return !(await (0, isbinaryfile_1.isBinaryFile)(path, 256));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reads the content from the given path.
+ *
+ * If the file is text, it will be read as UTF-8 and converted to a string.
+ * Otherwise, it will be read as binary.
+ */
+async function readFile(path) {
+    return utils_1.Result.fromPromise(async () => {
+        if (await isFileText(path)) {
+            const content = await fs.readFile(path, { encoding: 'utf-8' });
+            return content.toString();
+        }
+        else {
+            return fs.readFile(path);
+        }
+    }, (error) => ({ type: 'ReadFileError', message: `Error reading "${path}"!`, error }));
+}
+async function writeFile(filePath, content) {
+    return utils_1.Result.fromPromise(async () => {
+        await fs.mkdir((0, path_1.dirname)(filePath), { recursive: true });
+        if (typeof content === 'string') {
+            await fs.writeFile(filePath, content);
+        }
+        else {
+            await fs.writeFile(filePath, new Uint8Array(content));
+        }
+        // Set executable permission for shell scripts
+        if (filePath.endsWith('.sh')) {
+            await fs.chmod(filePath, 0o755);
+        }
+    }, (error) => ({ type: 'WriteFileError', message: `Error writing "${filePath}"!`, error }));
+}
+async function deleteFile(filePath) {
+    return utils_1.Result.fromPromise(async () => {
+        return fs.unlink(filePath);
+    }, (error) => ({ type: 'DeleteFileError', message: `Error deleting "${filePath}"!`, error }));
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './jsdoc';
+export * from './lint';
+export * from './path';
+export * from './promise';
+export * from './prettier';
+export * from './string-functions';
+export * from './sync';
+export * from './sync-log-result';
+export * from './template';
+export * from './vfs.class';

package/dist/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jsdoc"), exports);
+__exportStar(require("./lint"), exports);
+__exportStar(require("./path"), exports);
+__exportStar(require("./promise"), exports);
+__exportStar(require("./prettier"), exports);
+__exportStar(require("./string-functions"), exports);
+__exportStar(require("./sync"), exports);
+__exportStar(require("./sync-log-result"), exports);
+__exportStar(require("./template"), exports);
+__exportStar(require("./vfs.class"), exports);

package/dist/utils/jsdoc.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a string of JSDoc comments from an array of lines.
+ */
+export declare function toJsDocComment(comments: string | string[] | undefined): string;
+/**
+ * Adds a JSDoc comment to the beginning of a code string.
+ * If `comments` is blank, the code is returned as-is.
+ *
+ * This is a small convenience function that wraps `toJsDocComment` and
+ * handles the case where `comments` is blank.
+ */
+export declare function addJsDocComment(code: string, comments: string | string[] | undefined): string;

package/dist/utils/jsdoc.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJsDocComment = toJsDocComment;
+exports.addJsDocComment = addJsDocComment;
+/**
+ * Returns a string of JSDoc comments from an array of lines.
+ */
+function toJsDocComment(comments) {
+    if (!comments || comments.length === 0) {
+        return '';
+    }
+    if (typeof comments === 'string') {
+        comments = comments.split('\n');
+    }
+    if (comments.length === 1 && comments[0].trim() === '') {
+        return '';
+    }
+    return `/**
+${comments
+        //
+        .map((c) => ` * ${c.trim()}`.trimEnd())
+        .join('\n')}\n */`;
+}
+/**
+ * Adds a JSDoc comment to the beginning of a code string.
+ * If `comments` is blank, the code is returned as-is.
+ *
+ * This is a small convenience function that wraps `toJsDocComment` and
+ * handles the case where `comments` is blank.
+ */
+function addJsDocComment(code, comments) {
+    const comment = toJsDocComment(comments);
+    if (comment === '') {
+        return code;
+    }
+    return `${comment}\n${code}`;
+}

package/dist/utils/lint.d.ts

@@ -0,0 +1,46 @@
+import { Linter } from 'eslint';
+import { Logger } from './logger.class';
+import { PosixPath } from './path';
+import { VirtualFileSystem } from './vfs.class';
+type FileLintResult = {
+    errorCount: number;
+    warningCount: number;
+    fixableCount: number;
+    messages: Linter.LintMessage[];
+};
+type LintResults = {
+    totalErrorCount: number;
+    totalWarningCount: number;
+    totalFixableCount: number;
+    fileResults: Map<PosixPath, FileLintResult>;
+};
+export type LintOptions = {
+    /**
+     * If true, the linter will skip attempt to fix the errors.
+     *
+     * Default: false
+     */
+    noFix: boolean;
+    /**
+     * If true, linting will be skipped
+     *
+     * Default: false
+     */
+    skipLint: boolean;
+    /**
+     * If true, the linter will not print any messages to the logger.
+     *
+     * Default: false
+     */
+    quiet: boolean;
+    /**
+     * If true, the linter will print verbose messages to the logger.
+     *
+     * Default: false
+     */
+    verbose: boolean;
+    logger?: Logger;
+};
+export declare function lint(vfs: VirtualFileSystem, options?: Partial<LintOptions>): Promise<LintResults>;
+export declare function logLintResults(results: LintResults, options?: Partial<LintOptions>): void;
+export {};

package/dist/utils/lint.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = lint;
+exports.logLintResults = logLintResults;
+const path_1 = require("path");
+const process_1 = require("process");
+const eslint_1 = require("eslint");
+const utils_1 = require("@postxl/utils");
+const fs_utils_1 = require("./fs-utils");
+const logger_class_1 = require("./logger.class");
+const defaultOptions = {
+    noFix: false,
+    skipLint: false,
+    quiet: false,
+    verbose: false,
+    logger: new logger_class_1.Logger(),
+};
+function ignoreMessage(message) {
+    // For performance reasons (and also to lower complexity), we do not use the TS Language Service.
+    // Therefore, some linting rules cannot be applied at generate time and only pop up after generation.
+    // When we purposefully add an eslint-disable directive, eslint normally removes it as it
+    // considers it unused. We however want to keep it - the below check ensures that it remains.
+    // Not the cleanest solution, but cannot think of a better one at the moment. ¯\_(ツ)_/¯
+    if (message.message.startsWith("Unused eslint-disable directive (no problems were reported from '@typescript-eslint/")) {
+        return true;
+    }
+    return false;
+}
+async function lint(vfs, options = {}) {
+    const opts = { ...defaultOptions, ...options };
+    const logger = opts.logger ?? new logger_class_1.Logger();
+    const results = {
+        totalErrorCount: 0,
+        totalWarningCount: 0,
+        totalFixableCount: 0,
+        fileResults: new Map(),
+    };
+    if (opts.skipLint) {
+        return results;
+    }
+    const linter = new eslint_1.ESLint({
+        cwd: (0, path_1.join)((0, process_1.cwd)(), '../..'),
+        fix: opts.noFix ? false : (m) => !ignoreMessage(m),
+        warnIgnored: false,
+    });
+    await vfs.transform(async ({ path, content }) => {
+        const { content: newContent, stats: result } = await lintFile({ path, content, linter, fix: !opts.noFix, logger });
+        results.fileResults.set(path, result);
+        results.totalErrorCount += result.errorCount;
+        results.totalWarningCount += result.warningCount;
+        results.totalFixableCount += result.fixableCount;
+        return newContent;
+    });
+    return results;
+}
+async function lintFile({ path, content, linter, logger, }) {
+    const stats = {
+        errorCount: 0,
+        warningCount: 0,
+        fixableCount: 0,
+        messages: [],
+    };
+    if ((0, fs_utils_1.isBuffer)(content)) {
+        return { content, stats };
+    }
+    const fileExtension = (0, path_1.extname)(path);
+    if (fileExtension !== '.js' && fileExtension !== '.jsx' && fileExtension !== '.ts' && fileExtension !== '.tsx') {
+        return { content, stats };
+    }
+    try {
+        const results = await linter.lintText(content, { filePath: (0, path_1.join)((0, process_1.cwd)(), 'vfs', path) });
+        return extractResult({ results, stats, content });
+    }
+    catch (err) {
+        logger.error(`${content}\n\nFailed to lint ${path}\n\n`);
+        throw err;
+    }
+}
+function extractResult({ results, stats, content, }) {
+    const [result] = results;
+    if (!result) {
+        return { content, stats };
+    }
+    for (const message of result.messages) {
+        if (ignoreMessage(message)) {
+            continue;
+        }
+        stats.messages.push(message);
+        if (message.fatal) {
+            stats.errorCount++;
+        }
+        else if (message.fix) {
+            stats.fixableCount++;
+        }
+        else if (message.severity === 2) {
+            stats.errorCount++;
+        }
+        else if (message.severity === 1) {
+            stats.warningCount++;
+        }
+    }
+    return { content: result.output ?? content, stats };
+}
+function logLintResults(results, options = {}) {
+    const logger = options.logger ?? new logger_class_1.Logger();
+    if (options.quiet) {
+        return;
+    }
+    if (results.totalErrorCount === 0 && results.totalWarningCount === 0 && results.totalFixableCount === 0) {
+        if (!options.verbose) {
+            return;
+        }
+        if (results.fileResults.size === 0) {
+            logger.log((0, utils_1.bold)((0, utils_1.green)('No files linted!')));
+            return;
+        }
+        const count = results.fileResults.size;
+        logger.log((0, utils_1.bold)((0, utils_1.green)(`Successfully linted ${count} ${(0, utils_1.pluralize)('file', count)}!`)));
+        return;
+    }
+    for (const [path, result] of results.fileResults) {
+        logLintFileResult({ result, path, logger });
+    }
+}
+function logLintFileResult({ result, path, logger }) {
+    if (result.errorCount === 0 && result.warningCount === 0 && result.fixableCount === 0) {
+        return;
+    }
+    let fileColor = utils_1.gray;
+    let fileSummary = '';
+    if (result.errorCount > 0) {
+        fileColor = utils_1.red;
+        fileSummary = (0, utils_1.red)(`${result.errorCount} errors`);
+    }
+    else if (result.warningCount > 0) {
+        fileColor = utils_1.yellow;
+        if (fileSummary.length > 0) {
+            fileSummary += ', ';
+        }
+        fileSummary += (0, utils_1.yellow)(`${result.warningCount} warnings`);
+    }
+    else if (result.fixableCount > 0) {
+        fileColor = utils_1.green;
+        if (fileSummary.length > 0) {
+            fileSummary += ', ';
+        }
+        fileSummary += (0, utils_1.green)(`${result.fixableCount} fixable`);
+    }
+    for (const message of result.messages) {
+        const position = message.line ? `${message.line}:${message.column} ` : '';
+        fileSummary += `\n  ${position}${message.message}`;
+    }
+    logger.log(`${fileColor(path)}: ${fileSummary}`);
+}

package/dist/utils/lockfile.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { VirtualFileSystem } from './vfs.class';
+declare const zLockFile: z.ZodEffects<z.ZodRecord<z.ZodBranded<z.ZodString, "PXL.PosixPath">, z.ZodBranded<z.ZodString, "PXL.Checksum">>, Map<string & z.BRAND<"PXL.PosixPath">, string & z.BRAND<"PXL.Checksum">>, Record<string, string>>;
+type LockFile = z.infer<typeof zLockFile>;
+export declare function writeLockFile(lockFilePath: string, vfs: VirtualFileSystem): Promise<void>;
+export declare function readLockFile(lockFilePath: string): Promise<LockFile | undefined>;
+export {};

package/dist/utils/lockfile.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLockFile = writeLockFile;
+exports.readLockFile = readLockFile;
+const fs = __importStar(require("fs/promises"));
+const zod_1 = require("zod");
+const checksum_1 = require("./checksum");
+const path_1 = require("./path");
+const zLockFile = zod_1.z
+    .record(path_1.zPosixPath, checksum_1.zChecksum)
+    .transform((val) => new Map(Object.entries(val).filter((entry) => entry[1] !== undefined)));
+async function writeLockFile(lockFilePath, vfs) {
+    const newLockFileMap = await vfsToLockFile(vfs);
+    // If VFS has a file pattern filter, merge with existing lock file to preserve non-filtered entries
+    if (vfs.filePattern) {
+        const existingLockFile = await readLockFile(lockFilePath);
+        if (existingLockFile) {
+            // Keep all entries from existing lock file that don't match the current filter
+            for (const [filePath, checksum] of existingLockFile) {
+                if (!vfs.matchesPattern(filePath) && !newLockFileMap.has(filePath)) {
+                    newLockFileMap.set(filePath, checksum);
+                }
+            }
+        }
+    }
+    const sortedEntries = Array.from(newLockFileMap.entries()).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+    await fs.writeFile(lockFilePath, JSON.stringify(Object.fromEntries(sortedEntries), null, 2));
+}
+async function vfsToLockFile(vfs) {
+    const lockFile = new Map();
+    for (const fileName of vfs.fileNames) {
+        const content = vfs.get(fileName);
+        if (content) {
+            lockFile.set(fileName, await (0, checksum_1.calculateChecksum)(content));
+        }
+    }
+    return lockFile;
+}
+async function readLockFile(lockFilePath) {
+    try {
+        const lockFile = zLockFile.parse(JSON.parse(await fs.readFile(lockFilePath, 'utf8')));
+        return lockFile;
+    }
+    catch {
+        return undefined;
+    }
+}