@pnpm/installing.context 1001.1.8

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @pnpm/get-context
+
+> Gets context information about a project
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/get-context.svg)](https://www.npmjs.com/package/@pnpm/get-context)
+
+## Installation
+
+```sh
+pnpm add @pnpm/get-context
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,152 @@
+import type { IncludedDependencies, Modules } from '@pnpm/installing.modules-yaml';
+import type { LockfileObject } from '@pnpm/lockfile.fs';
+import type { WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { DepPath, HoistedDependencies, ProjectId, ProjectManifest, ProjectRootDir, ProjectRootDirRealPath, ReadPackageHook, Registries } from '@pnpm/types';
+/**
+ * Note that some fields are affected by modules directory state. Such fields should be used for
+ * mutating the modules directory only or in a manner that does not influence dependency resolution.
+ */
+export interface PnpmContext {
+    currentLockfile: LockfileObject;
+    currentLockfileIsUpToDate: boolean;
+    existsCurrentLockfile: boolean;
+    existsWantedLockfile: boolean;
+    existsNonEmptyWantedLockfile: boolean;
+    extraBinPaths: string[];
+    /** Affected by existing modules directory, if it exists. */
+    extraNodePaths: string[];
+    lockfileHadConflicts: boolean;
+    hoistedDependencies: HoistedDependencies;
+    /** Required included dependencies or dependencies currently included by the modules directory. */
+    include: IncludedDependencies;
+    modulesFile: Modules | null;
+    pendingBuilds: string[];
+    projects: Record<string, {
+        modulesDir: string;
+        id: ProjectId;
+    } & HookOptions & Required<ProjectOptions>>;
+    rootModulesDir: string;
+    hoistPattern: string[] | undefined;
+    /** As applied to existing modules directory, if it exists. */
+    currentHoistPattern: string[] | undefined;
+    hoistedModulesDir: string;
+    publicHoistPattern: string[] | undefined;
+    /** As applied to existing modules directory, if it exists. */
+    currentPublicHoistPattern: string[] | undefined;
+    lockfileDir: string;
+    virtualStoreDir: string;
+    /** As applied to existing modules directory, otherwise options. */
+    virtualStoreDirMaxLength: number;
+    /** As applied to existing modules directory, if it exists. */
+    skipped: Set<DepPath>;
+    storeDir: string;
+    wantedLockfile: LockfileObject;
+    wantedLockfileIsModified: boolean;
+    workspacePackages: WorkspacePackages;
+    registries: Registries;
+}
+export interface ProjectOptions {
+    buildIndex: number;
+    binsDir?: string;
+    manifest: ProjectManifest;
+    modulesDir?: string;
+    rootDir: ProjectRootDir;
+    rootDirRealPath?: ProjectRootDirRealPath;
+}
+interface HookOptions {
+    originalManifest?: ProjectManifest;
+}
+export interface GetContextOptions {
+    autoInstallPeers: boolean;
+    ci?: boolean;
+    excludeLinksFromLockfile: boolean;
+    peersSuffixMaxLength: number;
+    allProjects: Array<ProjectOptions & HookOptions>;
+    confirmModulesPurge?: boolean;
+    force: boolean;
+    frozenLockfile?: boolean;
+    enableGlobalVirtualStore?: boolean;
+    extraBinPaths: string[];
+    extendNodePath?: boolean;
+    lockfileDir: string;
+    modulesDir?: string;
+    nodeLinker: 'isolated' | 'hoisted' | 'pnp';
+    readPackageHook?: ReadPackageHook;
+    include?: IncludedDependencies;
+    registries: Registries;
+    storeDir: string;
+    useLockfile: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+    virtualStoreDir?: string;
+    virtualStoreDirMaxLength: number;
+    workspacePackages?: WorkspacePackages;
+    hoistPattern?: string[] | undefined;
+    forceHoistPattern?: boolean;
+    publicHoistPattern?: string[] | undefined;
+    forcePublicHoistPattern?: boolean;
+    global?: boolean;
+}
+export declare function getContext(opts: GetContextOptions): Promise<PnpmContext>;
+export interface PnpmSingleContext {
+    currentLockfile: LockfileObject;
+    currentLockfileIsUpToDate: boolean;
+    existsCurrentLockfile: boolean;
+    existsWantedLockfile: boolean;
+    existsNonEmptyWantedLockfile: boolean;
+    /** Affected by existing modules directory, if it exists. */
+    extraBinPaths: string[];
+    extraNodePaths: string[];
+    lockfileHadConflicts: boolean;
+    hoistedDependencies: HoistedDependencies;
+    hoistedModulesDir: string;
+    hoistPattern: string[] | undefined;
+    manifest: ProjectManifest;
+    modulesDir: string;
+    importerId: string;
+    prefix: string;
+    /** Required included dependencies or dependencies currently included by the modules directory. */
+    include: IncludedDependencies;
+    modulesFile: Modules | null;
+    pendingBuilds: string[];
+    publicHoistPattern: string[] | undefined;
+    registries: Registries;
+    rootModulesDir: string;
+    lockfileDir: string;
+    virtualStoreDir: string;
+    /** As applied to existing modules directory, if it exists. */
+    skipped: Set<string>;
+    storeDir: string;
+    wantedLockfile: LockfileObject;
+    wantedLockfileIsModified: boolean;
+}
+export declare function getContextForSingleImporter(manifest: ProjectManifest, opts: {
+    autoInstallPeers: boolean;
+    ci?: boolean;
+    enableGlobalVirtualStore?: boolean;
+    excludeLinksFromLockfile: boolean;
+    peersSuffixMaxLength: number;
+    force: boolean;
+    confirmModulesPurge?: boolean;
+    extraBinPaths: string[];
+    extendNodePath?: boolean;
+    lockfileDir: string;
+    nodeLinker: 'isolated' | 'hoisted' | 'pnp';
+    modulesDir?: string;
+    readPackageHook?: ReadPackageHook;
+    include?: IncludedDependencies;
+    dir: string;
+    registries: Registries;
+    storeDir: string;
+    useLockfile: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+    virtualStoreDir?: string;
+    virtualStoreDirMaxLength: number;
+    hoistPattern?: string[] | undefined;
+    forceHoistPattern?: boolean;
+    publicHoistPattern?: string[] | undefined;
+    forcePublicHoistPattern?: boolean;
+}): Promise<PnpmSingleContext>;
+export declare function arrayOfWorkspacePackagesToMap(pkgs: Array<Pick<ProjectOptions, 'manifest' | 'rootDir'>>): WorkspacePackages;
+export {};

package/lib/index.js

@@ -0,0 +1,188 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { contextLogger, packageManifestLogger } from '@pnpm/core-loggers';
+import { readProjectsContext } from '@pnpm/installing.read-projects-context';
+import { registerProject } from '@pnpm/store.controller';
+import { pathAbsolute } from 'path-absolute';
+import { clone } from 'ramda';
+import { readLockfiles } from './readLockfiles.js';
+export async function getContext(opts) {
+    const modulesDir = opts.modulesDir ?? 'node_modules';
+    const importersContext = await readProjectsContext(opts.allProjects, { lockfileDir: opts.lockfileDir, modulesDir });
+    const virtualStoreDir = pathAbsolute(opts.virtualStoreDir ?? path.join(modulesDir, '.pnpm'), opts.lockfileDir);
+    await fs.mkdir(opts.storeDir, { recursive: true });
+    // Register this project for store prune tracking
+    await registerProject(opts.storeDir, opts.lockfileDir);
+    for (const project of opts.allProjects) {
+        packageManifestLogger.debug({
+            initial: project.manifest,
+            prefix: project.rootDir,
+        });
+    }
+    if (opts.readPackageHook != null) {
+        await Promise.all(importersContext.projects.map(async (project) => {
+            project.originalManifest = project.manifest;
+            project.manifest = await opts.readPackageHook(clone(project.manifest), project.rootDir);
+        }));
+    }
+    const extraBinPaths = [
+        ...opts.extraBinPaths || [],
+    ];
+    const internalPnpmDir = path.join(importersContext.rootModulesDir, '.pnpm');
+    const hoistedModulesDir = path.join(opts.enableGlobalVirtualStore ? internalPnpmDir : virtualStoreDir, 'node_modules');
+    if (opts.hoistPattern?.length) {
+        extraBinPaths.unshift(path.join(hoistedModulesDir, '.bin'));
+    }
+    const ctx = {
+        extraBinPaths,
+        extraNodePaths: getExtraNodePaths({
+            extendNodePath: opts.extendNodePath,
+            nodeLinker: opts.nodeLinker,
+            hoistPattern: importersContext.currentHoistPattern ?? opts.hoistPattern,
+            hoistedModulesDir,
+        }),
+        hoistedDependencies: importersContext.hoistedDependencies,
+        hoistedModulesDir,
+        hoistPattern: opts.hoistPattern,
+        currentHoistPattern: importersContext.currentHoistPattern,
+        include: opts.include ?? importersContext.include,
+        lockfileDir: opts.lockfileDir,
+        modulesFile: importersContext.modules,
+        pendingBuilds: importersContext.pendingBuilds,
+        projects: Object.fromEntries(importersContext.projects.map((project) => [project.rootDir, project])),
+        publicHoistPattern: opts.publicHoistPattern,
+        currentPublicHoistPattern: importersContext.currentPublicHoistPattern,
+        registries: opts.registries,
+        rootModulesDir: importersContext.rootModulesDir,
+        skipped: importersContext.skipped,
+        storeDir: opts.storeDir,
+        virtualStoreDir,
+        virtualStoreDirMaxLength: importersContext.virtualStoreDirMaxLength ?? opts.virtualStoreDirMaxLength,
+        workspacePackages: opts.workspacePackages ?? arrayOfWorkspacePackagesToMap(opts.allProjects),
+        ...await readLockfiles({
+            autoInstallPeers: opts.autoInstallPeers,
+            ci: opts.ci,
+            excludeLinksFromLockfile: opts.excludeLinksFromLockfile,
+            peersSuffixMaxLength: opts.peersSuffixMaxLength,
+            force: opts.force,
+            frozenLockfile: opts.frozenLockfile === true,
+            lockfileDir: opts.lockfileDir,
+            projects: importersContext.projects,
+            registry: opts.registries.default,
+            useLockfile: opts.useLockfile,
+            useGitBranchLockfile: opts.useGitBranchLockfile,
+            mergeGitBranchLockfiles: opts.mergeGitBranchLockfiles,
+            internalPnpmDir,
+        }),
+    };
+    contextLogger.debug({
+        currentLockfileExists: ctx.existsCurrentLockfile,
+        storeDir: opts.storeDir,
+        virtualStoreDir,
+    });
+    return ctx;
+}
+export async function getContextForSingleImporter(manifest, opts) {
+    const { currentHoistPattern, hoistedDependencies, projects, include, modules, pendingBuilds, registries, skipped, rootModulesDir, } = await readProjectsContext([
+        {
+            rootDir: opts.dir,
+        },
+    ], {
+        lockfileDir: opts.lockfileDir,
+        modulesDir: opts.modulesDir,
+    });
+    const storeDir = opts.storeDir;
+    const importer = projects[0];
+    const modulesDir = importer.modulesDir;
+    const importerId = importer.id;
+    const virtualStoreDir = pathAbsolute(opts.virtualStoreDir ?? 'node_modules/.pnpm', opts.lockfileDir);
+    await fs.mkdir(storeDir, { recursive: true });
+    // Register this project for store prune tracking
+    await registerProject(storeDir, opts.lockfileDir);
+    const extraBinPaths = [
+        ...opts.extraBinPaths || [],
+    ];
+    const internalPnpmDir = path.join(rootModulesDir, '.pnpm');
+    const hoistedModulesDir = path.join(opts.enableGlobalVirtualStore ? internalPnpmDir : virtualStoreDir, 'node_modules');
+    if (opts.hoistPattern?.length) {
+        extraBinPaths.unshift(path.join(hoistedModulesDir, '.bin'));
+    }
+    const ctx = {
+        extraBinPaths,
+        extraNodePaths: getExtraNodePaths({
+            extendNodePath: opts.extendNodePath,
+            nodeLinker: opts.nodeLinker,
+            hoistPattern: currentHoistPattern ?? opts.hoistPattern,
+            hoistedModulesDir,
+        }),
+        hoistedDependencies,
+        hoistedModulesDir,
+        hoistPattern: opts.hoistPattern,
+        importerId,
+        include: opts.include ?? include,
+        lockfileDir: opts.lockfileDir,
+        manifest: await opts.readPackageHook?.(manifest) ?? manifest,
+        modulesDir,
+        modulesFile: modules,
+        pendingBuilds,
+        prefix: opts.dir,
+        publicHoistPattern: opts.publicHoistPattern,
+        registries: {
+            ...opts.registries,
+            ...registries,
+        },
+        rootModulesDir,
+        skipped,
+        storeDir,
+        virtualStoreDir,
+        ...await readLockfiles({
+            autoInstallPeers: opts.autoInstallPeers,
+            ci: opts.ci,
+            excludeLinksFromLockfile: opts.excludeLinksFromLockfile,
+            peersSuffixMaxLength: opts.peersSuffixMaxLength,
+            force: opts.force,
+            frozenLockfile: false,
+            lockfileDir: opts.lockfileDir,
+            projects: [{ id: importerId, rootDir: opts.dir }],
+            registry: opts.registries.default,
+            useLockfile: opts.useLockfile,
+            useGitBranchLockfile: opts.useGitBranchLockfile,
+            mergeGitBranchLockfiles: opts.mergeGitBranchLockfiles,
+            internalPnpmDir,
+        }),
+    };
+    packageManifestLogger.debug({
+        initial: manifest,
+        prefix: opts.dir,
+    });
+    contextLogger.debug({
+        currentLockfileExists: ctx.existsCurrentLockfile,
+        storeDir: opts.storeDir,
+        virtualStoreDir,
+    });
+    return ctx;
+}
+function getExtraNodePaths({ extendNodePath = true, hoistPattern, nodeLinker, hoistedModulesDir }) {
+    if (extendNodePath && nodeLinker === 'isolated' && hoistPattern?.length) {
+        return [hoistedModulesDir];
+    }
+    return [];
+}
+export function arrayOfWorkspacePackagesToMap(pkgs) {
+    const workspacePkgs = new Map();
+    for (const { manifest, rootDir } of pkgs) {
+        if (!manifest.name)
+            continue;
+        let workspacePkgsByVersion = workspacePkgs.get(manifest.name);
+        if (!workspacePkgsByVersion) {
+            workspacePkgsByVersion = new Map();
+            workspacePkgs.set(manifest.name, workspacePkgsByVersion);
+        }
+        workspacePkgsByVersion.set(manifest.version ?? '0.0.0', {
+            manifest: manifest,
+            rootDir,
+        });
+    }
+    return workspacePkgs;
+}
+//# sourceMappingURL=index.js.map

package/lib/readLockfiles.d.ts

@@ -0,0 +1,36 @@
+import { type LockfileObject } from '@pnpm/lockfile.fs';
+import type { ProjectId, ProjectRootDir } from '@pnpm/types';
+export interface PnpmContext {
+    currentLockfile: LockfileObject;
+    existsCurrentLockfile: boolean;
+    existsWantedLockfile: boolean;
+    existsNonEmptyWantedLockfile: boolean;
+    wantedLockfile: LockfileObject;
+}
+export declare function readLockfiles(opts: {
+    autoInstallPeers: boolean;
+    excludeLinksFromLockfile: boolean;
+    peersSuffixMaxLength: number;
+    ci?: boolean;
+    force: boolean;
+    frozenLockfile: boolean;
+    projects: Array<{
+        id: ProjectId;
+        rootDir: ProjectRootDir;
+    }>;
+    lockfileDir: string;
+    registry: string;
+    useLockfile: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+    internalPnpmDir: string;
+}): Promise<{
+    currentLockfile: LockfileObject;
+    currentLockfileIsUpToDate: boolean;
+    existsCurrentLockfile: boolean;
+    existsWantedLockfile: boolean;
+    existsNonEmptyWantedLockfile: boolean;
+    wantedLockfile: LockfileObject;
+    wantedLockfileIsModified: boolean;
+    lockfileHadConflicts: boolean;
+}>;

package/lib/readLockfiles.js

@@ -0,0 +1,100 @@
+import { LOCKFILE_VERSION, WANTED_LOCKFILE, } from '@pnpm/constants';
+import { createLockfileObject, existsNonEmptyWantedLockfile, isEmptyLockfile, readCurrentLockfile, readWantedLockfile, readWantedLockfileAndAutofixConflicts, } from '@pnpm/lockfile.fs';
+import { logger } from '@pnpm/logger';
+import { clone, equals } from 'ramda';
+export async function readLockfiles(opts) {
+    const wantedLockfileVersion = LOCKFILE_VERSION;
+    // On CI, avoid breaking builds due to incompatible lockfiles by default.
+    // Ignore incompatible lockfiles only for non-frozen CI installs or when `force` is set;
+    // in frozen-lockfile mode, incompatible lockfiles should still fail.
+    const lockfileOpts = {
+        ignoreIncompatible: opts.force || (opts.ci === true && !opts.frozenLockfile),
+        wantedVersions: [LOCKFILE_VERSION],
+        useGitBranchLockfile: opts.useGitBranchLockfile,
+        mergeGitBranchLockfiles: opts.mergeGitBranchLockfiles,
+    };
+    const fileReads = [];
+    let lockfileHadConflicts = false;
+    if (opts.useLockfile) {
+        if (!opts.frozenLockfile) {
+            fileReads.push((async () => {
+                try {
+                    const { lockfile, hadConflicts } = await readWantedLockfileAndAutofixConflicts(opts.lockfileDir, lockfileOpts);
+                    lockfileHadConflicts = hadConflicts;
+                    return lockfile;
+                }
+                catch (err) { // eslint-disable-line
+                    logger.warn({
+                        message: `Ignoring broken lockfile at ${opts.lockfileDir}: ${err.message}`,
+                        prefix: opts.lockfileDir,
+                    });
+                    return undefined;
+                }
+            })());
+        }
+        else {
+            fileReads.push(readWantedLockfile(opts.lockfileDir, lockfileOpts));
+        }
+    }
+    else {
+        if (await existsNonEmptyWantedLockfile(opts.lockfileDir, lockfileOpts)) {
+            logger.warn({
+                message: `A ${WANTED_LOCKFILE} file exists. The current configuration prohibits to read or write a lockfile`,
+                prefix: opts.lockfileDir,
+            });
+        }
+        fileReads.push(Promise.resolve(undefined));
+    }
+    fileReads.push((async () => {
+        try {
+            return await readCurrentLockfile(opts.internalPnpmDir, lockfileOpts);
+        }
+        catch (err) { // eslint-disable-line
+            logger.warn({
+                message: `Ignoring broken lockfile at ${opts.internalPnpmDir}: ${err.message}`,
+                prefix: opts.lockfileDir,
+            });
+            return undefined;
+        }
+    })());
+    const files = await Promise.all(fileReads);
+    const sopts = {
+        autoInstallPeers: opts.autoInstallPeers,
+        excludeLinksFromLockfile: opts.excludeLinksFromLockfile,
+        lockfileVersion: wantedLockfileVersion,
+        peersSuffixMaxLength: opts.peersSuffixMaxLength,
+    };
+    const importerIds = opts.projects.map((importer) => importer.id);
+    const currentLockfile = files[1] ?? createLockfileObject(importerIds, sopts);
+    for (const importerId of importerIds) {
+        if (!currentLockfile.importers[importerId]) {
+            currentLockfile.importers[importerId] = {
+                specifiers: {},
+            };
+        }
+    }
+    const wantedLockfile = files[0] ??
+        (currentLockfile && clone(currentLockfile)) ??
+        createLockfileObject(importerIds, sopts);
+    let wantedLockfileIsModified = false;
+    for (const importerId of importerIds) {
+        if (!wantedLockfile.importers[importerId]) {
+            wantedLockfileIsModified = true;
+            wantedLockfile.importers[importerId] = {
+                specifiers: {},
+            };
+        }
+    }
+    const existsWantedLockfile = files[0] != null;
+    return {
+        currentLockfile,
+        currentLockfileIsUpToDate: equals(currentLockfile, wantedLockfile),
+        existsCurrentLockfile: files[1] != null,
+        existsWantedLockfile,
+        existsNonEmptyWantedLockfile: existsWantedLockfile && !isEmptyLockfile(wantedLockfile),
+        wantedLockfile,
+        wantedLockfileIsModified,
+        lockfileHadConflicts,
+    };
+}
+//# sourceMappingURL=readLockfiles.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pnpm/installing.context",
+  "version": "1001.1.8",
+  "description": "Gets context information about a project",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "scripts"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/installing/context",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/installing/context#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "path-absolute": "^2.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "@pnpm/installing.modules-yaml": "1000.3.6",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/lockfile.fs": "1001.1.21",
+    "@pnpm/installing.read-projects-context": "1000.0.24",
+    "@pnpm/resolving.resolver-base": "1005.1.0",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/store.controller": "1004.0.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@types/ramda": "0.29.12",
+    "@pnpm/installing.context": "1001.1.8",
+    "@pnpm/logger": "1001.0.1"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}