syncpack 10.7.3 → 10.9.3

package/dist/create-program/versions.js

@@ -30,7 +30,7 @@ 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.allPar(versionGroups.flatMap((group) => group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
+    return (0, Function_1.pipe)((0, get_version_groups_1.getVersionGroups)(ctx), Effect.flatMap((versionGroups) => Effect.all(versionGroups.flatMap((group) => 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) {
             return effects.onFilteredOut({ ctx, group, index, report });
         },
@@ -59,12 +59,12 @@ function createVersionsProgram(ctx, effects) {
         SnappedToMismatch(report) {
             return effects.onSnappedToMismatch({ ctx, group, index, report });
         },
-        UnsupportedMismatch(report) {
-            return effects.onUnsupportedMismatch({ ctx, group, index, report });
+        NonSemverMismatch(report) {
+            return effects.onNonSemverMismatch({ ctx, group, index, report });
         },
-        WorkspaceMismatch(report) {
-            return effects.onWorkspaceMismatch({ ctx, group, index, report });
+        LocalPackageMismatch(report) {
+            return effects.onLocalPackageMismatch({ ctx, group, index, report });
         },
-    })))))), Effect.flatMap((results) => effects.onComplete(ctx, results)), Effect.map(() => ctx));
+    })))), { concurrency: 'inherit' })), Effect.flatMap((results) => effects.onComplete(ctx, results)), Effect.map(() => ctx));
 }
 exports.createVersionsProgram = createVersionsProgram;

package/dist/env/create-env.js

@@ -29,10 +29,16 @@ 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) }));
+            return Effect.tryPromise({
+                try: () => env.askForChoice(opts),
+                catch: (err) => new tags_1.AskForChoiceError({ error: String(err) }),
+            });
         },
         askForInput(opts) {
-            return Effect.tryCatchPromise(() => env.askForInput(opts), (err) => new tags_1.AskForInputError({ error: String(err) }));
+            return Effect.tryPromise({
+                try: () => env.askForInput(opts),
+                catch: (err) => new tags_1.AskForInputError({ error: String(err) }),
+            });
         },
         // @FIXME: process.exit is probably handled some other way in effect-ts
         exitProcess(code) {
@@ -41,19 +47,34 @@ function createEnv(env) {
             });
         },
         globSync(patterns) {
-            return Effect.tryCatch(() => env.globSync(patterns), (err) => new tags_1.GlobError({ error: String(err) }));
+            return Effect.try({
+                try: () => env.globSync(patterns),
+                catch: (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) }));
+            return Effect.try({
+                try: () => env.readConfigFileSync(filePath),
+                catch: (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) }));
+            return Effect.try({
+                try: () => env.readFileSync(filePath),
+                catch: (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) }));
+            return Effect.try({
+                try: () => env.readYamlFileSync(filePath),
+                catch: (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) }));
+            return Effect.try({
+                try: () => env.writeFileSync(filePath, contents),
+                catch: (err) => new tags_1.WriteFileError({ filePath, error: String(err) }),
+            });
         },
     };
 }

package/dist/env/default-env.js

@@ -59,13 +59,14 @@ exports.defaultEnv = {
         process.exit(code);
     },
     readConfigFileSync(configPath) {
+        var _a;
         (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;
+            const rcConfig = (_a = pjson === null || pjson === void 0 ? void 0 : pjson.config) === null || _a === void 0 ? void 0 : _a.syncpack;
             if ((0, is_non_empty_object_1.isNonEmptyObject)(rcConfig))
                 return rcConfig;
             (0, log_verbose_1.logVerbose)('no config file found');

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

@@ -29,6 +29,6 @@ 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));
+    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/write-if-changed.js

