syncpack 12.0.0 → 12.1.0

package/dist/schema.json

@@ -9,55 +9,17 @@
         "SemverGroupConfig.Any": {
             "anyOf": [
                 {
-                    "$ref": "#/definitions/{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}"
+                    "$ref": "#/definitions/SemverGroupConfig.Disabled"
                 },
                 {
-                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}"
+                    "$ref": "#/definitions/SemverGroupConfig.Ignored"
                 },
                 {
-                    "$ref": "#/definitions/{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}"
+                    "$ref": "#/definitions/SemverGroupConfig.WithRange"
                 }
             ]
         },
-        "SemverRange": {
-            "default": "",
-            "description": "Aliases for semver range formats supported by syncpack\n\nDefaults to `\"\"` to ensure that exact dependency versions are used instead of\nloose ranges, but this can be overridden in your config file.\n\n| Supported Range |   Example |\n| --------------- | --------: |\n| `\"<\"`           |  `<1.4.2` |\n| `\"<=\"`          | `<=1.4.2` |\n| `\"\"`            |   `1.4.2` |\n| `\"~\"`           |  `~1.4.2` |\n| `\"^\"`           |  `^1.4.2` |\n| `\">=\"`          | `>=1.4.2` |\n| `\">\"`           |  `>1.4.2` |\n| `\"*\"`           |       `*` |",
-            "enum": [
-                "",
-                "*",
-                ".x",
-                "<",
-                "<=",
-                ">",
-                ">=",
-                "^",
-                "~"
-            ],
-            "type": "string"
-        },
-        "VersionGroupConfig.Any": {
-            "anyOf": [
-                {
-                    "$ref": "#/definitions/{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
-                },
-                {
-                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
-                },
-                {
-                    "$ref": "#/definitions/{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
-                },
-                {
-                    "$ref": "#/definitions/{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}"
-                },
-                {
-                    "$ref": "#/definitions/{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}"
-                },
-                {
-                    "$ref": "#/definitions/{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}"
-                }
-            ]
-        },
-        "{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "SemverGroupConfig.Disabled": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -72,7 +34,7 @@
                     },
                     "type": "array"
                 },
-                "isBanned": {
+                "isDisabled": {
                     "const": true,
                     "type": "boolean"
                 },
@@ -88,7 +50,7 @@
             },
             "type": "object"
         },
-        "{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}": {
+        "SemverGroupConfig.Ignored": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -103,7 +65,7 @@
                     },
                     "type": "array"
                 },
-                "isDisabled": {
+                "isIgnored": {
                     "const": true,
                     "type": "boolean"
                 },
@@ -119,7 +81,7 @@
             },
             "type": "object"
         },
-        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "SemverGroupConfig.WithRange": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -134,10 +96,6 @@
                     },
                     "type": "array"
                 },
-                "isIgnored": {
-                    "const": true,
-                    "type": "boolean"
-                },
                 "label": {
                     "type": "string"
                 },
@@ -146,11 +104,53 @@
                         "type": "string"
                     },
                     "type": "array"
+                },
+                "range": {
+                    "$ref": "#/definitions/SemverRange"
                 }
             },
             "type": "object"
         },
-        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}": {
+        "SemverRange": {
+            "default": "",
+            "description": "Aliases for semver range formats supported by syncpack\n\nDefaults to `\"\"` to ensure that exact dependency versions are used instead of\nloose ranges, but this can be overridden in your config file.\n\n| Supported Range |   Example |\n| --------------- | --------: |\n| `\"<\"`           |  `<1.4.2` |\n| `\"<=\"`          | `<=1.4.2` |\n| `\"\"`            |   `1.4.2` |\n| `\"~\"`           |  `~1.4.2` |\n| `\"^\"`           |  `^1.4.2` |\n| `\">=\"`          | `>=1.4.2` |\n| `\">\"`           |  `>1.4.2` |\n| `\"*\"`           |       `*` |",
+            "enum": [
+                "",
+                "*",
+                ".x",
+                "<",
+                "<=",
+                ">",
+                ">=",
+                "^",
+                "workspace:",
+                "~"
+            ],
+            "type": "string"
+        },
+        "VersionGroupConfig.Any": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.Banned"
+                },
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.Ignored"
+                },
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.Pinned"
+                },
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.SnappedTo"
+                },
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.SameRange"
+                },
+                {
+                    "$ref": "#/definitions/VersionGroupConfig.Standard"
+                }
+            ]
+        },
+        "VersionGroupConfig.Banned": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -165,7 +165,7 @@
                     },
                     "type": "array"
                 },
