ic-mops 1.0.1 → 1.1.0-pre.0

package/cli.ts

@@ -89,6 +89,7 @@ program
 	.command('install')
 	.alias('i')
 	.description('Install all dependencies specified in mops.toml')
+	.option('--no-toolchain', 'Do not install toolchain')
 	.option('--verbose')
 	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
 	.action(async (options) => {
@@ -101,10 +102,15 @@ program
 			return;
 		}
 
-		await toolchain.ensureToolchainInited({strict: false});
+		if (options.toolchain) {
+			await toolchain.ensureToolchainInited({strict: false});
+		}
 
 		let ok = await installAll(options);
-		await toolchain.installAll(options);
+
+		if (options.toolchain) {
+			await toolchain.installAll(options);
+		}
 
 		// check conflicts
 		await resolvePackages({conflicts: 'warning'});
@@ -162,7 +168,7 @@ program
 			process.exit(1);
 		}
 		if (options.install) {
-			await installAll({silent: true, lock: 'ignore', threads: 6});
+			await installAll({silent: true, lock: 'ignore', threads: 6, installFromLockFile: true});
 		}
 		await toolchain.ensureToolchainInited({strict: false});
 		let sourcesArr = await sources(options);
@@ -206,7 +212,7 @@ program
 	.option('-w, --watch', 'Enable watch mode')
 	.action(async (filter, options) => {
 		checkConfigFile(true);
-		await installAll({silent: true, lock: 'ignore'});
+		await installAll({silent: true, lock: 'ignore', installFromLockFile: true});
 		await test(filter, options);
 	});
 
@@ -222,7 +228,7 @@ program
 	.addOption(new Option('--verbose', 'Show more information'))
 	.action(async (filter, options) => {
 		checkConfigFile(true);
-		await installAll({silent: true, lock: 'ignore'});
+		await installAll({silent: true, lock: 'ignore', installFromLockFile: true});
 		await bench(filter, options);
 	});
 

package/commands/install/install-all.ts

@@ -1,8 +1,8 @@
 import process from 'node:process';
 import chalk from 'chalk';
 import {createLogUpdate} from 'log-update';
-import {checkConfigFile, readConfig} from '../../mops.js';
-import {checkIntegrity} from '../../integrity.js';
+import {checkConfigFile, parseDepValue, readConfig} from '../../mops.js';
+import {checkIntegrity, checkLockFileLight, readLockFile} from '../../integrity.js';
 import {installDeps} from './install-deps.js';
 import {checkRequirements} from '../../check-requirements.js';
 import {syncLocalCache} from './sync-local-cache.js';
@@ -13,9 +13,10 @@ type InstallAllOptions = {
 	silent ?: boolean;
 	lock ?: 'check' | 'update' | 'ignore';
 	threads ?: number;
+	installFromLockFile ?: boolean;
 }
 