@@ -35,7 +35,7 @@ const get_indent_1 = require("../config/get-indent");
 const constants_1 = require("../constants");
 const tags_1 = require("./tags");
 function writeIfChanged(ctx) {
-    return (0, Function_1.pipe)(tags_1.EnvTag, Effect.flatMap((env) => Effect.all(ctx.packageJsonFiles.map((file) => (0, Function_1.pipe)(Effect.Do(), Effect.bind('nextJson', () => toJson(file)), Effect.bind('hasChanged', ({ nextJson }) => Effect.succeed(file.json !== nextJson)), Effect.flatMap(({ hasChanged, nextJson }) => hasChanged
+    return (0, Function_1.pipe)(tags_1.EnvTag, Effect.flatMap((env) => Effect.all(ctx.packageJsonFiles.map((file) => (0, Function_1.pipe)(Effect.Do, Effect.bind('nextJson', () => toJson(file)), Effect.bind('hasChanged', ({ nextJson }) => Effect.succeed(file.json !== nextJson)), Effect.flatMap(({ hasChanged, nextJson }) => hasChanged
         ? (0, Function_1.pipe)(env.writeFileSync(file.filePath, nextJson), Effect.flatMap(() => Effect.sync(() => {
             console.log((0, chalk_1.default) `{green ${constants_1.ICON.tick}}`, file.shortPath);
         })))

package/dist/get-context/index.js

@@ -30,7 +30,7 @@ const types_1 = require("../config/types");
 const tags_1 = require("../env/tags");
 const get_package_json_files_1 = require("../get-package-json-files");
 function getContext() {
-    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('cli', () => types_1.CliConfigTag), Effect.bind('env', () => tags_1.EnvTag), Effect.bind('rcFile', ({ cli, env }) => env.readConfigFileSync(cli.configPath)), Effect.bind('packageJsonFiles', get_package_json_files_1.getPackageJsonFiles), Effect.map(({ cli, rcFile, packageJsonFiles }) => ({
+    return (0, Function_1.pipe)(Effect.Do, Effect.bind('cli', () => types_1.CliConfigTag), Effect.bind('env', () => tags_1.EnvTag), Effect.bind('rcFile', ({ cli, env }) => env.readConfigFileSync(cli.configPath)), Effect.bind('packageJsonFiles', get_package_json_files_1.getPackageJsonFiles), Effect.map(({ cli, rcFile, packageJsonFiles }) => ({
         config: { cli, rcFile },
         isInvalid: false,
         packageJsonFiles,

package/dist/get-package-json-files/get-patterns/get-lerna-patterns.js

@@ -32,7 +32,7 @@ const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
 const constants_1 = require("../../constants");
 const read_json_safe_1 = require("./read-json-safe");
 function getLernaPatterns() {
-    return (0, Function_1.pipe)((0, read_json_safe_1.readJsonSafe)((0, path_1.join)(constants_1.CWD, 'lerna.json')), Effect.map((file) => (0, is_array_of_strings_1.isArrayOfStrings)(file?.contents?.packages) ? O.some(file.contents.packages) : O.none()), Effect.catchTags({
+    return (0, Function_1.pipe)((0, read_json_safe_1.readJsonSafe)((0, path_1.join)(constants_1.CWD, 'lerna.json')), Effect.map((file) => { var _a; return (0, is_array_of_strings_1.isArrayOfStrings)((_a = file === null || file === void 0 ? void 0 : file.contents) === null || _a === void 0 ? void 0 : _a.packages) ? O.some(file.contents.packages) : O.none(); }), Effect.catchTags({
         ReadFileError: () => Effect.succeed(O.none()),
         JsonParseError: () => Effect.succeed(O.none()),
     }));

package/dist/get-package-json-files/get-patterns/get-pnpm-patterns.js

@@ -37,7 +37,7 @@ function getPnpmPatterns() {
     //   - "packages/**"
     //   - "components/**"
     //   - "!**/test/**"
-    tags_1.EnvTag, Effect.flatMap((env) => env.readYamlFileSync((0, path_1.join)(constants_1.CWD, 'pnpm-workspace.yaml'))), Effect.map((file) => ((0, is_array_of_strings_1.isArrayOfStrings)(file?.packages) ? O.some(file.packages) : O.none())), Effect.catchTags({
+    tags_1.EnvTag, Effect.flatMap((env) => env.readYamlFileSync((0, path_1.join)(constants_1.CWD, 'pnpm-workspace.yaml'))), Effect.map((file) => ((0, is_array_of_strings_1.isArrayOfStrings)(file === null || file === void 0 ? void 0 : file.packages) ? O.some(file.packages) : O.none())), Effect.catchTags({
         ReadYamlFileError: () => Effect.succeed(O.none()),
     }));
 }

package/dist/get-package-json-files/get-patterns/get-yarn-patterns.js

@@ -33,12 +33,15 @@ const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
 const constants_1 = require("../../constants");
 const read_json_safe_1 = require("./read-json-safe");
 function getYarnPatterns() {
-    return (0, Function_1.pipe)((0, read_json_safe_1.readJsonSafe)((0, path_1.join)(constants_1.CWD, 'package.json')), Effect.map((file) => (0, is_non_empty_object_1.isNonEmptyObject)(file?.contents?.workspaces) &&
-        (0, is_array_of_strings_1.isArrayOfStrings)(file.contents.workspaces?.packages)
-        ? O.some(file.contents.workspaces.packages)
-        : (0, is_array_of_strings_1.isArrayOfStrings)(file?.contents?.workspaces)
-            ? O.some(file.contents.workspaces)
-            : O.none()), Effect.catchTags({
+    return (0, Function_1.pipe)((0, read_json_safe_1.readJsonSafe)((0, path_1.join)(constants_1.CWD, 'package.json')), Effect.map((file) => {
+        var _a, _b, _c;
+        return (0, is_non_empty_object_1.isNonEmptyObject)((_a = file === null || file === void 0 ? void 0 : file.contents) === null || _a === void 0 ? void 0 : _a.workspaces) &&
+            (0, is_array_of_strings_1.isArrayOfStrings)((_b = file.contents.workspaces) === null || _b === void 0 ? void 0 : _b.packages)
+            ? O.some(file.contents.workspaces.packages)
+            : (0, is_array_of_strings_1.isArrayOfStrings)((_c = file === null || file === void 0 ? void 0 : file.contents) === null || _c === void 0 ? void 0 : _c.workspaces)
+                ? O.some(file.contents.workspaces)
+                : O.none();
+    }), Effect.catchTags({
         ReadFileError: () => Effect.succeed(O.none()),
         JsonParseError: () => Effect.succeed(O.none()),
     }));

package/dist/get-package-json-files/get-patterns/read-json-safe.js

@@ -33,8 +33,11 @@ class JsonParseError extends Data.TaggedClass('JsonParseError') {
 exports.JsonParseError = JsonParseError;
 // @TODO: move to env.readJsonFileSync
 function readJsonSafe(filePath) {
-    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('env', () => tags_1.EnvTag), Effect.bind('json', ({ env }) => env.readFileSync(filePath)), Effect.bind('contents', ({ json }) => 
+    return (0, Function_1.pipe)(Effect.Do, Effect.bind('env', () => tags_1.EnvTag), Effect.bind('json', ({ env }) => env.readFileSync(filePath)), Effect.bind('contents', ({ json }) => 
     // @TODO: move to env.parseJson
-    Effect.tryCatch(() => JSON.parse(json), (err) => new JsonParseError({ error: String(err), filePath, json }))), Effect.map(({ contents, json }) => ({ contents, filePath, json })));
+    Effect.try({
+        try: () => JSON.parse(json),
+        catch: (err) => new JsonParseError({ error: String(err), filePath, json }),
+    })), Effect.map(({ contents, json }) => ({ contents, filePath, json })));
 }
 exports.readJsonSafe = readJsonSafe;

package/dist/get-package-json-files/package-json-file.d.ts

@@ -1,7 +1,7 @@
 import type { Strategy } from '../config/get-custom-types';
 import type { Ctx } from '../get-context';
+import type { Instance } from '../instance';
 import type { JsonFile } from './get-patterns/read-json-safe';
-import { Instance } from './instance';
 export interface PackageJson {
     bugs?: {
         url: string;
@@ -34,6 +34,8 @@ export declare class PackageJsonFile {
     contents: PackageJson;
     /** absolute path on disk to this file */
     readonly filePath: string;
+    /** absolute path on disk to this file's directory */
+    readonly dirPath: string;
     /** raw file contents of the file */
     readonly json: string;
     /** resolved configuration */
@@ -41,5 +43,5 @@ export declare class PackageJsonFile {
     /** relative path on disk to this file */
     readonly shortPath: string;
     constructor(jsonFile: JsonFile<PackageJson>, config: Ctx['config']);
-    getInstances(enabledTypes: Strategy.Any[]): Instance[];
+    getInstances(enabledTypes: Strategy.Any[]): Instance.Any[];
 }

package/dist/get-package-json-files/package-json-file.js

@@ -5,22 +5,23 @@ const Function_1 = require("@effect/data/Function");
 const path_1 = require("path");
 const map_1 = require("tightrope/result/map");
 const constants_1 = require("../constants");
+const create_1 = require("../instance/create");
 const log_verbose_1 = require("../lib/log-verbose");
-const instance_1 = require("./instance");
 class PackageJsonFile {
     constructor(jsonFile, config) {
         this.config = config;
         this.contents = jsonFile.contents;
         this.filePath = jsonFile.filePath;
+        this.dirPath = (0, path_1.dirname)(jsonFile.filePath);
         this.json = jsonFile.json;
         this.shortPath = (0, path_1.relative)(constants_1.CWD, jsonFile.filePath);
     }
     getInstances(enabledTypes) {
         const instances = [];
         enabledTypes.forEach((strategy) => {
-            (0, Function_1.pipe)(strategy.read(this), (0, map_1.map)((entries) => entries.forEach(([name, version]) => {
-                (0, log_verbose_1.logVerbose)(`add ${name}@${version} to ${strategy.name}:${strategy._tag} ${this.shortPath}`);
-                instances.push(new instance_1.Instance(strategy, name, this, version));
+            (0, Function_1.pipe)(strategy.read(this), (0, map_1.map)((entries) => entries.forEach(([name, specifier]) => {
+                (0, log_verbose_1.logVerbose)(`add ${name}@${specifier} to ${strategy.name}:${strategy._tag} ${this.shortPath}`);
+                instances.push((0, create_1.createInstance)(strategy, name, this, specifier));
             })));
         });
         return instances;

package/dist/get-semver-groups/filtered-out.d.ts

@@ -3,17 +3,17 @@ import * as Effect from '@effect/io/Effect';
 import { SemverGroupReport } from '.';
 import type { GroupConfig } from '../config/types';
 import type { Ctx } from '../get-context';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const FilteredOutSemverGroup_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: "FilteredOut";
 }>;
 export declare class FilteredOutSemverGroup extends FilteredOutSemverGroup_base<{
     config: GroupConfig;
     filter: string;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(ctx: Ctx);
-    canAdd(instance: Instance): boolean;
+    canAdd(instance: Instance.Any): boolean;
     inspect(): Effect.Effect<never, never, SemverGroupReport.FilteredOut>[];
 }
 export {};

package/dist/get-semver-groups/ignored.d.ts

@@ -2,16 +2,16 @@ import * as Data from '@effect/data/Data';
 import * as Effect from '@effect/io/Effect';
 import { SemverGroupReport } from '.';
 import type { SemverGroupConfig } from '../config/types';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const IgnoredSemverGroup_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: "Ignored";
 }>;
 export declare class IgnoredSemverGroup extends IgnoredSemverGroup_base<{
     config: SemverGroupConfig.Ignored;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(config: SemverGroupConfig.Ignored);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, never, SemverGroupReport.Ignored>[];
 }
 export {};

package/dist/get-semver-groups/index.d.ts

@@ -3,7 +3,7 @@ import * as Effect from '@effect/io/Effect';
 import type { Union } from 'ts-toolbelt';
 import type { DeprecatedTypesError } from '../config/get-enabled-types';
 import type { Ctx } from '../get-context';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 import { FilteredOutSemverGroup } from './filtered-out';
 import { IgnoredSemverGroup } from './ignored';
 import { WithRangeSemverGroup } from './with-range';
@@ -14,7 +14,7 @@ export declare namespace SemverGroupReport {
     }>;
     export class FilteredOut extends FilteredOut_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: true;
     }> {
     }
@@ -23,7 +23,7 @@ export declare namespace SemverGroupReport {
     }>;
     export class Ignored extends Ignored_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: true;
     }> {
     }
@@ -32,16 +32,16 @@ export declare namespace SemverGroupReport {
     }>;
     export class Valid extends Valid_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: true;
     }> {
     }
-    const WorkspaceSemverRangeMismatch_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: "WorkspaceSemverRangeMismatch";
+    const LocalPackageSemverRangeMismatch_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: "LocalPackageSemverRangeMismatch";
     }>;
-    export class WorkspaceSemverRangeMismatch extends WorkspaceSemverRangeMismatch_base<{
+    export class LocalPackageSemverRangeMismatch extends LocalPackageSemverRangeMismatch_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: false;
         readonly expectedVersion: string;
     }> {
@@ -51,24 +51,24 @@ export declare namespace SemverGroupReport {
     }>;
     export class SemverRangeMismatch extends SemverRangeMismatch_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: false;
         readonly expectedVersion: string;
     }> {
     }
-    const UnsupportedVersion_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: "UnsupportedVersion";
+    const NonSemverVersion_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: "NonSemverVersion";
     }>;
-    export class UnsupportedVersion extends UnsupportedVersion_base<{
+    export class NonSemverVersion extends NonSemverVersion_base<{
         name: string;
-        instance: Instance;
+        instance: Instance.Any;
         readonly isValid: false;
     }> {
     }
     export type ValidCases = Union.Strict<FilteredOut | Ignored | Valid>;
-    export type InvalidCases = Union.Strict<SemverRangeMismatch | UnsupportedVersion | WorkspaceSemverRangeMismatch>;
-    export type FixableCases = Union.Strict<SemverRangeMismatch | WorkspaceSemverRangeMismatch>;
-    export type UnfixableCases = Union.Strict<UnsupportedVersion>;
+    export type InvalidCases = Union.Strict<SemverRangeMismatch | NonSemverVersion | LocalPackageSemverRangeMismatch>;
+    export type FixableCases = Union.Strict<SemverRangeMismatch | LocalPackageSemverRangeMismatch>;
+    export type UnfixableCases = Union.Strict<NonSemverVersion>;
     export type Any = Union.Strict<ValidCases | InvalidCases>;
     export {};
 }

package/dist/get-semver-groups/index.js

@@ -50,21 +50,21 @@ var SemverGroupReport;
     class Valid extends Data.TaggedClass('Valid') {
     }
     SemverGroupReport.Valid = Valid;
-    class WorkspaceSemverRangeMismatch extends Data.TaggedClass('WorkspaceSemverRangeMismatch') {
+    class LocalPackageSemverRangeMismatch extends Data.TaggedClass('LocalPackageSemverRangeMismatch') {
     }
-    SemverGroupReport.WorkspaceSemverRangeMismatch = WorkspaceSemverRangeMismatch;
+    SemverGroupReport.LocalPackageSemverRangeMismatch = LocalPackageSemverRangeMismatch;
     class SemverRangeMismatch extends Data.TaggedClass('SemverRangeMismatch') {
     }
     SemverGroupReport.SemverRangeMismatch = SemverRangeMismatch;
-    class UnsupportedVersion extends Data.TaggedClass('UnsupportedVersion') {
+    class NonSemverVersion extends Data.TaggedClass('NonSemverVersion') {
     }
-    SemverGroupReport.UnsupportedVersion = UnsupportedVersion;
+    SemverGroupReport.NonSemverVersion = NonSemverVersion;
 })(SemverGroupReport || (exports.SemverGroupReport = SemverGroupReport = {}));
 class SemverGroupConfigError extends Data.TaggedClass('SemverGroupConfigError') {
 }
 exports.SemverGroupConfigError = SemverGroupConfigError;
 function getSemverGroups(ctx) {
-    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('enabledTypes', () => (0, get_enabled_types_1.getEnabledTypes)(ctx.config)), Effect.bind('semverGroups', () => createSemverGroups(ctx)), Effect.flatMap(({ enabledTypes, semverGroups }) => {
+    return (0, Function_1.pipe)(Effect.Do, Effect.bind('enabledTypes', () => (0, get_enabled_types_1.getEnabledTypes)(ctx.config)), Effect.bind('semverGroups', () => createSemverGroups(ctx)), Effect.flatMap(({ enabledTypes, semverGroups }) => {
         for (const file of ctx.packageJsonFiles) {
             instances: for (const instance of file.getInstances(enabledTypes)) {
                 for (const group of semverGroups) {

package/dist/get-semver-groups/with-range.d.ts

@@ -2,17 +2,17 @@ import * as Data from '@effect/data/Data';
 import * as Effect from '@effect/io/Effect';
 import { SemverGroupReport } from '.';
 import type { SemverGroupConfig } from '../config/types';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const WithRangeSemverGroup_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: "WithRange";
 }>;
 export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     config: SemverGroupConfig.WithRange;
-    instances: Instance[];
+    instances: Instance.Any[];
     isCatchAll: boolean;
 }> {
     constructor(isCatchAll: boolean, config: SemverGroupConfig.WithRange);
-    canAdd(_: Instance): boolean;
-    inspect(): Effect.Effect<never, SemverGroupReport.UnsupportedVersion | SemverGroupReport.WorkspaceSemverRangeMismatch | SemverGroupReport.SemverRangeMismatch, SemverGroupReport.Valid>[];
+    canAdd(_: Instance.Any): boolean;
+    inspect(): Effect.Effect<never, SemverGroupReport.NonSemverVersion | SemverGroupReport.LocalPackageSemverRangeMismatch | SemverGroupReport.SemverRangeMismatch, SemverGroupReport.Valid>[];
 }
 export {};

package/dist/get-semver-groups/with-range.js

@@ -25,9 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WithRangeSemverGroup = void 0;
 const Data = __importStar(require("@effect/data/Data"));
+const Option = __importStar(require("@effect/data/Option"));
 const Effect = __importStar(require("@effect/io/Effect"));
 const _1 = require(".");
-const is_supported_1 = require("../guards/is-supported");
 const set_semver_range_1 = require("../lib/set-semver-range");
 class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
     constructor(isCatchAll, config) {
@@ -42,25 +42,25 @@ class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
     }
     inspect() {
         return this.instances.map((instance) => {
-            if (!(0, is_supported_1.isSupported)(instance.version)) {
-                return Effect.fail(new _1.SemverGroupReport.UnsupportedVersion({
+            if (Option.isNone(instance.getSemverSpecifier())) {
+                return Effect.fail(new _1.SemverGroupReport.NonSemverVersion({
                     name: instance.name,
                     instance,
                     isValid: false,
                 }));
             }
-            const isWsInstance = instance.strategy.name === 'workspace';
-            const exactVersion = (0, set_semver_range_1.setSemverRange)('', instance.version);
-            const expectedVersion = (0, set_semver_range_1.setSemverRange)(this.config.range, instance.version);
-            if (isWsInstance && instance.version !== exactVersion) {
-                return Effect.fail(new _1.SemverGroupReport.WorkspaceSemverRangeMismatch({
+            const isLocalPackageInstance = instance.strategy.name === 'localPackage';
+            const exactVersion = (0, set_semver_range_1.setSemverRange)('', instance.specifier);
+            const expectedVersion = (0, set_semver_range_1.setSemverRange)(this.config.range, instance.specifier);
+            if (isLocalPackageInstance && instance.specifier !== exactVersion) {
+                return Effect.fail(new _1.SemverGroupReport.LocalPackageSemverRangeMismatch({
                     name: instance.name,
                     instance,
                     isValid: false,
                     expectedVersion: exactVersion,
                 }));
             }
-            if (instance.version === expectedVersion) {
+            if (instance.specifier === expectedVersion) {
                 return Effect.succeed(new _1.SemverGroupReport.Valid({
                     name: instance.name,
                     instance,

package/dist/get-version-groups/banned.d.ts

@@ -2,16 +2,16 @@ import * as Data from '@effect/data/Data';
 import * as Effect from '@effect/io/Effect';
 import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const BannedVersionGroup_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: "Banned";
 }>;
 export declare class BannedVersionGroup extends BannedVersionGroup_base<{
     config: VersionGroupConfig.Banned;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(config: VersionGroupConfig.Banned);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, VersionGroupReport.Banned, never>[];
 }
 export {};

package/dist/get-version-groups/filtered-out.d.ts

@@ -3,17 +3,17 @@ import * as Effect from '@effect/io/Effect';
 import { VersionGroupReport } from '.';
 import type { GroupConfig } from '../config/types';
 import type { Ctx } from '../get-context';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const FilteredOutVersionGroup_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: "FilteredOut";
 }>;
 export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_base<{
     config: GroupConfig;
     filter: string;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(ctx: Ctx);
-    canAdd(instance: Instance): boolean;
+    canAdd(instance: Instance.Any): boolean;
     inspect(): Effect.Effect<never, never, VersionGroupReport.FilteredOut>[];
 }
 export {};

package/dist/get-version-groups/ignored.d.ts

@@ -2,16 +2,16 @@ import * as Data from '@effect/data/Data';
 import * as Effect from '@effect/io/Effect';
 import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
-import type { Instance } from '../get-package-json-files/instance';
+import type { Instance } from '../instance';
 declare const IgnoredVersionGroup_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: "Ignored";
 }>;
 export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
     config: VersionGroupConfig.Ignored;
-    instances: Instance[];
+    instances: Instance.Any[];
 }> {
     constructor(config: VersionGroupConfig.Ignored);
-    canAdd(_: Instance): boolean;
+    canAdd(_: Instance.Any): boolean;
     inspect(): Effect.Effect<never, never, VersionGroupReport.Ignored>[];
 }
 export {};