-                "isIgnored": {
+                "isBanned": {
                     "const": true,
                     "type": "boolean"
                 },
@@ -181,7 +181,7 @@
             },
             "type": "object"
         },
-        "{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+        "VersionGroupConfig.Ignored": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -196,6 +196,10 @@
                     },
                     "type": "array"
                 },
+                "isIgnored": {
+                    "const": true,
+                    "type": "boolean"
+                },
                 "label": {
                     "type": "string"
                 },
@@ -204,14 +208,11 @@
                         "type": "string"
                     },
                     "type": "array"
-                },
-                "pinVersion": {
-                    "type": "string"
                 }
             },
             "type": "object"
         },
-        "{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}": {
+        "VersionGroupConfig.Pinned": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -235,14 +236,13 @@
                     },
                     "type": "array"
                 },
-                "policy": {
-                    "const": "sameRange",
+                "pinVersion": {
                     "type": "string"
                 }
             },
             "type": "object"
         },
-        "{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}": {
+        "VersionGroupConfig.SameRange": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -266,17 +266,14 @@
                     },
                     "type": "array"
                 },
-                "preferVersion": {
-                    "enum": [
-                        "highestSemver",
-                        "lowestSemver"
-                    ],
+                "policy": {
+                    "const": "sameRange",
                     "type": "string"
                 }
             },
             "type": "object"
         },
-        "{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}": {
+        "VersionGroupConfig.SnappedTo": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -300,13 +297,16 @@
                     },
                     "type": "array"
                 },
-                "range": {
-                    "$ref": "#/definitions/SemverRange"
+                "snapTo": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
                 }
             },
             "type": "object"
         },
-        "{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}": {
+        "VersionGroupConfig.Standard": {
             "additionalProperties": false,
             "properties": {
                 "dependencies": {
@@ -330,11 +330,12 @@
                     },
                     "type": "array"
                 },
-                "snapTo": {
-                    "items": {
-                        "type": "string"
-                    },
-                    "type": "array"
+                "preferVersion": {
+                    "enum": [
+                        "highestSemver",
+                        "lowestSemver"
+                    ],
+                    "type": "string"
                 }
             },
             "type": "object"

package/dist/semver-group/disabled.js

@@ -26,9 +26,7 @@ class DisabledSemverGroup extends effect_1.Data.TaggedClass('Disabled') {
         return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.Disabled({
-            instance,
-        }));
+        return effect_1.Effect.succeed(new report_1.Report.Disabled(instance));
     }
 }
 exports.DisabledSemverGroup = DisabledSemverGroup;

package/dist/semver-group/filtered-out.js

@@ -32,9 +32,7 @@ class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
         return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.FilteredOut({
-            instance,
-        }));
+        return effect_1.Effect.succeed(new report_1.Report.FilteredOut(instance));
     }
 }
 exports.FilteredOutSemverGroup = FilteredOutSemverGroup;

package/dist/semver-group/ignored.js

@@ -22,9 +22,7 @@ class IgnoredSemverGroup extends effect_1.Data.TaggedClass('Ignored') {
         return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.Ignored({
-            instance,
-        }));
+        return effect_1.Effect.succeed(new report_1.Report.Ignored(instance));
     }
 }
 exports.IgnoredSemverGroup = IgnoredSemverGroup;

package/dist/semver-group/index.d.ts

@@ -1,5 +1,4 @@
 import { Data } from 'effect';
-import type { Union } from 'ts-toolbelt';
 import type { DisabledSemverGroup } from './disabled';
 import type { FilteredOutSemverGroup } from './filtered-out';
 import type { IgnoredSemverGroup } from './ignored';
@@ -9,7 +8,7 @@ export declare namespace SemverGroup {
     export type FilteredOut = FilteredOutSemverGroup;
     export type Ignored = IgnoredSemverGroup;
     export type WithRange = WithRangeSemverGroup;
-    export type Any = Union.Strict<Disabled | FilteredOut | Ignored | WithRange>;
+    export type Any = Disabled | FilteredOut | Ignored | WithRange;
     const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
         readonly _tag: "SemverGroupConfigError";
     }>;

package/dist/semver-group/with-range.js

@@ -33,24 +33,16 @@ class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
             instance.versionGroup._tag === 'Pinned' &&
                 instance.rawSpecifier === instance.versionGroup.config.pinVersion
                 ? // the pinned version takes precendence and is a match
-                    new report_1.Report.Valid({
-                        specifier: current,
-                    })
+                    new report_1.Report.Valid(current)
                 : // if it is already like this on disk
                     instance.rawSpecifier === valid.raw
                         ? // it is a match
