syncpack 10.5.1 → 10.6.1

package/dist/config/get-semver-range.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSemverRange = void 0;
-const is_semver_1 = require("../lib/is-semver");
-function getSemverRange({ cli, rcFile, }) {
-    return (0, is_semver_1.isValidSemverRange)(cli.semverRange)
+const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
+function getSemverRange({ cli, rcFile }) {
+    return (0, is_valid_semver_range_1.isValidSemverRange)(cli.semverRange)
         ? cli.semverRange
-        : (0, is_semver_1.isValidSemverRange)(rcFile.semverRange)
+        : (0, is_valid_semver_range_1.isValidSemverRange)(rcFile.semverRange)
             ? rcFile.semverRange
             : '';
 }

package/dist/config/get-sort-az.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSortAz({ rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSortAz({ rcFile }: Ctx['config']): string[];

package/dist/config/get-sort-first.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSortFirst({ rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSortFirst({ rcFile }: Ctx['config']): string[];

package/dist/config/get-source.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSource({ cli, rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSource({ cli, rcFile }: Ctx['config']): string[];

package/dist/config/get-source.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSource = void 0;
 const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
-const constants_1 = require("../constants");
 function getSource({ cli, rcFile }) {
     return (0, is_array_of_strings_1.isArrayOfStrings)(cli.source)
         ? cli.source
         : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.source)
             ? rcFile.source
-            : [...constants_1.DEFAULT_CONFIG.source];
+            : [];
 }
 exports.getSource = getSource;

package/dist/config/types.d.ts

@@ -1,3 +1,4 @@
+import * as Context from '@effect/data/Context';
 import type { Union } from 'ts-toolbelt';
 /**
  * Aliases for semver range formats supported by syncpack
@@ -80,13 +81,14 @@ declare namespace CustomTypeConfig {
     type Any = Union.Strict<NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName>;
 }
 export interface CliConfig {
-    configPath?: string;
-    filter: string;
-    indent: string;
-    semverRange: SemverRange;
-    source: string[];
-    types: string;
+    readonly configPath?: string;
+    readonly filter: string;
+    readonly indent: string;
+    readonly semverRange: SemverRange;
+    readonly source: string[];
+    readonly types: string;
 }
+export declare const CliConfigTag: Context.Tag<Partial<CliConfig>, Partial<CliConfig>>;
 export interface RcConfig {
     /** @see https://jamiemason.github.io/syncpack/config/custom-types */
     customTypes: Record<string, CustomTypeConfig.Any>;

package/dist/config/types.js

@@ -1,2 +1,28 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliConfigTag = void 0;
+const Context = __importStar(require("@effect/data/Context"));
+exports.CliConfigTag = Context.Tag();

package/dist/constants.d.ts

@@ -31,6 +31,6 @@ export declare const DEFAULT_CONFIG: {
     readonly semverRange: "";
     readonly sortAz: readonly ["contributors", "dependencies", "devDependencies", "keywords", "peerDependencies", "resolutions", "scripts"];
     readonly sortFirst: readonly ["name", "description", "version", "author"];
-    readonly source: readonly [];
+    readonly source: string[];
     readonly versionGroups: readonly [];
 };

package/dist/constants.js

@@ -50,6 +50,6 @@ exports.DEFAULT_CONFIG = {
         'scripts',
     ],
     sortFirst: ['name', 'description', 'version', 'author'],
-    source: [],
+    source: exports.DEFAULT_SOURCES,
     versionGroups: [],
 };

package/dist/create-program/effects.d.ts

@@ -0,0 +1,42 @@
+import type * as Effect from '@effect/io/Effect';
+import type { Env } from '../env/create-env';
+import type { Ctx } from '../get-context';
+import type { AnySemverGroup, SemverGroupReport as SR } from '../get-semver-groups';
+import type { AnyVersionGroup, VersionGroupReport as VR } from '../get-version-groups';
+type R = Effect.Effect<Env | never, never, void>;
+export interface SemverRangeEffectInput<T> {
+    ctx: Ctx;
+    group: AnySemverGroup;
+    index: number;
+    report: T;
+}
+export interface VersionEffectInput<T> {
+    ctx: Ctx;
+    group: AnyVersionGroup;
+    index: number;
+    report: T;
+}
+export interface SemverRangeEffects {
+    FilteredOut: (input: SemverRangeEffectInput<SR.FilteredOut>) => R;
+    Ignored: (input: SemverRangeEffectInput<SR.Ignored>) => R;
+    SemverRangeMismatch: (input: SemverRangeEffectInput<SR.SemverRangeMismatch>) => R;
+    UnsupportedVersion: (input: SemverRangeEffectInput<SR.UnsupportedVersion>) => R;
+    Valid: (input: SemverRangeEffectInput<SR.Valid>) => R;
+    WorkspaceSemverRangeMismatch: (input: SemverRangeEffectInput<SR.WorkspaceSemverRangeMismatch>) => R;
+    TearDown: (ctx: Ctx) => R;
+}
+export interface VersionEffects {
+    Banned: (input: VersionEffectInput<VR.Banned>) => R;
+    FilteredOut: (input: VersionEffectInput<VR.FilteredOut>) => R;
+    HighestSemverMismatch: (input: VersionEffectInput<VR.HighestSemverMismatch>) => R;
+    Ignored: (input: VersionEffectInput<VR.Ignored>) => R;
+    LowestSemverMismatch: (input: VersionEffectInput<VR.LowestSemverMismatch>) => R;
+    PinnedMismatch: (input: VersionEffectInput<VR.PinnedMismatch>) => R;
+    SameRangeMismatch: (input: VersionEffectInput<VR.SameRangeMismatch>) => R;
+    SnappedToMismatch: (input: VersionEffectInput<VR.SnappedToMismatch>) => R;
+    UnsupportedMismatch: (input: VersionEffectInput<VR.UnsupportedMismatch>) => R;
+    Valid: (input: VersionEffectInput<VR.Valid>) => R;
+    WorkspaceMismatch: (input: VersionEffectInput<VR.WorkspaceMismatch>) => R;
+    TearDown: (ctx: Ctx) => R;
+}
+export {};

package/dist/create-program/effects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/create-program/semver-ranges.d.ts

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/io/Effect';
+import type { DeprecatedTypesError } from '../config/get-enabled-types';
+import type { Env } from '../env/create-env';
+import type { Ctx } from '../get-context';
+import type { SemverGroupConfigError } from '../get-semver-groups';
+import type { SemverRangeEffects } from './effects';
+export declare function createSemverRangesProgram(ctx: Ctx, effects: SemverRangeEffects): Effect.Effect<Env, SemverGroupConfigError | DeprecatedTypesError, Ctx>;

package/dist/create-program/semver-ranges.js

@@ -0,0 +1,43 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemverRangesProgram = void 0;
+const Function_1 = require("@effect/data/Function");
+const Unify_1 = require("@effect/data/Unify");
+const Effect = __importStar(require("@effect/io/Effect"));
+const Match = __importStar(require("@effect/match"));
+const get_semver_groups_1 = require("../get-semver-groups");
+function createSemverRangesProgram(ctx, effects) {
+    return (0, Function_1.pipe)((0, get_semver_groups_1.getSemverGroups)(ctx), Effect.flatMap((semverGroups) => Effect.all(semverGroups.map((group) => Effect.all(group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
+        FilteredOut: (report) => (0, Function_1.pipe)(effects.FilteredOut({ ctx, group, index, report }), Effect.map(() => report)),
+        Ignored: (report) => (0, Function_1.pipe)(effects.Ignored({ ctx, group, index, report }), Effect.map(() => report)),
+        Valid: (report) => (0, Function_1.pipe)(effects.Valid({ ctx, group, index, report }), Effect.map(() => report)),
+    }))), Effect.catchTags({
+        SemverRangeMismatch: (report) => (0, Function_1.pipe)(effects.SemverRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        UnsupportedVersion: (report) => (0, Function_1.pipe)(effects.UnsupportedVersion({ ctx, group, index, report }), Effect.map(() => report)),
+        WorkspaceSemverRangeMismatch: (report) => (0, Function_1.pipe)(effects.WorkspaceSemverRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+    }))))))), Effect.flatMap(() => effects.TearDown(ctx)), Effect.map(() => ctx));
+}
+exports.createSemverRangesProgram = createSemverRangesProgram;

package/dist/create-program/versions.d.ts

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/io/Effect';
+import type { DeprecatedTypesError } from '../config/get-enabled-types';
+import type { Env } from '../env/create-env';
+import type { Ctx } from '../get-context';
+import type { VersionGroupConfigError } from '../get-version-groups';
+import type { VersionEffects } from './effects';
+export declare function createVersionsProgram(ctx: Ctx, effects: VersionEffects): Effect.Effect<Env, VersionGroupConfigError | DeprecatedTypesError, Ctx>;

package/dist/create-program/versions.js

@@ -0,0 +1,48 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVersionsProgram = void 0;
+const Function_1 = require("@effect/data/Function");
+const Unify_1 = require("@effect/data/Unify");
+const Effect = __importStar(require("@effect/io/Effect"));
+const Match = __importStar(require("@effect/match"));
+const get_version_groups_1 = require("../get-version-groups");
+function createVersionsProgram(ctx, effects) {
+    return (0, Function_1.pipe)((0, get_version_groups_1.getVersionGroups)(ctx), Effect.flatMap((versionGroups) => Effect.all(versionGroups.map((group) => Effect.all(group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
+        FilteredOut: (report) => (0, Function_1.pipe)(effects.FilteredOut({ ctx, group, index, report }), Effect.map(() => report)),
+        Ignored: (report) => (0, Function_1.pipe)(effects.Ignored({ ctx, group, index, report }), Effect.map(() => report)),
+        Valid: (report) => (0, Function_1.pipe)(effects.Valid({ ctx, group, index, report }), Effect.map(() => report)),
+    }))), Effect.catchTags({
+        Banned: (report) => (0, Function_1.pipe)(effects.Banned({ ctx, group, index, report }), Effect.map(() => report)),
+        HighestSemverMismatch: (report) => (0, Function_1.pipe)(effects.HighestSemverMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        LowestSemverMismatch: (report) => (0, Function_1.pipe)(effects.LowestSemverMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        PinnedMismatch: (report) => (0, Function_1.pipe)(effects.PinnedMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        SameRangeMismatch: (report) => (0, Function_1.pipe)(effects.SameRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        SnappedToMismatch: (report) => (0, Function_1.pipe)(effects.SnappedToMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        UnsupportedMismatch: (report) => (0, Function_1.pipe)(effects.UnsupportedMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+        WorkspaceMismatch: (report) => (0, Function_1.pipe)(effects.WorkspaceMismatch({ ctx, group, index, report }), Effect.map(() => report)),
+    }))))))), Effect.flatMap(() => effects.TearDown(ctx)), Effect.map(() => ctx));
+}
+exports.createVersionsProgram = createVersionsProgram;

package/dist/env/create-env.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/io/Effect';
+import type { O } from 'ts-toolbelt';
+import type { RcConfig } from '../config/types';
+import type { DefaultEnv } from './default-env';
+import { AskForChoiceError, AskForInputError, GlobError, ReadConfigFileError, ReadFileError, ReadYamlFileError, WriteFileError } from './tags';
+export interface Env {
+    readonly askForChoice: (opts: {
+        message: string;
+        choices: string[];
+    }) => Effect.Effect<never, AskForChoiceError, string>;
+    readonly askForInput: (opts: {
+        message: string;
+    }) => Effect.Effect<never, AskForInputError, string>;
+    readonly exitProcess: (code: number) => Effect.Effect<never, never, void>;
+    readonly globSync: (patterns: string[]) => Effect.Effect<never, GlobError, string[]>;
+    readonly readConfigFileSync: (configPath?: string) => Effect.Effect<never, ReadConfigFileError, O.Partial<RcConfig, 'deep'>>;
+    readonly readFileSync: (filePath: string) => Effect.Effect<never, ReadFileError, string>;
+    readonly readYamlFileSync: <T = unknown>(filePath: string) => Effect.Effect<never, ReadYamlFileError, T>;
+    readonly writeFileSync: (filePath: string, contents: string) => Effect.Effect<never, WriteFileError, void>;
+}
+export declare function createEnv(env: DefaultEnv): Env;

package/dist/env/create-env.js

@@ -0,0 +1,60 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnv = void 0;
+const Effect = __importStar(require("@effect/io/Effect"));
+const tags_1 = require("./tags");
+function createEnv(env) {
+    return {
+        askForChoice(opts) {
+            return Effect.tryCatchPromise(() => env.askForChoice(opts), (err) => new tags_1.AskForChoiceError({ error: String(err) }));
+        },
+        askForInput(opts) {
+            return Effect.tryCatchPromise(() => env.askForInput(opts), (err) => new tags_1.AskForInputError({ error: String(err) }));
+        },
+        // @FIXME: process.exit is probably handled some other way in effect-ts
+        exitProcess(code) {
+            return Effect.sync(() => {
+                env.exitProcess(code);
+            });
+        },
+        globSync(patterns) {
+            return Effect.tryCatch(() => env.globSync(patterns), (err) => new tags_1.GlobError({ error: String(err) }));
+        },
+        readConfigFileSync(filePath) {
+            return Effect.tryCatch(() => env.readConfigFileSync(filePath), (err) => new tags_1.ReadConfigFileError({ filePath: filePath || '', error: String(err) }));
+        },
+        readFileSync(filePath) {
+            return Effect.tryCatch(() => env.readFileSync(filePath), (err) => new tags_1.ReadFileError({ filePath, error: String(err) }));
+        },
+        readYamlFileSync(filePath) {
+            return Effect.tryCatch(() => env.readYamlFileSync(filePath), (err) => new tags_1.ReadYamlFileError({ filePath, error: String(err) }));
+        },
+        writeFileSync(filePath, contents) {
+            return Effect.tryCatch(() => env.writeFileSync(filePath, contents), (err) => new tags_1.WriteFileError({ filePath, error: String(err) }));
+        },
+    };
+}
+exports.createEnv = createEnv;

package/dist/env/default-env.d.ts

@@ -0,0 +1,18 @@
+import type { O } from 'ts-toolbelt';
+import type { RcConfig } from '../config/types';
+export interface DefaultEnv {
+    readonly askForChoice: (opts: {
+        message: string;
+        choices: string[];
+    }) => Promise<string>;
+    readonly askForInput: (opts: {
+        message: string;
+    }) => Promise<string>;
+    readonly exitProcess: (code: number) => void;
+    readonly globSync: (patterns: string[]) => string[];
+    readonly readConfigFileSync: (configPath?: string) => O.Partial<RcConfig, 'deep'>;
+    readonly readFileSync: (filePath: string) => string;
+    readonly readYamlFileSync: <T = unknown>(filePath: string) => T;
+    readonly writeFileSync: (filePath: string, contents: string) => void;
+}
+export declare const defaultEnv: DefaultEnv;

package/dist/env/default-env.js

@@ -0,0 +1,95 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEnv = void 0;
+const cosmiconfig_1 = require("cosmiconfig");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore Select *does* exist
+const enquirer_1 = require("enquirer");
+const fs_extra_1 = require("fs-extra");
+const globby = __importStar(require("globby"));
+const path_1 = require("path");
+const readYamlFile = __importStar(require("read-yaml-file"));
+const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
+const constants_1 = require("../constants");
+const log_verbose_1 = require("../lib/log-verbose");
+exports.defaultEnv = {
+    /* istanbul ignore next */
+    askForChoice({ message, choices }) {
+        return new enquirer_1.Select({ name: 'choice', message, choices }).run();
+    },
+    /* istanbul ignore next */
+    askForInput({ message }) {
+        return new enquirer_1.Input({ message }).run();
+    },
+    /* istanbul ignore next */
+    globSync(patterns) {
+        (0, log_verbose_1.logVerbose)('globSync(', patterns, ')');
+        return globby.sync(patterns, {
+            ignore: ['**/node_modules/**'],
+            absolute: true,
+            cwd: constants_1.CWD,
+        });
+    },
+    /* istanbul ignore next */
+    exitProcess(code) {
+        (0, log_verbose_1.logVerbose)('exit(', code, ')');
+        process.exit(code);
+    },
+    readConfigFileSync(configPath) {
+        (0, log_verbose_1.logVerbose)('readConfigFileSync(', configPath, ')');
+        const client = (0, cosmiconfig_1.cosmiconfigSync)('syncpack');
+        const result = configPath ? client.load(configPath) : client.search();
+        if (!(0, is_non_empty_object_1.isNonEmptyObject)(result)) {
+            const rcPath = (0, path_1.join)(constants_1.CWD, 'package.json');
+            const pjson = (0, fs_extra_1.readJsonSync)(rcPath, { throws: false });
+            const rcConfig = pjson?.config?.syncpack;
+            if ((0, is_non_empty_object_1.isNonEmptyObject)(rcConfig))
+                return rcConfig;
+            (0, log_verbose_1.logVerbose)('no config file found');
+            return {};
+        }
+        const rcPath = result.filepath;
+        const rcConfig = result.config;
+        (0, log_verbose_1.logVerbose)('.syncpackrc path:', rcPath);
+        (0, log_verbose_1.logVerbose)('.syncpackrc contents:', rcConfig);
+        return rcConfig;
+    },
+    /* istanbul ignore next */
+    readFileSync(filePath) {
+        (0, log_verbose_1.logVerbose)('readFileSync(', filePath, ')');
+        return (0, fs_extra_1.readFileSync)(filePath, { encoding: 'utf8' });
+    },
+    /* istanbul ignore next */
+    readYamlFileSync(filePath) {
+        (0, log_verbose_1.logVerbose)('readYamlFileSync(', filePath, ')');
+        return readYamlFile.sync(filePath);
+    },
+    /* istanbul ignore next */
+    writeFileSync(filePath, contents) {
+        (0, log_verbose_1.logVerbose)('writeFileSync(', filePath, contents, ')');
+        (0, fs_extra_1.writeFileSync)(filePath, contents);
+    },
+};

package/dist/env/exit-if-invalid.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from '@effect/io/Effect';
+import type { Ctx } from '../get-context';
+import { type Env } from './create-env';
+export declare function exitIfInvalid(ctx: Ctx): Effect.Effect<Env, never, Ctx>;

package/dist/env/exit-if-invalid.js

@@ -0,0 +1,34 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitIfInvalid = void 0;
+const Function_1 = require("@effect/data/Function");
+const Effect = __importStar(require("@effect/io/Effect"));
+const tags_1 = require("./tags");
+// @TODO what's the effect-ts way to process.exit?
+function exitIfInvalid(ctx) {
+    return (0, Function_1.pipe)(tags_1.EnvTag, Effect.flatMap((env) => (ctx.isInvalid ? env.exitProcess(1) : Effect.unit())), Effect.map(() => ctx));
+}
+exports.exitIfInvalid = exitIfInvalid;

package/dist/env/tags.d.ts

@@ -0,0 +1,58 @@
+import * as Context from '@effect/data/Context';
+import * as Data from '@effect/data/Data';
+import type { Env } from './create-env';
+export declare const EnvTag: Context.Tag<Env, Env>;
+declare const AskForChoiceError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "AskForChoiceError";
+}>;
+export declare class AskForChoiceError extends AskForChoiceError_base<{
+    readonly error: string;
+}> {
+}
+declare const AskForInputError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "AskForInputError";
+}>;
+export declare class AskForInputError extends AskForInputError_base<{
+    readonly error: string;
+}> {
+}
+declare const GlobError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "GlobError";
+}>;
+export declare class GlobError extends GlobError_base<{
+    readonly error: string;
+}> {
+}
+declare const ReadConfigFileError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "ReadConfigFileError";
+}>;
+export declare class ReadConfigFileError extends ReadConfigFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+declare const ReadFileError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "ReadFileError";
+}>;
+export declare class ReadFileError extends ReadFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+declare const ReadYamlFileError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "ReadYamlFileError";
+}>;
+export declare class ReadYamlFileError extends ReadYamlFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+declare const WriteFileError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "WriteFileError";
+}>;
+export declare class WriteFileError extends WriteFileError_base<{
+    readonly filePath: string;
+    readonly error: string;
+}> {
+}
+export {};