-export async function installAll({verbose = false, silent = false, threads, lock} : InstallAllOptions = {}) : Promise<boolean> {
+export async function installAll({verbose = false, silent = false, threads, lock, installFromLockFile} : InstallAllOptions = {}) : Promise<boolean> {
 	if (!checkConfigFile()) {
 		return false;
 	}
@@ -24,12 +25,33 @@ export async function installAll({verbose = false, silent = false, threads, lock
 	let deps = Object.values(config.dependencies || {});
 	let devDeps = Object.values(config['dev-dependencies'] || {});
 	let allDeps = [...deps, ...devDeps];
+	let installedFromLockFile = false;
 
-	let ok = await installDeps(allDeps, {silent, verbose, threads});
-	if (!ok) {
-		return false;
+	// install from lock file to avoid installing intermediate dependencies
+	if ((lock !== 'ignore' || installFromLockFile) && checkLockFileLight()) {
+		let lockFileJson = readLockFile();
+
+		if (lockFileJson && lockFileJson.version === 3) {
+			verbose && console.log('Installing from lock file...');
+			installedFromLockFile = true;
+			let deps = Object.entries(lockFileJson.deps).map(([name, version]) => {
+				return parseDepValue(name, version);
+			});
+			let ok = await installDeps(deps, {silent, verbose, threads, ignoreTransitive: true});
+			if (!ok) {
+				return false;
+			}
+		}
 	}
 
+	if (!installedFromLockFile) {
+		let ok = await installDeps(allDeps, {silent, verbose, threads});
+		if (!ok) {
+			return false;
+		}
+	}
+
+
 	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
 
 	if (!silent && lock !== 'ignore') {

package/commands/install/install-dep.ts

@@ -9,13 +9,14 @@ type InstallDepOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
 // install dependency
 // returns false if failed
-export async function installDep(dep : Dependency, {verbose, silent, threads} : InstallDepOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
+export async function installDep(dep : Dependency, {verbose, silent, threads, ignoreTransitive} : InstallDepOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
 	if (dep.repo) {
-		await installFromGithub(dep.name, dep.repo, {silent, verbose});
+		await installFromGithub(dep.name, dep.repo, {silent, verbose, ignoreTransitive});
 		return true;
 	}
 	else if (dep.path) {
@@ -24,10 +25,10 @@ export async function installDep(dep : Dependency, {verbose, silent, threads} :
 		if (parentPkgPath) {
 			depPath = path.resolve(parentPkgPath, dep.path);
 		}
-		return installLocalDep(dep.name, depPath, {silent, verbose});
+		return installLocalDep(dep.name, depPath, {silent, verbose, ignoreTransitive});
 	}
 	else if (dep.version) {
-		return installMopsDep(dep.name, dep.version, {silent, verbose, threads});
+		return installMopsDep(dep.name, dep.version, {silent, verbose, threads, ignoreTransitive});
 	}
 
 	return true;

package/commands/install/install-deps.ts

@@ -5,16 +5,17 @@ type InstallDepsOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
 // install all dependencies
 // returns actual installed dependencies
 // returns false if failed
-export async function installDeps(deps : Dependency[], {verbose, silent, threads} : InstallDepsOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
+export async function installDeps(deps : Dependency[], {verbose, silent, threads, ignoreTransitive} : InstallDepsOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
 	let ok = true;
 
 	for (const dep of deps) {
-		let res = await installDep(dep, {verbose, silent, threads}, parentPkgPath);
+		let res = await installDep(dep, {verbose, silent, threads, ignoreTransitive}, parentPkgPath);
 		if (!res) {
 			ok = false;
 		}

package/commands/install/install-local-dep.ts

@@ -7,11 +7,12 @@ import {installDeps} from './install-deps.js';
 type InstallLocalDepOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
+	ignoreTransitive ?: boolean;
 };
 
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg : string, pkgPath = '', {verbose, silent} : InstallLocalDepOptions = {}) : Promise<boolean> {
+export async function installLocalDep(pkg : string, pkgPath = '', {verbose, silent, ignoreTransitive} : InstallLocalDepOptions = {}) : Promise<boolean> {
 	if (!silent) {
 		let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
 		logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
@@ -25,7 +26,12 @@ export async function installLocalDep(pkg : string, pkgPath = '', {verbose, sile
 	}
 
 	// install dependencies
-	let dir = path.resolve(getRootDir(), pkgPath);
-	let config = readConfig(path.join(dir, 'mops.toml'));
-	return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
-}
+	if (!ignoreTransitive) {
+		let dir = path.resolve(getRootDir(), pkgPath);
+		let config = readConfig(path.join(dir, 'mops.toml'));
+		return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
+	}
+	else {
+		return true;
+	}
+}

package/commands/install/install-mops-dep.ts

@@ -19,9 +19,10 @@ type InstallMopsDepOptions = {
 	silent ?: boolean;
 	dep ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
-export async function installMopsDep(pkg : string, version = '', {verbose, silent, dep, threads} : InstallMopsDepOptions = {}) : Promise<boolean> {
+export async function installMopsDep(pkg : string, version = '', {verbose, silent, dep, threads, ignoreTransitive} : InstallMopsDepOptions = {}) : Promise<boolean> {
 	threads = threads || 12;
 	let depName = getDepName(pkg);
 
@@ -113,11 +114,13 @@ export async function installMopsDep(pkg : string, version = '', {verbose, silen
 	}
 
 	// install dependencies
-	let config = readConfig(path.join(cacheDir, 'mops.toml'));
-	let res = await installDeps(Object.values(config.dependencies || {}), {silent, verbose});
+	if (!ignoreTransitive) {
+		let config = readConfig(path.join(cacheDir, 'mops.toml'));
+		let res = await installDeps(Object.values(config.dependencies || {}), {silent, verbose});
 
-	if (!res) {
-		return false;
+		if (!res) {
+			return false;
+		}
 	}
 
 	return true;

package/dist/cli.js

@@ -72,6 +72,7 @@ program
     .command('install')
     .alias('i')
     .description('Install all dependencies specified in mops.toml')
+    .option('--no-toolchain', 'Do not install toolchain')
     .option('--verbose')
     .addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
     .action(async (options) => {
@@ -82,9 +83,13 @@ program
     if (!compatible) {
         return;
     }
-    await toolchain.ensureToolchainInited({ strict: false });
+    if (options.toolchain) {
+        await toolchain.ensureToolchainInited({ strict: false });
+    }
     let ok = await installAll(options);
-    await toolchain.installAll(options);
+    if (options.toolchain) {
+        await toolchain.installAll(options);
+    }
     // check conflicts
     await resolvePackages({ conflicts: 'warning' });
     if (!ok) {
@@ -136,7 +141,7 @@ program
         process.exit(1);
     }
     if (options.install) {
-        await installAll({ silent: true, lock: 'ignore', threads: 6 });
+        await installAll({ silent: true, lock: 'ignore', threads: 6, installFromLockFile: true });
     }
     await toolchain.ensureToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
@@ -177,7 +182,7 @@ program
     .option('-w, --watch', 'Enable watch mode')
     .action(async (filter, options) => {
     checkConfigFile(true);
-    await installAll({ silent: true, lock: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore', installFromLockFile: true });
     await test(filter, options);
 });
 // bench
@@ -192,7 +197,7 @@ program
     .addOption(new Option('--verbose', 'Show more information'))
     .action(async (filter, options) => {
     checkConfigFile(true);
-    await installAll({ silent: true, lock: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore', installFromLockFile: true });
     await bench(filter, options);
 });
 // template

package/dist/commands/install/install-all.d.ts

@@ -3,6 +3,7 @@ type InstallAllOptions = {
     silent?: boolean;
     lock?: 'check' | 'update' | 'ignore';
     threads?: number;
+    installFromLockFile?: boolean;
 };
-export declare function installAll({ verbose, silent, threads, lock }?: InstallAllOptions): Promise<boolean>;
+export declare function installAll({ verbose, silent, threads, lock, installFromLockFile }?: InstallAllOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-all.js

@@ -1,13 +1,13 @@
 import process from 'node:process';
 import chalk from 'chalk';
 import { createLogUpdate } from 'log-update';
-import { checkConfigFile, readConfig } from '../../mops.js';
-import { checkIntegrity } from '../../integrity.js';
+import { checkConfigFile, parseDepValue, readConfig } from '../../mops.js';
+import { checkIntegrity, checkLockFileLight, readLockFile } from '../../integrity.js';
 import { installDeps } from './install-deps.js';
 import { checkRequirements } from '../../check-requirements.js';
 import { syncLocalCache } from './sync-local-cache.js';
 import { notifyInstalls } from '../../notify-installs.js';
-export async function installAll({ verbose = false, silent = false, threads, lock } = {}) {
+export async function installAll({ verbose = false, silent = false, threads, lock, installFromLockFile } = {}) {
     if (!checkConfigFile()) {
         return false;
     }
@@ -15,9 +15,27 @@ export async function installAll({ verbose = false, silent = false, threads, loc
     let deps = Object.values(config.dependencies || {});
     let devDeps = Object.values(config['dev-dependencies'] || {});
     let allDeps = [...deps, ...devDeps];
-    let ok = await installDeps(allDeps, { silent, verbose, threads });
-    if (!ok) {
-        return false;
+    let installedFromLockFile = false;
+    // install from lock file to avoid installing intermediate dependencies
+    if ((lock !== 'ignore' || installFromLockFile) && checkLockFileLight()) {
+        let lockFileJson = readLockFile();
+        if (lockFileJson && lockFileJson.version === 3) {
+            verbose && console.log('Installing from lock file...');
+            installedFromLockFile = true;
+            let deps = Object.entries(lockFileJson.deps).map(([name, version]) => {
+                return parseDepValue(name, version);
+            });
+            let ok = await installDeps(deps, { silent, verbose, threads, ignoreTransitive: true });
+            if (!ok) {
+                return false;
+            }
+        }
+    }
+    if (!installedFromLockFile) {
+        let ok = await installDeps(allDeps, { silent, verbose, threads });
+        if (!ok) {
+            return false;
+        }
     }
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
     if (!silent && lock !== 'ignore') {

package/dist/commands/install/install-dep.d.ts

@@ -3,6 +3,7 @@ type InstallDepOptions = {
     verbose?: boolean;
     silent?: boolean;
     threads?: number;
+    ignoreTransitive?: boolean;
 };
-export declare function installDep(dep: Dependency, { verbose, silent, threads }?: InstallDepOptions, parentPkgPath?: string): Promise<boolean>;
+export declare function installDep(dep: Dependency, { verbose, silent, threads, ignoreTransitive }?: InstallDepOptions, parentPkgPath?: string): Promise<boolean>;
 export {};

package/dist/commands/install/install-dep.js

@@ -5,9 +5,9 @@ import { installLocalDep } from './install-local-dep.js';
 import { getRootDir } from '../../mops.js';
 // install dependency
 // returns false if failed
-export async function installDep(dep, { verbose, silent, threads } = {}, parentPkgPath) {
+export async function installDep(dep, { verbose, silent, threads, ignoreTransitive } = {}, parentPkgPath) {
     if (dep.repo) {
-        await installFromGithub(dep.name, dep.repo, { silent, verbose });
+        await installFromGithub(dep.name, dep.repo, { silent, verbose, ignoreTransitive });
         return true;
     }
     else if (dep.path) {
@@ -16,10 +16,10 @@ export async function installDep(dep, { verbose, silent, threads } = {}, parentP
         if (parentPkgPath) {
             depPath = path.resolve(parentPkgPath, dep.path);
         }
-        return installLocalDep(dep.name, depPath, { silent, verbose });
+        return installLocalDep(dep.name, depPath, { silent, verbose, ignoreTransitive });
     }
     else if (dep.version) {
-        return installMopsDep(dep.name, dep.version, { silent, verbose, threads });
+        return installMopsDep(dep.name, dep.version, { silent, verbose, threads, ignoreTransitive });
     }
     return true;
 }

package/dist/commands/install/install-deps.d.ts

@@ -3,6 +3,7 @@ type InstallDepsOptions = {
     verbose?: boolean;
     silent?: boolean;
     threads?: number;
+    ignoreTransitive?: boolean;
 };
-export declare function installDeps(deps: Dependency[], { verbose, silent, threads }?: InstallDepsOptions, parentPkgPath?: string): Promise<boolean>;
+export declare function installDeps(deps: Dependency[], { verbose, silent, threads, ignoreTransitive }?: InstallDepsOptions, parentPkgPath?: string): Promise<boolean>;
 export {};

package/dist/commands/install/install-deps.js

@@ -2,10 +2,10 @@ import { installDep } from './install-dep.js';
 // install all dependencies
 // returns actual installed dependencies
 // returns false if failed
-export async function installDeps(deps, { verbose, silent, threads } = {}, parentPkgPath) {
+export async function installDeps(deps, { verbose, silent, threads, ignoreTransitive } = {}, parentPkgPath) {
     let ok = true;
     for (const dep of deps) {
-        let res = await installDep(dep, { verbose, silent, threads }, parentPkgPath);
+        let res = await installDep(dep, { verbose, silent, threads, ignoreTransitive }, parentPkgPath);
         if (!res) {
             ok = false;
         }

package/dist/commands/install/install-local-dep.d.ts

@@ -1,6 +1,7 @@
 type InstallLocalDepOptions = {
     verbose?: boolean;
     silent?: boolean;
+    ignoreTransitive?: boolean;
 };
-export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent }?: InstallLocalDepOptions): Promise<boolean>;
+export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent, ignoreTransitive }?: InstallLocalDepOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-local-dep.js

@@ -5,7 +5,7 @@ import { getRootDir, readConfig } from '../../mops.js';
 import { installDeps } from './install-deps.js';
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {}) {
+export async function installLocalDep(pkg, pkgPath = '', { verbose, silent, ignoreTransitive } = {}) {
     if (!silent) {
         let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
         logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
@@ -17,7 +17,12 @@ export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {
         }
     }
     // install dependencies
-    let dir = path.resolve(getRootDir(), pkgPath);
-    let config = readConfig(path.join(dir, 'mops.toml'));
-    return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+    if (!ignoreTransitive) {
+        let dir = path.resolve(getRootDir(), pkgPath);
+        let config = readConfig(path.join(dir, 'mops.toml'));
+        return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+    }
+    else {
+        return true;
+    }
 }

package/dist/commands/install/install-mops-dep.d.ts

@@ -3,6 +3,7 @@ type InstallMopsDepOptions = {
     silent?: boolean;
     dep?: boolean;
     threads?: number;
+    ignoreTransitive?: boolean;
 };
-export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads }?: InstallMopsDepOptions): Promise<boolean>;
+export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads, ignoreTransitive }?: InstallMopsDepOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-mops-dep.js

@@ -13,7 +13,7 @@ import { getDepCacheDir, getMopsDepCacheName, isDepCached } from '../../cache.js
 import { downloadFile, getPackageFilesInfo } from '../../api/downloadPackageFiles.js';
 import { installDeps } from './install-deps.js';
 import { getDepName } from '../../helpers/get-dep-name.js';
-export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads } = {}) {
+export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads, ignoreTransitive } = {}) {
     threads = threads || 12;
     let depName = getDepName(pkg);
     if (!checkConfigFile()) {
@@ -90,10 +90,12 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
         logUpdate.clear();
     }
     // install dependencies
-    let config = readConfig(path.join(cacheDir, 'mops.toml'));
-    let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
-    if (!res) {
-        return false;
+    if (!ignoreTransitive) {
+        let config = readConfig(path.join(cacheDir, 'mops.toml'));
+        let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
+        if (!res) {
+            return false;
+        }
     }
     return true;
 }

package/dist/integrity.d.ts

@@ -1,5 +1,25 @@
+type LockFileV1 = {
+    version: 1;
+    mopsTomlHash: string;
+    hashes: Record<string, Record<string, string>>;
+};
+type LockFileV2 = {
+    version: 2;
+    mopsTomlDepsHash: string;
+    hashes: Record<string, Record<string, string>>;
+};
+type LockFileV3 = {
+    version: 3;
+    mopsTomlDepsHash: string;
+    hashes: Record<string, Record<string, string>>;
+    deps: Record<string, string>;
+};
+type LockFile = LockFileV1 | LockFileV2 | LockFileV3;
 export declare function checkIntegrity(lock?: 'check' | 'update' | 'ignore'): Promise<void>;
 export declare function getLocalFileHash(fileId: string): string;
 export declare function checkRemote(): Promise<void>;
+export declare function readLockFile(): LockFile | null;
+export declare function checkLockFileLight(): boolean;
 export declare function updateLockFile(): Promise<void>;
 export declare function checkLockFile(force?: boolean): Promise<void>;
+export {};

package/dist/integrity.js

@@ -78,21 +78,36 @@ export async function checkRemote() {
         }
     }
 }
-export async function updateLockFile() {
+export function readLockFile() {
     let rootDir = getRootDir();
     let lockFile = path.join(rootDir, 'mops.lock');
-    // if lock file exists and mops.toml hasn't changed, don't update it
     if (fs.existsSync(lockFile)) {
-        let lockFileJson = JSON.parse(fs.readFileSync(lockFile).toString());
+        return JSON.parse(fs.readFileSync(lockFile).toString());
+    }
+    return null;
+}
+// check if lock file exists and integrity of mopsTomlDepsHash
+export function checkLockFileLight() {
+    let existingLockFileJson = readLockFile();
+    if (existingLockFileJson) {
         let mopsTomlDepsHash = getMopsTomlDepsHash();
-        if (mopsTomlDepsHash === lockFileJson.mopsTomlDepsHash) {
-            return;
+        if (existingLockFileJson.version === 3 && mopsTomlDepsHash === existingLockFileJson.mopsTomlDepsHash) {
+            return true;
         }
     }
+    return false;
+}
+export async function updateLockFile() {
+    // if lock file exists and mops.toml hasn't changed, don't update it
+    if (checkLockFileLight()) {
+        return;
+    }
+    let resolvedDeps = await resolvePackages();
     let fileHashes = await getFileHashesFromRegistry();
     let lockFileJson = {
-        version: 2,
+        version: 3,
         mopsTomlDepsHash: getMopsTomlDepsHash(),
+        deps: resolvedDeps,
         hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
             acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
                 acc[fileId] = bytesToHex(new Uint8Array(hash));
@@ -101,6 +116,8 @@ export async function updateLockFile() {
             return acc;
         }, {}),
     };
+    let rootDir = getRootDir();
+    let lockFile = path.join(rootDir, 'mops.lock');
     fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
 }
 // compare hashes of local files with hashes from the lock file
@@ -118,9 +135,9 @@ export async function checkLockFile(force = false) {
     let lockFileJsonGeneric = JSON.parse(fs.readFileSync(lockFile).toString());
     let packageIds = await getResolvedMopsPackageIds();
     // check lock file version
-    if (lockFileJsonGeneric.version !== 1 && lockFileJsonGeneric.version !== 2) {
+    if (lockFileJsonGeneric.version !== 1 && lockFileJsonGeneric.version !== 2 && lockFileJsonGeneric.version !== 3) {
         console.error('Integrity check failed');
-        console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: 1`);
+        console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: 1, 2, 3`);
         process.exit(1);
     }
     let lockFileJson = lockFileJsonGeneric;
@@ -134,8 +151,8 @@ export async function checkLockFile(force = false) {
             process.exit(1);
         }
     }
-    // V2: check mops.toml deps hash
-    if (lockFileJson.version === 2) {
+    // V2, V3: check mops.toml deps hash
+    if (lockFileJson.version === 2 || lockFileJson.version === 3) {
         if (lockFileJson.mopsTomlDepsHash !== getMopsTomlDepsHash()) {
             console.error('Integrity check failed');
             console.error('Mismatched mops.toml dependencies hash');
@@ -144,6 +161,20 @@ export async function checkLockFile(force = false) {
             process.exit(1);
         }
     }
+    // V3: check locked deps (including GitHub and local packages)
+    if (lockFileJson.version === 3) {
+        let lockedDeps = { ...lockFileJson.deps };
+        let resolvedDeps = await resolvePackages();
+        for (let name of Object.keys(resolvedDeps)) {
+            if (lockedDeps[name] !== resolvedDeps[name]) {
+                console.error('Integrity check failed');
+                console.error(`Mismatched package ${name}`);
+                console.error(`Locked: ${lockedDeps[name]}`);
+                console.error(`Actual: ${resolvedDeps[name]}`);
+                process.exit(1);
+            }
+        }
+    }
     // check number of packages
     if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
         console.error('Integrity check failed');

package/dist/mops.d.ts

@@ -1,5 +1,5 @@
 import { Identity } from '@dfinity/agent';
-import { Config } from './types.js';
+import { Config, Dependency } from './types.js';
 import { mainActor, storageActor } from './api/actors.js';
 import { getNetwork } from './api/network.js';
 import { getHighestVersion } from './api/getHighestVersion.js';
@@ -21,6 +21,7 @@ export declare function parseGithubURL(href: string): {
 };
 export declare function getGithubCommit(repo: string, ref: string): Promise<any>;
 export declare function getDependencyType(version: string): "local" | "mops" | "github";
+export declare function parseDepValue(name: string, value: string): Dependency;
 export declare function readConfig(configFile?: string): Config;
 export declare function writeConfig(config: Config, configFile?: string): void;
 export declare function formatDir(name: string, version: string): string;

package/dist/mops.js

@@ -135,6 +135,18 @@ export function getDependencyType(version) {
         return 'mops';
     }
 }
+export function parseDepValue(name, value) {
+    let depType = getDependencyType(value);
+    if (depType === 'github') {
+        return { name, repo: value, version: '' };
+    }
+    else if (depType === 'local') {
+        return { name, repo: '', path: value, version: '' };
+    }
+    else {
+        return { name, repo: '', version: value };
+    }
+}
 export function readConfig(configFile = getClosestConfigFile()) {
     let text = fs.readFileSync(configFile).toString();
     let toml = TOML.parse(text);
@@ -143,16 +155,7 @@ export function readConfig(configFile = getClosestConfigFile()) {
             if (!data || typeof data !== 'string') {
                 throw Error(`Invalid dependency value ${name} = "${data}"`);
             }
-            let depType = getDependencyType(data);
-            if (depType === 'github') {
-                deps[name] = { name, repo: data, version: '' };
-            }
-            else if (depType === 'local') {
-                deps[name] = { name, repo: '', path: data, version: '' };
-            }
-            else {
-                deps[name] = { name, repo: '', version: data };
-            }
+            deps[name] = parseDepValue(name, data);
         });
     };
     processDeps(toml.dependencies || {});

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "1.0.1",
+  "version": "1.1.0-pre.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

package/dist/resolve-packages.js

@@ -5,10 +5,17 @@ import { checkConfigFile, getRootDir, parseGithubURL, readConfig } from './mops.
 import { readVesselConfig } from './vessel.js';
 import { getDepCacheDir, getDepCacheName } from './cache.js';
 import { getPackageId } from './helpers/get-package-id.js';
+import { checkLockFileLight, readLockFile } from './integrity.js';
 export async function resolvePackages({ conflicts = 'ignore' } = {}) {
     if (!checkConfigFile()) {
         return {};
     }
+    if (checkLockFileLight()) {
+        let lockFileJson = readLockFile();
+        if (lockFileJson && lockFileJson.version === 3) {
+            return lockFileJson.deps;
+        }
+    }
     let rootDir = getRootDir();
     let packages = {};
     let versions = {};

package/dist/vessel.d.ts

@@ -13,8 +13,9 @@ export declare const readVesselConfig: (dir: string, { cache, silent }?: {
     silent?: boolean | undefined;
 }) => Promise<VesselConfig | null>;
 export declare const downloadFromGithub: (repo: string, dest: string, onProgress: any) => Promise<unknown>;
-export declare const installFromGithub: (name: string, repo: string, { verbose, dep, silent }?: {
+export declare const installFromGithub: (name: string, repo: string, { verbose, dep, silent, ignoreTransitive }?: {
     verbose?: boolean | undefined;
     dep?: boolean | undefined;
     silent?: boolean | undefined;
+    ignoreTransitive?: boolean | undefined;
 }) => Promise<void>;

package/dist/vessel.js

@@ -116,7 +116,7 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     });
     return promise;
 };
-export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false } = {}) => {
+export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false, ignoreTransitive = false } = {}) => {
     let cacheName = getGithubDepCacheName(name, repo);
     let cacheDir = getDepCacheDir(cacheName);
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
@@ -143,6 +143,9 @@ export const installFromGithub = async (name, repo, { verbose = false, dep = fal
     else {
         logUpdate.clear();
     }
+    if (ignoreTransitive) {
+        return;
+    }
     const config = await readVesselConfig(cacheDir, { silent });
     if (config) {
         for (const { name, repo } of config.dependencies) {

package/integrity.ts

@@ -24,7 +24,14 @@ type LockFileV2 = {
 	hashes : Record<string, Record<string, string>>;
 };
 
-type LockFile = LockFileV1 | LockFileV2;
+type LockFileV3 = {
+	version : 3;
+	mopsTomlDepsHash : string;
+	hashes : Record<string, Record<string, string>>;
+	deps : Record<string, string>;
+};
+
+type LockFile = LockFileV1 | LockFileV2 | LockFileV3;
 
 export async function checkIntegrity(lock ?: 'check' | 'update' | 'ignore') {
 	let force = !!lock;
@@ -109,24 +116,41 @@ export async function checkRemote() {
 	}
 }
 
-export async function updateLockFile() {
+export function readLockFile() : LockFile | null {
 	let rootDir = getRootDir();
 	let lockFile = path.join(rootDir, 'mops.lock');
-
-	// if lock file exists and mops.toml hasn't changed, don't update it
 	if (fs.existsSync(lockFile)) {
-		let lockFileJson : LockFileV2 = JSON.parse(fs.readFileSync(lockFile).toString());
+		return JSON.parse(fs.readFileSync(lockFile).toString()) as LockFile;
+	}
+	return null;
+}
+
+// check if lock file exists and integrity of mopsTomlDepsHash
+export function checkLockFileLight() : boolean {
+	let existingLockFileJson = readLockFile();
+	if (existingLockFileJson) {
 		let mopsTomlDepsHash = getMopsTomlDepsHash();
-		if (mopsTomlDepsHash === lockFileJson.mopsTomlDepsHash) {
-			return;
+		if (existingLockFileJson.version === 3 && mopsTomlDepsHash === existingLockFileJson.mopsTomlDepsHash) {
+			return true;
 		}
 	}
+	return false;
+}
+
+export async function updateLockFile() {
+	// if lock file exists and mops.toml hasn't changed, don't update it
+	if (checkLockFileLight()) {
+		return;
+	}
+
+	let resolvedDeps = await resolvePackages();
 
 	let fileHashes = await getFileHashesFromRegistry();
 
-	let lockFileJson : LockFileV2 = {
-		version: 2,
+	let lockFileJson : LockFileV3 = {
+		version: 3,
 		mopsTomlDepsHash: getMopsTomlDepsHash(),
+		deps: resolvedDeps,
 		hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
 			acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
 				acc[fileId] = bytesToHex(new Uint8Array(hash));
@@ -136,6 +160,8 @@ export async function updateLockFile() {
 		}, {} as Record<string, Record<string, string>>),
 	};
 
+	let rootDir = getRootDir();
+	let lockFile = path.join(rootDir, 'mops.lock');
 	fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
 }
 
@@ -157,9 +183,9 @@ export async function checkLockFile(force = false) {
 	let packageIds = await getResolvedMopsPackageIds();
 
 	// check lock file version
-	if (lockFileJsonGeneric.version !== 1 && lockFileJsonGeneric.version !== 2) {
+	if (lockFileJsonGeneric.version !== 1 && lockFileJsonGeneric.version !== 2 && lockFileJsonGeneric.version !== 3) {
 		console.error('Integrity check failed');
-		console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: 1`);
+		console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: 1, 2, 3`);
 		process.exit(1);
 	}
 
@@ -176,8 +202,8 @@ export async function checkLockFile(force = false) {
 		}
 	}
 
-	// V2: check mops.toml deps hash
-	if (lockFileJson.version === 2) {
+	// V2, V3: check mops.toml deps hash
+	if (lockFileJson.version === 2 || lockFileJson.version === 3) {
 		if (lockFileJson.mopsTomlDepsHash !== getMopsTomlDepsHash()) {
 			console.error('Integrity check failed');
 			console.error('Mismatched mops.toml dependencies hash');
@@ -187,6 +213,22 @@ export async function checkLockFile(force = false) {
 		}
 	}
 
+	// V3: check locked deps (including GitHub and local packages)
+	if (lockFileJson.version === 3) {
+		let lockedDeps = {...lockFileJson.deps};
+		let resolvedDeps = await resolvePackages();
+
+		for (let name of Object.keys(resolvedDeps)) {
+			if (lockedDeps[name] !== resolvedDeps[name]) {
+				console.error('Integrity check failed');
+				console.error(`Mismatched package ${name}`);
+				console.error(`Locked: ${lockedDeps[name]}`);
+				console.error(`Actual: ${resolvedDeps[name]}`);
+				process.exit(1);
+			}
+		}
+	}
+
 	// check number of packages
 	if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
 		console.error('Integrity check failed');

package/mops.ts

@@ -8,7 +8,7 @@ import prompts from 'prompts';
 import fetch from 'node-fetch';
 
 import {decodeFile} from './pem.js';
-import {Config} from './types.js';
+import {Config, Dependency} from './types.js';
 import {mainActor, storageActor} from './api/actors.js';
 import {getNetwork} from './api/network.js';
 import {getHighestVersion} from './api/getHighestVersion.js';
@@ -156,6 +156,19 @@ export function getDependencyType(version : string) {
 	}
 }
 
+export function parseDepValue(name : string, value : string) : Dependency {
+	let depType = getDependencyType(value);
+	if (depType === 'github') {
+		return {name, repo: value, version: ''};
+	}
+	else if (depType === 'local') {
+		return {name, repo: '', path: value, version: ''};
+	}
+	else {
+		return {name, repo: '', version: value};
+	}
+}
+
 export function readConfig(configFile = getClosestConfigFile()) : Config {
 	let text = fs.readFileSync(configFile).toString();
 	let toml = TOML.parse(text);
@@ -165,16 +178,7 @@ export function readConfig(configFile = getClosestConfigFile()) : Config {
 			if (!data || typeof data !== 'string') {
 				throw Error(`Invalid dependency value ${name} = "${data}"`);
 			}
-			let depType = getDependencyType(data);
-			if (depType === 'github') {
-				deps[name] = {name, repo: data, version: ''};
-			}
-			else if (depType === 'local') {
-				deps[name] = {name, repo: '', path: data, version: ''};
-			}
-			else {
-				deps[name] = {name, repo: '', version: data};
-			}
+			deps[name] = parseDepValue(name, data);
 		});
 	};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "1.0.1",
+  "version": "1.1.0-pre.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/resolve-packages.ts

@@ -6,12 +6,21 @@ import {VesselConfig, readVesselConfig} from './vessel.js';
 import {Config, Dependency} from './types.js';
 import {getDepCacheDir, getDepCacheName} from './cache.js';
 import {getPackageId} from './helpers/get-package-id.js';
+import {checkLockFileLight, readLockFile} from './integrity.js';
 
 export async function resolvePackages({conflicts = 'ignore' as 'warning' | 'error' | 'ignore'} = {}) : Promise<Record<string, string>> {
 	if (!checkConfigFile()) {
 		return {};
 	}
 
+	if (checkLockFileLight()) {
+		let lockFileJson = readLockFile();
+
+		if (lockFileJson && lockFileJson.version === 3) {
+			return lockFileJson.deps;
+		}
+	}
+
 	let rootDir = getRootDir();
 	let packages : Record<string, Dependency & {isRoot : boolean;}> = {};
 	let versions : Record<string, Array<{

package/test

@@ -0,0 +1,4 @@
+dev, toolchain 89s
+no dev, no toolchain 68s
+lockfile, toolchain 60s
+lockfile, no toolchain 49s

package/vessel.ts

@@ -149,7 +149,7 @@ export const downloadFromGithub = async (repo : string, dest : string, onProgres
 	return promise;
 };
 
-export const installFromGithub = async (name : string, repo : string, {verbose = false, dep = false, silent = false} = {}) => {
+export const installFromGithub = async (name : string, repo : string, {verbose = false, dep = false, silent = false, ignoreTransitive = false} = {}) => {
 	let cacheName = getGithubDepCacheName(name, repo);
 	let cacheDir = getDepCacheDir(cacheName);
 
@@ -183,6 +183,10 @@ export const installFromGithub = async (name : string, repo : string, {verbose =
 		logUpdate.clear();
 	}
 
+	if (ignoreTransitive) {
+		return;
+	}
+
 	const config = await readVesselConfig(cacheDir, {silent});
 
 	if (config) {