-                            new report_1.Report.Valid({
-                                specifier: current,
-                            })
+                            new report_1.Report.Valid(current)
                         : // it is a mismatch and should be this one
-                            new report_1.Report.SemverRangeMismatch({
-                                fixable: valid,
-                            }),
+                            new report_1.Report.SemverRangeMismatch(valid),
             // if range is NOT fixable, it is a mismatch we can't auto-fix
             // as it seems to not be semver
-            onFailure: () => new report_1.Report.UnsupportedMismatch({
-                unfixable: instance,
-            }),
+            onFailure: () => new report_1.Report.UnsupportedMismatch(instance),
         }));
     }
 }

package/dist/specifier/index.d.ts

@@ -1,4 +1,3 @@
-import type { Union } from 'ts-toolbelt';
 import type { Instance } from '../get-instances/instance';
 import { type Delete } from '../version-group/lib/delete';
 import { AliasSpecifier } from './alias';
@@ -22,6 +21,6 @@ export declare namespace Specifier {
     const Url: typeof UrlSpecifier;
     const Version: typeof VersionSpecifier;
     const WorkspaceProtocol: typeof WorkspaceProtocolSpecifier;
-    type Any = Union.Strict<AliasSpecifier | DeleteSpecifier | FileSpecifier | HostedGitSpecifier | RangeSpecifier | TagSpecifier | UnsupportedSpecifier | UrlSpecifier | VersionSpecifier | WorkspaceProtocolSpecifier>;
+    type Any = AliasSpecifier | DeleteSpecifier | FileSpecifier | HostedGitSpecifier | RangeSpecifier | TagSpecifier | UnsupportedSpecifier | UrlSpecifier | VersionSpecifier | WorkspaceProtocolSpecifier;
     function create(instance: Instance, raw: string | Delete): Specifier.Any;
 }