package/dist/env/tags.js

@@ -0,0 +1,50 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteFileError = exports.ReadYamlFileError = exports.ReadFileError = exports.ReadConfigFileError = exports.GlobError = exports.AskForInputError = exports.AskForChoiceError = exports.EnvTag = void 0;
+const Context = __importStar(require("@effect/data/Context"));
+const Data = __importStar(require("@effect/data/Data"));
+exports.EnvTag = Context.Tag();
+class AskForChoiceError extends Data.TaggedClass('AskForChoiceError') {
+}
+exports.AskForChoiceError = AskForChoiceError;
+class AskForInputError extends Data.TaggedClass('AskForInputError') {
+}
+exports.AskForInputError = AskForInputError;
+class GlobError extends Data.TaggedClass('GlobError') {
+}
+exports.GlobError = GlobError;
+class ReadConfigFileError extends Data.TaggedClass('ReadConfigFileError') {
+}
+exports.ReadConfigFileError = ReadConfigFileError;
+class ReadFileError extends Data.TaggedClass('ReadFileError') {
+}
+exports.ReadFileError = ReadFileError;
+class ReadYamlFileError extends Data.TaggedClass('ReadYamlFileError') {
+}
+exports.ReadYamlFileError = ReadYamlFileError;
+class WriteFileError extends Data.TaggedClass('WriteFileError') {
+}
+exports.WriteFileError = WriteFileError;

package/dist/env/write-if-changed.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect';
+import type { Ctx } from '../get-context';
+import { type Env } from './create-env';
+import type { WriteFileError } from './tags';
+export declare function writeIfChanged(ctx: Ctx): Effect.Effect<Env, WriteFileError, Ctx>;
+type Ending = '\n' | '\r' | '\r\n' | string;
+export declare const newlines: {
+    detect(source: string): Ending;
+    fix(source: string, lineEnding: Ending): string;
+};
+export {};