@doki-land/nifty 0.1.1 → 0.1.3

package/src/cli/format.ts

@@ -2,38 +2,38 @@ import { loadConfig, resolveFormatConfig } from "../config/index.js";
 import { loadNiftyNative } from "../native.js";
 
 export type FormatOptions = {
-    check ? : boolean;
-    cwd ? : string;
+    check?: boolean;
+    cwd?: string;
 };
 
-export async function formatWorkspace(options : FormatOptions) : Promise<number>{
+export async function formatWorkspace(options: FormatOptions): Promise<number> {
     const cwd = options.cwd ?? process.cwd();
-    const { config } = await loadConfig({ cwd, createIfMissing : false, env : { command : "format" } });
+    const { config } = await loadConfig({ cwd, createIfMissing: false, env: { command: "format" } });
     const resolved = resolveFormatConfig(config.format);
     const native = loadNiftyNative();
     const report = native.formatter.run({
         cwd,
-        check : options.check,
-        includes : resolved.includes,
-        excludes : resolved.excludes,
-        rust : resolved.rust,
-        javascript : resolved.javascript,
-        style : resolved.style,
+        check: options.check,
+        includes: resolved.includes,
+        excludes: resolved.excludes,
+        rust: resolved.rust,
+        javascript: resolved.javascript,
+        style: resolved.style,
     });
 
-    if(report.errors.length>0){
-        for(const message of report.errors){
+    if (report.errors.length > 0) {
+        for (const message of report.errors) {
             console.error(`error: ${message}`);
         }
     }
 
-    if(report.formatted === 0 && report.unchanged>0 && report.errors.length === 0){
+    if (report.formatted === 0 && report.unchanged > 0 && report.errors.length === 0) {
         console.log(`format: no changes needed (preset ${resolved.preset})`);
-    } else if(report.errors.length === 0){
+    } else if (report.errors.length === 0) {
         console.log(
             `format: ${report.formatted} file(s) updated, ${report.unchanged} unchanged (preset ${resolved.preset})`,
         );
     }
 
-    return report.errors.length>0 ? 1 : 0;
+    return report.errors.length > 0 ? 1 : 0;
 }

package/src/cli/install-native-cmd.ts

@@ -3,20 +3,20 @@ import type { Cli, ParsedOptions } from "@vmz/commander";
 import { installNativeFromOptions } from "./install-native.js";
 import { cwdFrom, str } from "./options.js";
 
-export function registerInstallNativeCommand(cli : Cli) : void {
+export function registerInstallNativeCommand(cli: Cli): void {
     cli.command("install-native", "cli.cmd.install-native")
         .option("--from <dir>", "cli.opt.from-artifacts")
-        .action(async(options) =>cmdInstallNative(options));
+        .action(async (options) => cmdInstallNative(options));
 }
 
-export async function cmdInstallNative(options : ParsedOptions) : Promise<number>{
+export async function cmdInstallNative(options: ParsedOptions): Promise<number> {
     const from =
         str(options, "from") ??
         process.env.NATIVE_ARTIFACT_ROOT ??
         "native-artifacts";
     installNativeFromOptions({
         from,
-        cwd : cwdFrom(options),
+        cwd: cwdFrom(options),
     });
     return 0;
 }

package/src/cli/install-native.ts

@@ -4,12 +4,12 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { detectProjectLayout } from "../config/detectProject.js";
 
 /** Basename of a built .node file → platform package directory under projects/packages/. */
-const PACKAGE_BY_ASSET : Record<string, string> = {
-    "nifty-win32-x64-msvc.node" : "nifty-win32-x64",
-    "nifty-linux-x64-gnu.node" : "nifty-linux-x64",
-    "nifty-linux-arm64-gnu.node" : "nifty-linux-arm64",
-    "nifty-darwin-x64.node" : "nifty-darwin-x64",
-    "nifty-darwin-arm64.node" : "nifty-darwin-arm64",
+const PACKAGE_BY_ASSET: Record<string, string> = {
+    "nifty-win32-x64-msvc.node": "nifty-win32-x64",
+    "nifty-linux-x64-gnu.node": "nifty-linux-x64",
+    "nifty-linux-arm64-gnu.node": "nifty-linux-arm64",
+    "nifty-darwin-x64.node": "nifty-darwin-x64",
+    "nifty-darwin-arm64.node": "nifty-darwin-arm64",
 };
 
 /** Matrix platforms that must be present after install (matches publish-npm.yml). */
@@ -17,61 +17,61 @@ const REQUIRED_PACKAGES = ["nifty-win32-x64", "nifty-linux-x64", "nifty-darwin-a
 
 export type InstallNativeOptions = {
     /** Downloaded CI artifact tree (walked recursively for .node files). */
-    from : string;
-    cwd ? : string;
+    from: string;
+    cwd?: string;
 };
 
-function walkNodes(dir : string) : string[]{
-    const out : string[] = [];
-    if(!existsSync(dir)){
+function walkNodes(dir: string): string[] {
+    const out: string[] = [];
+    if (!existsSync(dir)) {
         return out;
     }
-    for(const entry of readdirSync(dir, { withFileTypes : true })){
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
         const full = join(dir, entry.name);
-        if(entry.isDirectory()){
+        if (entry.isDirectory()) {
             out.push(...walkNodes(full));
-        } else if(entry.isFile() && entry.name.endsWith(".node")){
+        } else if (entry.isFile() && entry.name.endsWith(".node")) {
             out.push(full);
         }
     }
     return out;
 }
 
-function libHasNode(libDir : string) : boolean {
-    return existsSync(libDir) && readdirSync(libDir).some((name) =>name.endsWith(".node"));
+function libHasNode(libDir: string): boolean {
+    return existsSync(libDir) && readdirSync(libDir).some((name) => name.endsWith(".node"));
 }
 
 /** Copy matrix .node artifacts into platform package lib dirs for npm publish. */
-export function installNativeFromOptions(options : InstallNativeOptions) : void {
+export function installNativeFromOptions(options: InstallNativeOptions): void {
     const layout = detectProjectLayout(options.cwd ?? process.cwd());
     const artifactRoot = resolve(layout.root, options.from);
     const nodes = walkNodes(artifactRoot);
-    if(nodes.length === 0){
+    if (nodes.length === 0) {
         throw new Error(`install-native: no .node files under ${artifactRoot}`);
     }
 
     let installed = 0;
-    for(const file of nodes){
+    for (const file of nodes) {
         const base = basename(file);
         const packageDir = PACKAGE_BY_ASSET[base];
-        if(!packageDir){
+        if (!packageDir) {
             console.log(`skip unmapped artifact ${relative(artifactRoot, file)}`);
             continue;
         }
         const dest = join(layout.root, "projects/packages", packageDir, "lib", base);
-        mkdirSync(dirname(dest), { recursive : true });
+        mkdirSync(dirname(dest), { recursive: true });
         copyFileSync(file, dest);
         console.log(`installed ${relative(layout.root, dest)}`);
         installed += 1;
     }
 
-    if(installed === 0){
+    if (installed === 0) {
         throw new Error("install-native: no mapped platform .node files installed");
     }
 
-    for(const packageDir of REQUIRED_PACKAGES){
+    for (const packageDir of REQUIRED_PACKAGES) {
         const libDir = join(layout.root, "projects/packages", packageDir, "lib");
-        if(!libHasNode(libDir)){
+        if (!libHasNode(libDir)) {
             throw new Error(`install-native: missing .node under ${packageDir}/lib`);
         }
     }

package/src/cli/lint-cmd.ts

@@ -4,31 +4,31 @@ import { bootstrapFromOptions } from "./context.js";
 import { lintCommits, type LintOptions } from "./lint.js";
 import { cwdFrom, flag, str, strList } from "./options.js";
 
-export function registerLintCommands(cli : Cli) : void {
+export function registerLintCommands(cli: Cli): void {
     registerLintLike(cli, "lint", "cli.cmd.lint", false);
     registerLintLike(cli, "check", "cli.cmd.check", true);
 }
 
-function registerLintLike(cli : Cli, name : string, helpId : string, check : boolean) : void {
+function registerLintLike(cli: Cli, name: string, helpId: string, check: boolean): void {
     cli.command(name, helpId)
         .option("--from <ref>", "cli.opt.from")
         .option("--to <ref>", "cli.opt.to")
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--no-cargo", "cli.opt.no-cargo")
-        .action(async(options) =>cmdLint(options, check));
+        .action(async (options) => cmdLint(options, check));
 }
 
-export async function cmdLint(options : ParsedOptions, check : boolean) : Promise<number>{
+export async function cmdLint(options: ParsedOptions, check: boolean): Promise<number> {
     await bootstrapFromOptions(options);
-    const lintOptions : LintOptions = {
-        subjects : strList(options, "subject"),
-        from : str(options, "from"),
-        to : str(options, "to"),
-        cwd : cwdFrom(options),
-        scanCargo : flag(options, "no-cargo") ? false : undefined,
+    const lintOptions: LintOptions = {
+        subjects: strList(options, "subject"),
+        from: str(options, "from"),
+        to: str(options, "to"),
+        cwd: cwdFrom(options),
+        scanCargo: flag(options, "no-cargo") ? false : undefined,
     };
     const errorCount = await lintCommits(lintOptions, check);
-    if(check && errorCount>0){
+    if (check && errorCount > 0) {
         throw new Error(`found ${errorCount} lint error(s)`);
     }
     return 0;

package/src/cli/lint.ts

@@ -3,70 +3,70 @@ import { loadNiftyNative } from "../native.js";
 import { printCommitLintReport, type CommitLintDiagnostic } from "./commit-lint-report.js";
 
 export type LintOptions = {
-    subjects : string[];
-    from ? : string;
-    to ? : string;
-    cwd ? : string;
-    scanCargo ? : boolean;
-    commitOnly ? : boolean;
-    json ? : boolean;
-    errorsOnly ? : boolean;
-    reportTitle ? : string;
+    subjects: string[];
+    from?: string;
+    to?: string;
+    cwd?: string;
+    scanCargo?: boolean;
+    commitOnly?: boolean;
+    json?: boolean;
+    errorsOnly?: boolean;
+    reportTitle?: string;
 };
 
 type LintDiagnostic = CommitLintDiagnostic;
 
 type LintRuleConfig = {
-    id : string;
-    enabled ? : boolean;
-    severity ? : "error" | "warning" | "info";
+    id: string;
+    enabled?: boolean;
+    severity?: "error" | "warning" | "info";
 };
 
-export async function runLint(argv : string[], check : boolean) : Promise<void>{
+export async function runLint(argv: string[], check: boolean): Promise<void> {
     const options = parseLintArgs(argv);
     const errorCount = await lintCommits(options, check);
-    if(check && errorCount>0){
+    if (check && errorCount > 0) {
         throw new Error(`found ${errorCount} lint error(s)`);
     }
 }
 
 export async function lintCommits(
-    options : LintOptions,
-    check : boolean,
+    options: LintOptions,
+    check: boolean,
     commitOnly = options.commitOnly ?? false,
-) : Promise<number>{
+): Promise<number> {
     const native = loadNiftyNative();
     const cwd = options.cwd ?? process.cwd();
-    const { config } = await loadConfig({ cwd, createIfMissing : false });
-    const rules : LintRuleConfig[] | undefined = config.lint ?.rules ?.map((rule) =>({
-        id : rule.id,
-        enabled : rule.enabled,
-        severity : rule.severity,
+    const { config } = await loadConfig({ cwd, createIfMissing: false });
+    const rules: LintRuleConfig[] | undefined = config.lint?.rules?.map((rule) => ({
+        id: rule.id,
+        enabled: rule.enabled,
+        severity: rule.severity,
     }));
 
     const runner = check ? native.lint.check : native.lint.run;
     const report = runner({
         cwd,
-        fromRef : options.from,
-        toRef : options.to,
-        subjects : options.subjects.length>0 ? options.subjects : undefined,
+        fromRef: options.from,
+        toRef: options.to,
+        subjects: options.subjects.length > 0 ? options.subjects : undefined,
         rules,
-        scanCargo : options.scanCargo,
-        commitOnly : commitOnly || options.commitOnly,
+        scanCargo: options.scanCargo,
+        commitOnly: commitOnly || options.commitOnly,
     });
 
-    if(commitOnly || options.commitOnly){
+    if (commitOnly || options.commitOnly) {
         printCommitLintReport(report.diagnostics, report.errorCount, report.warningCount, {
-            json : options.json,
-            errorsOnly : options.errorsOnly,
-            title : options.reportTitle ?? "commit lint",
+            json: options.json,
+            errorsOnly: options.errorsOnly,
+            title: options.reportTitle ?? "commit lint",
         });
     } else {
-        for(const item of report.diagnostics){
+        for (const item of report.diagnostics) {
             printWorkspaceDiagnostic(item);
         }
 
-        if(report.diagnostics.length>0){
+        if (report.diagnostics.length > 0) {
             console.log(`lint: ${report.errorCount} error(s), ${report.warningCount} warning(s)`);
         } else {
             console.log("lint: no issues found");
@@ -76,16 +76,16 @@ export async function lintCommits(
     return report.errorCount;
 }
 
-function printWorkspaceDiagnostic(item : LintDiagnostic) : void {
+function printWorkspaceDiagnostic(item: LintDiagnostic): void {
     const prefix = item.severity === "error" ? "error" : item.severity === "warning" ? "warning" : "info";
-    if(item.subject){
+    if (item.subject) {
         const hash = item.hash ? `${item.hash.slice(0, 8)} ` : "";
         console.log(`${prefix} [${item.rule}] ${hash}${item.message} (${item.subject})`);
         return;
     }
     const location =
-        item.path!== undefined
-            ? item.line!== undefined
+        item.path !== undefined
+            ? item.line !== undefined
                 ? `${item.path}:${item.line}`
                 : item.path
             : undefined;
@@ -93,19 +93,19 @@ function printWorkspaceDiagnostic(item : LintDiagnostic) : void {
     console.log(`${prefix} [${item.rule}] ${item.message}${suffix}`);
 }
 
-function parseLintArgs(argv : string[]) : LintOptions {
-    const options : LintOptions = { subjects : [] };
-    for(let i = 0; i<argv.length; i += 1){
+function parseLintArgs(argv: string[]): LintOptions {
+    const options: LintOptions = { subjects: [] };
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "--from"){
-            options.from = argv[ ++ i];
-        } else if(arg === "--to"){
-            options.to = argv[ ++ i];
-        } else if(arg === "-C" || arg === "--cwd"){
-            options.cwd = argv[ ++ i];
-        } else if(arg === "-s" || arg === "--subject"){
-            options.subjects.push(argv[ ++ i]);
-        } else if(arg === "--no-cargo"){
+        if (arg === "--from") {
+            options.from = argv[++i];
+        } else if (arg === "--to") {
+            options.to = argv[++i];
+        } else if (arg === "-C" || arg === "--cwd") {
+            options.cwd = argv[++i];
+        } else if (arg === "-s" || arg === "--subject") {
+            options.subjects.push(argv[++i]);
+        } else if (arg === "--no-cargo") {
             options.scanCargo = false;
         }
     }

package/src/cli/options.ts

@@ -5,36 +5,36 @@ import type { ParsedOptions } from "@vmz/commander";
 import { resolveNpmExecutable } from "./resolveNpm.js";
 import type { AuthCliOptions } from "./authArgs.js";
 
-export function cwdFrom(options : ParsedOptions) : string | undefined {
+export function cwdFrom(options: ParsedOptions): string | undefined {
     const value = options.cwd;
-    return typeof value === "string" && value.length>0 ? resolve(value) : undefined;
+    return typeof value === "string" && value.length > 0 ? resolve(value) : undefined;
 }
 
-export function flag(options : ParsedOptions, key : string) : boolean {
+export function flag(options: ParsedOptions, key: string): boolean {
     return options[key] === true;
 }
 
-export function str(options : ParsedOptions, key : string) : string | undefined {
+export function str(options: ParsedOptions, key: string): string | undefined {
     const value = options[key];
-    return typeof value === "string" && value.length>0 ? value : undefined;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-export function strList(options : ParsedOptions, key : string) : string[]{
+export function strList(options: ParsedOptions, key: string): string[] {
     const value = options[key];
-    if(Array.isArray(value)){
-        return value.filter((entry) : entry is string =>typeof entry === "string" && entry.length>0);
+    if (Array.isArray(value)) {
+        return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
     }
-    if(typeof value === "string" && value.length>0){
-        return[value];
+    if (typeof value === "string" && value.length > 0) {
+        return [value];
     }
-    return[];
+    return [];
 }
 
-export function authFromOptions(options : ParsedOptions) : AuthCliOptions {
+export function authFromOptions(options: ParsedOptions): AuthCliOptions {
     return {
-        otp : str(options, "otp"),
-        totpSecret : str(options, "totp-secret"),
-        token : str(options, "npm-token") ?? str(options, "token"),
-        npm : resolveNpmExecutable(),
+        otp: str(options, "otp"),
+        totpSecret: str(options, "totp-secret"),
+        token: str(options, "npm-token") ?? str(options, "token"),
+        npm: resolveNpmExecutable(),
     };
 }

package/src/cli/publish-cmd.ts

@@ -8,7 +8,7 @@ import { bootstrapFromOptions } from "./context.js";
 import { printPublishReport } from "./publish.js";
 import { authFromOptions, cwdFrom, flag, str, strList } from "./options.js";
 
-export function registerPublishCommand(cli : Cli) : void {
+export function registerPublishCommand(cli: Cli): void {
     cli.command("publish", "cli.cmd.publish")
         .option("--dry-run", "cli.opt.dry-run")
         .option("--refresh", "cli.opt.refresh")
@@ -19,29 +19,29 @@ export function registerPublishCommand(cli : Cli) : void {
         .option("--otp <code>", "cli.opt.otp")
         .option("--totp-secret <secret>", "cli.opt.totp-secret")
         .option("--npm-token <token>", "cli.opt.npm-token")
-        .action(async(options) =>cmdPublish(options));
+        .action(async (options) => cmdPublish(options));
 }
 
-export async function cmdPublish(options : ParsedOptions) : Promise<number>{
+export async function cmdPublish(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
-    const { config } = await loadConfig({ cwd : cwdFrom(options), createIfMissing : false });
+    const { config } = await loadConfig({ cwd: cwdFrom(options), createIfMissing: false });
     const packages = strList(options, "package");
-    const fromConfig = config.publish ?.packages ?? [];
+    const fromConfig = config.publish?.packages ?? [];
     const native = loadNiftyNative();
     const report = native.publisher["publish-workspace"]({
-        cwd : cwdFrom(options),
-        dryRun : flag(options, "dry-run"),
-        refresh : flag(options, "refresh"),
-        placeholder : flag(options, "placeholder"),
-        tag : str(options, "tag"),
-        access : str(options, "access") ?? "public",
+        cwd: cwdFrom(options),
+        dryRun: flag(options, "dry-run"),
+        refresh: flag(options, "refresh"),
+        placeholder: flag(options, "placeholder"),
+        tag: str(options, "tag"),
+        access: str(options, "access") ?? "public",
         ...(packages.length === 1
-            ? { only : packages[0] }
-            : packages.length>1
+            ? { only: packages[0] }
+            : packages.length > 1
               ? { packages }
-              : fromConfig.length>0
-                ? { packages : fromConfig }
-                : { }),
+              : fromConfig.length > 0
+                ? { packages: fromConfig }
+                : {}),
         ...trustPayloadFromConfig(config),
         ...authPayload(authFromOptions(options)),
     });

package/src/cli/publish.ts

@@ -2,64 +2,64 @@ import { loadNiftyNative } from "../native.js";
 import { authPayload, parseAuthArgs } from "./authArgs.js";
 
 export type PublishOptions = {
-    cwd ? : string;
-    dryRun ? : boolean;
-    refresh ? : boolean;
-    placeholder ? : boolean;
-    tag ? : string;
-    access ? : string;
+    cwd?: string;
+    dryRun?: boolean;
+    refresh?: boolean;
+    placeholder?: boolean;
+    tag?: string;
+    access?: string;
 };
 
 export type PublishReport = {
-    root : string;
-    order : string[];
-    published : string[];
-    skipped : string[];
-    skippedVersions : string[];
+    root: string;
+    order: string[];
+    published: string[];
+    skipped: string[];
+    skippedVersions: string[];
 };
 
-export async function runPublish(argv : string[]) : Promise<void>{
+export async function runPublish(argv: string[]): Promise<void> {
     const options = parsePublishArgs(argv);
     const native = loadNiftyNative();
     const report = native.publisher["publish-workspace"]({
-        cwd : options.cwd,
-        dryRun : options.dryRun,
-        refresh : options.refresh,
-        placeholder : options.placeholder,
-        tag : options.tag,
-        access : options.access,
+        cwd: options.cwd,
+        dryRun: options.dryRun,
+        refresh: options.refresh,
+        placeholder: options.placeholder,
+        tag: options.tag,
+        access: options.access,
         ...authPayload(options.auth),
     });
     printPublishReport(report, options.dryRun);
 }
 
-function parsePublishArgs(argv : string[]){
-    let cwd : string | undefined;
+function parsePublishArgs(argv: string[]) {
+    let cwd: string | undefined;
     let dryRun = false;
     let refresh = false;
     let placeholder = false;
-    let tag : string | undefined;
+    let tag: string | undefined;
     let access = "public";
     const auth = parseAuthArgs(argv);
 
-    for(let i = 0; i<argv.length; i += 1){
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "--dry-run"){
+        if (arg === "--dry-run") {
             dryRun = true;
-        } else if(arg === "--refresh"){
+        } else if (arg === "--refresh") {
             refresh = true;
-        } else if(arg === "--placeholder"){
+        } else if (arg === "--placeholder") {
             placeholder = true;
-        } else if(arg === "-C" || arg === "--cwd"){
-            cwd = argv[ ++ i];
-        } else if(arg === "--tag"){
-            tag = argv[ ++ i];
-        } else if(arg === "--access"){
-            access = argv[ ++ i];
-        } else if(arg === "-h" || arg === "--help"){
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
+        } else if (arg === "--tag") {
+            tag = argv[++i];
+        } else if (arg === "--access") {
+            access = argv[++i];
+        } else if (arg === "-h" || arg === "--help") {
             printPublishHelp();
             process.exit(0);
-        } else if(arg.startsWith("-")){
+        } else if (arg.startsWith("-")) {
             continue;
         }
     }
@@ -67,23 +67,23 @@ function parsePublishArgs(argv : string[]){
     return { cwd, dryRun, refresh, placeholder, tag, access, auth };
 }
 
-export function printPublishReport(report : PublishReport, dryRun ? : boolean) : void {
+export function printPublishReport(report: PublishReport, dryRun?: boolean): void {
     const prefix = dryRun ? "would publish" : "published";
     console.log(`${prefix} workspace ${report.root}`);
-    if(report.skipped.length>0){
+    if (report.skipped.length > 0) {
         console.log(`skipped private packages: ${report.skipped.join(", ")}`);
     }
-    if(report.skippedVersions.length>0){
+    if (report.skippedVersions.length > 0) {
         console.log(`skipped already published: ${report.skippedVersions.join(", ")}`);
     }
     console.log("publish order:");
-    for(const name of report.order){
+    for (const name of report.order) {
         const marker = report.published.includes(name) ? prefix : "pending";
         console.log(`  ${marker}: ${name}`);
     }
 }
 
-function printPublishHelp() : void {
+function printPublishHelp(): void {
     console.log(`nifty publish — publish workspace npm packages in dependency order
 
 OTP/TOTP is generated in nifty-publisher (set NPM_TOTP_SECRET in .env.placeholder.local).

package/src/cli/resolveNpm.ts

@@ -2,13 +2,13 @@ import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 /** Resolve npm next to the active Node binary (Windows needs `npm.cmd`). */
-export function resolveNpmExecutable() : string {
-    if(process.env.NIFTY_NPM){
+export function resolveNpmExecutable(): string {
+    if (process.env.NIFTY_NPM) {
         return process.env.NIFTY_NPM;
     }
 
     const sibling = join(dirname(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
-    if(existsSync(sibling)){
+    if (existsSync(sibling)) {
         return sibling;
     }