package/dist/specifier/lib/parse-specifier.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSpecifier = void 0;
 const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
 function parseSpecifier(name, specifier, packageJsonFile) {
-    if (specifier === 'workspace:*' || specifier === 'workspace:~') {
+    if (specifier === 'workspace:*' || specifier === 'workspace:~' || specifier === 'workspace:^') {
         const parsed = npm_package_arg_1.default.resolve(name, packageJsonFile.jsonFile.dirPath, specifier.replace('workspace:', 'file:'));
         return {
             escapedName: parsed.escapedName,

package/dist/specifier/workspace-protocol.js

@@ -16,11 +16,12 @@ class WorkspaceProtocolSpecifier extends base_1.BaseSpecifier {
         if (this.raw === 'workspace:*') {
             return effect_1.Effect.succeed('*');
         }
-        if (this.raw === 'workspace:~') {
+        if (this.raw === 'workspace:~' || this.raw === 'workspace:^') {
+            const range = this.raw.replace('workspace:', '');
             const local = ctx.packageJsonFilesByName[this.instance.name];
             const version = local?.jsonFile?.contents?.version;
             if (version)
-                return effect_1.Effect.succeed(`~${version}`);
+                return effect_1.Effect.succeed(`${range}${version}`);
         }
         return effect_1.Effect.succeed('0.0.0');
     }

package/dist/strategy/name-and-version-props.js

@@ -24,10 +24,10 @@ class NameAndVersionPropsStrategy {
         // add the version prop
         effect_1.Effect.bind('version', () => (0, effect_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.path, file), 
         /**
-         * In order to report an `InstanceReport.MissingLocalVersion`, we need
-         * to ensure that a value is returned for `local` package .version
-         * properties so we can know that `this.name` is a package developed
-         * in this repo but that its version is missing.
+         * In order to report a `MissingLocalVersion`, we need to ensure that
+         * a value is returned for `local` package .version properties so we
+         * can know that `this.name` is a package developed in this repo but
+         * that its version is missing.
          *
          * Not doing this results in the invalid local package being ignored
          * and each installation of it being checked for mismatches amongst

package/dist/version-group/banned.js

@@ -23,9 +23,7 @@ class BannedVersionGroup extends effect_1.Data.TaggedClass('Banned') {
             reports: instances.map((instance) => 
             // ✘ package should not be used
             // ✓ is a mismatch we can auto-fix
-            new report_1.Report.Banned({
-                fixable: specifier_1.Specifier.create(instance, delete_1.DELETE),
-            })),
+            new report_1.Report.Banned(specifier_1.Specifier.create(instance, delete_1.DELETE))),
         })));
     }
 }

package/dist/version-group/filtered-out.js

@@ -27,7 +27,7 @@ class FilteredOutVersionGroup extends effect_1.Data.TaggedClass('FilteredOut') {
             name,
             reports: instances.map((instance) => 
             // ✓ is ignored and dismissed as valid
-            new report_1.Report.FilteredOut({ instance })),
+            new report_1.Report.FilteredOut(instance)),
         })));
     }
 }

package/dist/version-group/ignored.js

@@ -20,7 +20,7 @@ class IgnoredVersionGroup extends effect_1.Data.TaggedClass('Ignored') {
             name,
             reports: instances.map((instance) => 
             // ✓ is ignored and dismissed as valid
-            new report_1.Report.Ignored({ instance })),
+            new report_1.Report.Ignored(instance)),
         })));
     }
 }

package/dist/version-group/index.d.ts

@@ -1,5 +1,4 @@
 import { Data } from 'effect';
-import type { Union } from 'ts-toolbelt';
 import type { BannedVersionGroup } from './banned';
 import type { FilteredOutVersionGroup } from './filtered-out';
 import type { IgnoredVersionGroup } from './ignored';
@@ -15,7 +14,7 @@ export declare namespace VersionGroup {
     export type SameRange = SameRangeVersionGroup;
     export type SnappedTo = SnappedToVersionGroup;
     export type Standard = StandardVersionGroup;
-    export type Any = Union.Strict<Banned | FilteredOut | Ignored | Pinned | SameRange | SnappedTo | Standard>;
+    export type Any = Banned | FilteredOut | Ignored | Pinned | SameRange | SnappedTo | Standard;
     const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
         readonly _tag: "VersionGroupConfigError";
     }>;

package/dist/version-group/pinned.js

@@ -20,11 +20,11 @@ class PinnedVersionGroup extends effect_1.Data.TaggedClass('Pinned') {
         return effect_1.Effect.all(Object.entries((0, group_by_1.groupBy)('name', this.instances)).map(([name, instances]) => (0, effect_1.pipe)(instances, effect_1.Effect.forEach((instance) => (0, effect_1.pipe)(effect_1.Effect.succeed(specifier_1.Specifier.create(instance, this.config.pinVersion)), effect_1.Effect.map((expected) => instance.rawSpecifier === expected.raw
             ? // ✓ pinned takes precedence over any semver group
                 // ✓ current version matches expected
-                new report_1.Report.Valid({ specifier: expected })
+                new report_1.Report.Valid(expected)
             : // ✓ pinned takes precedence over any semver group
                 // ✘ current version mismatches expected
                 // ✓ is a mismatch we can auto-fix
-                new report_1.Report.PinnedMismatch({ fixable: expected })))), effect_1.Effect.map((reports) => ({ name, reports })))));
+                new report_1.Report.PinnedMismatch(expected)))), effect_1.Effect.map((reports) => ({ name, reports })))));
     }
 }
 exports.PinnedVersionGroup = PinnedVersionGroup;

package/dist/version-group/same-range.js

@@ -27,27 +27,25 @@ class SameRangeVersionGroup extends effect_1.Data.TaggedClass('SameRange') {
             onFailure: () => effect_1.Effect.fail(
             // ✘ expected version is not semver
             // ✘ is a mismatch we can't auto-fix
-            new report_1.Report.UnsupportedMismatch({ unfixable: specifier.instance })),
+            new report_1.Report.UnsupportedMismatch(specifier.instance)),
             onSuccess: () => (0, effect_1.pipe)(specifier.instance.semverGroup.getFixed(specifier), effect_1.Effect.matchEffect({
                 onFailure: () => effect_1.Effect.fail(
                 // ✓ expected version is semver
                 // ✘ expected version is not fixable by its semver group
                 // ✘ is a mismatch we can't auto-fix
-                new report_1.Report.UnsupportedMismatch({
-                    unfixable: specifier.instance,
-                })),
+                new report_1.Report.UnsupportedMismatch(specifier.instance)),
                 onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
                     ? effect_1.Effect.succeed(
                     // ✓ expected version is semver
                     // ✓ expected version matches its semver group
                     // ✓ current version matches expected
-                    new report_1.Report.Valid({ specifier }))
+                    new report_1.Report.Valid(specifier))
                     : effect_1.Effect.fail(
                     // ✓ expected version is semver
                     // ✓ expected version matches its semver group
                     // ✘ current version mismatches expected
                     // ✓ is a mismatch we can auto-fix
-                    new report_1.Report.SemverRangeMismatch({ fixable: valid })),
+                    new report_1.Report.SemverRangeMismatch(valid)),
             })),
         }))))), effect_1.Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
             ? allMatches.map((thisMatch) => {
@@ -74,10 +72,7 @@ class SameRangeVersionGroup extends effect_1.Data.TaggedClass('SameRange') {
                 // ✓ current version matches expected
                 // ! is not the original local package
                 // ✘ current specifier does not match every other specifier
-                return new report_1.Report.SameRangeMismatch({
-                    unfixable: thisMatch.specifier.instance,
-                    mismatches: (0, uniq_1.uniq)(mismatches.map((report) => report.specifier.instance.rawSpecifier)),
-                });
+                return new report_1.Report.SameRangeMismatch(thisMatch.specifier.instance, (0, uniq_1.uniq)(mismatches.map((report) => report.specifier.instance.rawSpecifier)));
             })
             : // ✘ not every instance is valid on its own
                 // ! report on their validity individually ! when all are valid

package/dist/version-group/snapped-to.js

@@ -21,29 +21,24 @@ class SnappedToVersionGroup extends effect_1.Data.TaggedClass('SnappedTo') {
             onFailure: () => effect_1.Effect.succeed(instances.map((instance) => 
             // ✘ none of the snapTo packages contain this dependency
             // ✘ is a user configuration error we can't auto-fix
-            new report_1.Report.MissingSnappedToMismatch({ unfixable: instance }))),
+            new report_1.Report.MissingSnappedToMismatch(instance))),
             onSuccess: (expected) => (0, effect_1.pipe)(instances, effect_1.Effect.forEach((instance) => (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('specifier', () => effect_1.Effect.succeed(specifier_1.Specifier.create(instance, instance.rawSpecifier))), effect_1.Effect.bind('expected', () => effect_1.Effect.succeed(specifier_1.Specifier.create(instance, expected.rawSpecifier))), effect_1.Effect.flatMap(({ expected, specifier }) => (0, effect_1.pipe)(expected.getSemver(), effect_1.Effect.matchEffect({
                 onFailure: () => (0, effect_1.pipe)(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, effect_1.Effect.match({
                     onFailure: () => 
                     // ✘ expected version is not semver
                     // ✘ semver group expects semver
                     // ✘ is a mismatch we can't auto-fix
-                    new report_1.Report.UnsupportedMismatch({
-                        unfixable: specifier.instance,
-                    }),
+                    new report_1.Report.UnsupportedMismatch(specifier.instance),
                     onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
                         ? // ! expected version is not semver
                             // ✓ semver group is disabled/ignored
                             // ✓ current version matches expected
-                            new report_1.Report.Valid({ specifier })
+                            new report_1.Report.Valid(specifier)
                         : // ! expected version is not semver
                             // ✓ semver group is disabled/ignored
                             // ✘ current version mismatches expected
                             // ✓ is a mismatch we can auto-fix by replacing with the non-semver version
-                            new report_1.Report.SnappedToMismatch({
-                                fixable: valid,
-                                localInstance: expected.instance,
-                            }),
+                            new report_1.Report.SnappedToMismatch(valid, expected.instance),
                 })),
                 onSuccess: () => (0, effect_1.pipe)(specifier.replaceWith(expected), specifier.instance.semverGroup.getFixed, effect_1.Effect.match({
                     onFailure: /* istanbul ignore next */ () => 
@@ -51,22 +46,17 @@ class SnappedToVersionGroup extends effect_1.Data.TaggedClass('SnappedTo') {
                     // ✘ expected version is not fixable by its semver group
                     // ✘ is a mismatch we can't auto-fix
                     // ✘ this should be impossible - we already proved the local version is exact semver
-                    new report_1.Report.UnsupportedMismatch({
-                        unfixable: specifier.instance,
-                    }),
+                    new report_1.Report.UnsupportedMismatch(specifier.instance),
                     onSuccess: (valid) => specifier.instance.rawSpecifier === valid.raw
                         ? // ✓ expected version is semver
                             // ✓ expected version matches its semver group
                             // ✓ current version matches expected
-                            new report_1.Report.Valid({ specifier })
+                            new report_1.Report.Valid(specifier)
                         : // ✓ expected version is semver
                             // ✓ expected version matches its semver group
                             // ✘ current version mismatches expected
                             // ✓ is a mismatch we can auto-fix
-                            new report_1.Report.SnappedToMismatch({
-                                fixable: valid,
-                                localInstance: expected.instance,
-                            }),
+                            new report_1.Report.SnappedToMismatch(valid, expected.instance),
                 })),
             })))))),
         }), effect_1.Effect.map((reports) => ({ name, reports })))));