From c0d08d571cb595fc877477cec22b2d928b2ef1bc Mon Sep 17 00:00:00 2001
From: Jamie Mason <jamie@foldleft.io>
Date: Sun, 21 Apr 2024 11:19:42 +0100
Subject: [PATCH] refactor(effect): run @effect/codemod

---
 src/bin-format/format.ts                      |   2 +-
 .../lint-semver-ranges.ts                     |   6 +-
 src/bin-list-mismatches/list-mismatches.ts    | 348 +++++++++---------
 src/bin-list/list.ts                          |  19 +-
 src/bin-update/effects.ts                     |  38 +-
 src/config/get-custom-types.ts                |   2 +-
 src/config/get-enabled-types.ts               |   7 +-
 src/config/tag.ts                             |   2 +-
 src/error-handlers/default-error-handlers.ts  |   2 +-
 src/get-context/index.ts                      |   2 +-
 src/get-instances/index.ts                    |   2 +-
 src/get-instances/instance.ts                 |   2 +-
 src/get-package-json-files/get-file-paths.ts  |   2 +-
 .../get-patterns/get-lerna-patterns.ts        |   2 +-
 .../get-patterns/get-pnpm-patterns.ts         |   2 +-
 .../get-patterns/get-yarn-patterns.ts         |   2 +-
 .../get-patterns/index.ts                     |   6 +-
 src/get-package-json-files/index.ts           |   5 +-
 .../package-json-file.ts                      |   2 +-
 src/io/ask-for-choice.ts                      |   2 +-
 src/io/ask-for-input.ts                       |   2 +-
 src/io/exit-if-invalid.ts                     |   2 +-
 src/io/glob-sync.ts                           |   2 +-
 src/io/index.ts                               |   2 +-
 src/io/read-config-file.ts                    |   9 +-
 src/io/read-file-sync.ts                      |   5 +-
 src/io/read-json-file-sync.ts                 |   2 +-
 src/io/read-yaml-file-sync.ts                 |   2 +-
 src/io/write-file-sync.ts                     |   2 +-
 src/io/write-if-changed.ts                    |   2 +-
 src/lib/get.ts                                |  24 +-
 src/lib/with-logger.ts                        |   2 +-
 src/semver-group/create-semver-groups.ts      |   4 +-
 src/semver-group/disabled.ts                  |   4 +-
 src/semver-group/filtered-out.ts              |   4 +-
 src/semver-group/ignored.ts                   |   4 +-
 src/semver-group/with-range.ts                |   8 +-
 src/specifier/alias.ts                        |   4 +-
 src/specifier/base.ts                         |   9 +-
 src/specifier/exact.ts                        |   4 +-
 src/specifier/hosted-git.ts                   |   4 +-
 src/specifier/latest.ts                       |   4 +-
 src/specifier/lib/non-semver-error.ts         |   2 +-
 src/specifier/range.ts                        |   4 +-
 src/specifier/workspace-protocol.ts           |   6 +-
 src/strategy/lib/get-non-empty-string-prop.ts |   2 +-
 src/strategy/name-and-version-props.ts        |   4 +-
 src/strategy/named-version-string.ts          |   4 +-
 src/strategy/unnamed-version-string.ts        |   4 +-
 src/strategy/versions-by-name.ts              |   4 +-
 src/version-group/banned.ts                   |   2 +-
 src/version-group/create-version-groups.ts    |   4 +-
 src/version-group/filtered-out.ts             |   2 +-
 src/version-group/ignored.ts                  |   2 +-
 .../lib/get-preferred-version.ts              |   2 +-
 src/version-group/pinned.ts                   |   2 +-
 src/version-group/same-range.ts               |   2 +-
 src/version-group/snapped-to.ts               |   4 +-
 src/version-group/standard.ts                 |   2 +-
 59 files changed, 288 insertions(+), 324 deletions(-)

diff --git a/src/bin-format/format.ts b/src/bin-format/format.ts
index e89d9a80..8c3afa73 100644
--- a/src/bin-format/format.ts
+++ b/src/bin-format/format.ts
@@ -47,7 +47,7 @@ export function format({ io, cli, errorHandlers = defaultErrorHandlers }: Input)
   );
 }
 
-export function pipeline(ctx: Ctx): Effect.Effect<never, never, Ctx> {
+export function pipeline(ctx: Ctx): Effect.Effect<Ctx> {
   const { config, packageJsonFiles } = ctx;
   const sortAz = getSortAz(config);
   const sortExports = getSortExports(config);
diff --git a/src/bin-lint-semver-ranges/lint-semver-ranges.ts b/src/bin-lint-semver-ranges/lint-semver-ranges.ts
index 52bc9416..19589051 100644
--- a/src/bin-lint-semver-ranges/lint-semver-ranges.ts
+++ b/src/bin-lint-semver-ranges/lint-semver-ranges.ts
@@ -35,11 +35,7 @@ export function lintSemverRanges({ io, cli, errorHandlers = defaultErrorHandlers
 }
 
 /** Exported to be reused by `syncpack lint` */
-export function pipeline(
-  ctx: Ctx,
-  io: Io,
-  errorHandlers: ErrorHandlers,
-): Effect.Effect<never, never, Ctx> {
+export function pipeline(ctx: Ctx, io: Io, errorHandlers: ErrorHandlers): Effect.Effect<Ctx> {
   return Effect.gen(function* ($) {
     // no semver groups have been configured, they are disabled by default
     if (!isNonEmptyArray(ctx.config.rcFile.semverGroups)) {
diff --git a/src/bin-list-mismatches/list-mismatches.ts b/src/bin-list-mismatches/list-mismatches.ts
index 486b4385..c33a96c3 100644
--- a/src/bin-list-mismatches/list-mismatches.ts
+++ b/src/bin-list-mismatches/list-mismatches.ts
@@ -34,11 +34,7 @@ export function listMismatches({ io, cli, errorHandlers = defaultErrorHandlers }
 }
 
 /** Exported to be reused by `syncpack lint` */
-export function pipeline(
-  ctx: Ctx,
-  io: Io,
-  errorHandlers: ErrorHandlers,
-): Effect.Effect<never, never, Ctx> {
+export function pipeline(ctx: Ctx, io: Io, errorHandlers: ErrorHandlers): Effect.Effect<Ctx> {
   return Effect.gen(function* ($) {
     const { versionGroups } = yield* $(getInstances(ctx, io, errorHandlers));
     let index = 0;
@@ -75,210 +71,206 @@ export function pipeline(
   });
 }
 
-const onReportGroup: Record<
-  Report.Any['_tagGroup'],
-  (count: number) => Effect.Effect<never, never, void>
-> = {
+const onReportGroup: Record<Report.Any['_tagGroup'], (count: number) => Effect.Effect<void>> = {
   Excluded(amount: number) {
-    if (amount === 0) return Effect.unit;
+    if (amount === 0) return Effect.void;
     const msg = chalk`{gray ${padStart(amount)} ${ICON.rightArrow} ignored}`;
     return Effect.logInfo(msg);
   },
   Fixable(amount: number) {
-    if (amount === 0) return Effect.unit;
+    if (amount === 0) return Effect.void;
     const msg = chalk`${padStart(amount)} {green ${ICON.tick}} can be auto-fixed`;
     return Effect.logInfo(msg);
   },
   Unfixable(amount: number) {
-    if (amount === 0) return Effect.unit;
+    if (amount === 0) return Effect.void;
     const msg = chalk`{red ${padStart(amount)} ${
       ICON.panic
     } can be fixed manually using} {blue syncpack prompt}`;
     return Effect.logInfo(msg);
   },
   Valid(amount: number) {
-    if (amount === 0) return Effect.unit;
+    if (amount === 0) return Effect.void;
     const msg = chalk`${padStart(amount)} {green ${ICON.tick}} already valid`;
     return Effect.logInfo(msg);
   },
 };
 
-const onReportTag: Record<Report.Any['_tag'], (report: any) => Effect.Effect<never, never, void>> =
-  {
-    Banned(report: Report.Banned) {
-      const _tag = report._tag;
-      const instance = report.fixable.instance;
-      const name = instance.name;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
+const onReportTag: Record<Report.Any['_tag'], (report: any) => Effect.Effect<void>> = {
+  Banned(report: Report.Banned) {
+    const _tag = report._tag;
+    const instance = report.fixable.instance;
+    const name = instance.name;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red banned} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    Disabled(_report: Report.Disabled) {
-      return Effect.unit;
-    },
-    FilteredOut(_report: Report.FilteredOut) {
-      return Effect.unit;
-    },
-    HighestSemverMismatch(report: Report.HighestSemverMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red banned} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  Disabled(_report: Report.Disabled) {
+    return Effect.void;
+  },
+  FilteredOut(_report: Report.FilteredOut) {
+    return Effect.void;
+  },
+  HighestSemverMismatch(report: Report.HighestSemverMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    Ignored(_report: Report.Ignored) {
-      return Effect.unit;
-    },
-    LocalPackageMismatch(report: Report.LocalPackageMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = instance.packageJsonFile.jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  Ignored(_report: Report.Ignored) {
+    return Effect.void;
+  },
+  LocalPackageMismatch(report: Report.LocalPackageMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = instance.packageJsonFile.jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    LowestSemverMismatch(report: Report.LowestSemverMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = instance.packageJsonFile.jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  LowestSemverMismatch(report: Report.LowestSemverMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = instance.packageJsonFile.jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    MissingLocalVersion(report: Report.MissingLocalVersion) {
-      const instance = report.unfixable;
-      const localPath = report.localInstance.packageJsonFile.jsonFile.shortPath;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const actual = instance.rawSpecifier.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  MissingLocalVersion(report: Report.MissingLocalVersion) {
+    const instance = report.unfixable;
+    const localPath = report.localInstance.packageJsonFile.jsonFile.shortPath;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const actual = instance.rawSpecifier.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
 
-      return Effect.logInfo(
-        [
-          chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingLocalVersion]}`,
-          chalk`  {red ${localPath} does not have a .version property which is exact semver}`,
-        ].join(EOL),
-      );
-    },
-    MissingSnappedToMismatch(report: Report.MissingSnappedToMismatch) {
-      const instance = report.unfixable;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const actual = instance.rawSpecifier.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
+    return Effect.logInfo(
+      [
+        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingLocalVersion]}`,
+        chalk`  {red ${localPath} does not have a .version property which is exact semver}`,
+      ].join(EOL),
+    );
+  },
+  MissingSnappedToMismatch(report: Report.MissingSnappedToMismatch) {
+    const instance = report.unfixable;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const actual = instance.rawSpecifier.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
 
-      return Effect.logInfo(
-        [
-          chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingSnappedToMismatch]}`,
-          chalk`  {red no package in this groups .snapTo array depend on ${name}}`,
-        ].join(EOL),
-      );
-    },
-    PinnedMismatch(report: Report.PinnedMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = instance.packageJsonFile.jsonFile.shortPath;
+    return Effect.logInfo(
+      [
+        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingSnappedToMismatch]}`,
+        chalk`  {red no package in this groups .snapTo array depend on ${name}}`,
+      ].join(EOL),
+    );
+  },
+  PinnedMismatch(report: Report.PinnedMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = instance.packageJsonFile.jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    SameRangeMismatch(report: Report.SameRangeMismatch) {
-      const instance = report.unfixable;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const actual = instance.rawSpecifier.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
-      const mismatches = report.mismatches;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  SameRangeMismatch(report: Report.SameRangeMismatch) {
+    const instance = report.unfixable;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const actual = instance.rawSpecifier.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
+    const mismatches = report.mismatches;
 
-      return Effect.logInfo(
-        [
-          chalk`{red ${ICON.cross}} ${name} {red range ${actual} does not include ${mismatches.join(
-            ', ',
-          )}} {gray ${shortPath} > ${path}} {blue [SameRangeMismatch]}`,
-          chalk`  {gray use {blue syncpack prompt} to fix this manually}`,
-        ].join(EOL),
-      );
-    },
-    SemverRangeMismatch(report: Report.SemverRangeMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = instance.packageJsonFile.jsonFile.shortPath;
+    return Effect.logInfo(
+      [
+        chalk`{red ${ICON.cross}} ${name} {red range ${actual} does not include ${mismatches.join(
+          ', ',
+        )}} {gray ${shortPath} > ${path}} {blue [SameRangeMismatch]}`,
+        chalk`  {gray use {blue syncpack prompt} to fix this manually}`,
+      ].join(EOL),
+    );
+  },
+  SemverRangeMismatch(report: Report.SemverRangeMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = instance.packageJsonFile.jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    SnappedToMismatch(report: Report.SnappedToMismatch) {
-      const _tag = report._tag;
-      const fixable = report.fixable;
-      const instance = fixable.instance;
-      const actual = instance.rawSpecifier.raw;
-      const expected = fixable.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = instance.packageJsonFile.jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  SnappedToMismatch(report: Report.SnappedToMismatch) {
+    const _tag = report._tag;
+    const fixable = report.fixable;
+    const instance = fixable.instance;
+    const actual = instance.rawSpecifier.raw;
+    const expected = fixable.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = instance.packageJsonFile.jsonFile.shortPath;
 
-      return Effect.logInfo(
-        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
-      );
-    },
-    UnsupportedMismatch(report: Report.UnsupportedMismatch) {
-      const instance = report.unfixable;
-      const jsonFile = instance.packageJsonFile.jsonFile;
-      const actual = instance.rawSpecifier.raw;
-      const name = instance.name;
-      const path = instance.strategy.path;
-      const shortPath = jsonFile.shortPath;
+    return Effect.logInfo(
+      chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`,
+    );
+  },
+  UnsupportedMismatch(report: Report.UnsupportedMismatch) {
+    const instance = report.unfixable;
+    const jsonFile = instance.packageJsonFile.jsonFile;
+    const actual = instance.rawSpecifier.raw;
+    const name = instance.name;
+    const path = instance.strategy.path;
+    const shortPath = jsonFile.shortPath;
 
-      return Effect.logInfo(
-        [
-          chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [UnsupportedMismatch]}`,
-          chalk`  {red use {blue syncpack prompt} to fix this manually}`,
-        ].join(EOL),
-      );
-    },
-    Valid(_report: Report.Valid) {
-      return Effect.unit;
-    },
-  };
+    return Effect.logInfo(
+      [
+        chalk`{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [UnsupportedMismatch]}`,
+        chalk`  {red use {blue syncpack prompt} to fix this manually}`,
+      ].join(EOL),
+    );
+  },
+  Valid(_report: Report.Valid) {
+    return Effect.void;
+  },
+};
 
 export const logMissingLocalVersion = onReportTag.MissingLocalVersion;
 export const logMissingSnappedToMismatch = onReportTag.MissingSnappedToMismatch;
diff --git a/src/bin-list/list.ts b/src/bin-list/list.ts
index f5aa37ae..32849666 100644
--- a/src/bin-list/list.ts
+++ b/src/bin-list/list.ts
@@ -34,11 +34,7 @@ export function list({ io, cli, errorHandlers = defaultErrorHandlers }: Input) {
   );
 }
 
-export function pipeline(
-  ctx: Ctx,
-  io: Io,
-  errorHandlers: ErrorHandlers,
-): Effect.Effect<never, never, Ctx> {
+export function pipeline(ctx: Ctx, io: Io, errorHandlers: ErrorHandlers): Effect.Effect<Ctx> {
   return Effect.gen(function* ($) {
     const { versionGroups } = yield* $(getInstances(ctx, io, errorHandlers));
     let index = 0;
@@ -92,10 +88,7 @@ export function pipeline(
   });
 }
 
-const onGroupTag: Record<
-  VersionGroup.Any['_tag'],
-  (group: any) => Effect.Effect<never, never, void>
-> = {
+const onGroupTag: Record<VersionGroup.Any['_tag'], (group: any) => Effect.Effect<void>> = {
   Banned(group: VersionGroup.Banned) {
     return Effect.gen(function* ($) {
       for (const groupReport of yield* $(group.inspectAll())) {
@@ -130,16 +123,16 @@ const onGroupTag: Record<
     });
   },
   Pinned(_group: VersionGroup.Pinned) {
-    return Effect.unit;
+    return Effect.void;
   },
   SameRange(_group: VersionGroup.SameRange) {
-    return Effect.unit;
+    return Effect.void;
   },
   SnappedTo(_group: VersionGroup.SnappedTo) {
-    return Effect.unit;
+    return Effect.void;
   },
   Standard(_group: VersionGroup.Standard) {
-    return Effect.unit;
+    return Effect.void;
   },
 };
 
diff --git a/src/bin-update/effects.ts b/src/bin-update/effects.ts
index 9f917ebc..ed350eff 100644
--- a/src/bin-update/effects.ts
+++ b/src/bin-update/effects.ts
@@ -76,7 +76,7 @@ export const updateEffects = {
   onFetchAllStart() {
     if (!spinner) spinner = ora().start();
     fetchedCount = 0;
-    return Effect.unit;
+    return Effect.void;
   },
   onFetchStart(instance: Instance, totalCount: number) {
     inFlight.add(format(instance));
@@ -90,7 +90,7 @@ export const updateEffects = {
       const suffixText = sortedProgress.join(indent);
       spinner.text = chalk`${outdatedCount} updates found in ${fetchedCount}/${totalCount} dependencies${indent}${suffixText}`;
     }
-    return Effect.unit;
+    return Effect.void;
   },
   onFetchEnd(instance: Instance, versions?: Releases['versions']) {
     inFlight.delete(format(instance));
@@ -105,12 +105,12 @@ export const updateEffects = {
         mostRecent.push(chalk`{green ${instance.name}}`);
       }
     }
-    return Effect.unit;
+    return Effect.void;
   },
   /** After checking the registry, store this instance known to be up to date */
   onUpToDate(instance: Instance) {
     mostRecent.push(chalk`{green ${instance.name}}`);
-    return Effect.unit;
+    return Effect.void;
   },
   /** After checking the registry, store this instance known to have newer versions available */
   onOutdated(instance: Instance, latest: string) {
@@ -118,30 +118,28 @@ export const updateEffects = {
     mostRecent.push(
       chalk`${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${ICON.rightArrow}} {green ${latest}}`,
     );
-    return Effect.unit;
+    return Effect.void;
   },
   /** As the last request completes, remove the progress information */
   onFetchAllEnd() {
     if (spinner) spinner.stop();
     spinner = null;
     fetchedCount = 0;
-    return Effect.unit;
+    return Effect.void;
   },
   /** Fetch available versions for a given package from the npm registry */
-  fetchLatestVersions(
-    instance: Instance,
-  ): Effect.Effect<never, HttpError | NpmRegistryError, Releases> {
+  fetchLatestVersions(instance: Instance): Effect.Effect<Releases, HttpError | NpmRegistryError> {
     return pipe(
       fetchJson(`https://registry.npmjs.org/${instance.name}`),
       // parse and validate the specific data we expect
       Effect.flatMap(
         Schema.parse(
-          Schema.struct({
-            'dist-tags': Schema.struct({ latest: Schema.string }),
-            'time': Schema.record(Schema.string, Schema.string),
-            'homepage': Schema.optional(Schema.string),
+          Schema.Struct({
+            'dist-tags': Schema.Struct({ latest: Schema.String }),
+            'time': Schema.Record(Schema.String, Schema.String),
+            'homepage': Schema.optional(Schema.String),
             'repository': Schema.optional(
-              Schema.union(Schema.string, Schema.struct({ url: Schema.optional(Schema.string) })),
+              Schema.Union(Schema.String, Schema.Struct({ url: Schema.optional(Schema.String) })),
             ),
           }),
         ),
@@ -168,7 +166,7 @@ export const updateEffects = {
     );
   },
   /** Given responses from npm, ask the user which they want */
-  promptForUpdates(outdated: Releases[]): Effect.Effect<never, PromptCancelled, void> {
+  promptForUpdates(outdated: Releases[]): Effect.Effect<void, PromptCancelled> {
     return pipe(
       Effect.Do,
       Effect.bind('releasesByType', () => groupByReleaseType(outdated)),
@@ -242,7 +240,7 @@ export const updateEffects = {
               ),
             ),
           ),
-          Effect.flatMap(() => Effect.unit),
+          Effect.flatMap(() => Effect.void),
         ),
       ),
     );
@@ -252,7 +250,7 @@ export const updateEffects = {
 function promptForReleaseType(
   releaseType: ReleaseType,
   doState: { releasesByType: ReleasesByType; releaseTypeAnswers: string[] },
-): Effect.Effect<never, PromptCancelled, Releases[]> {
+): Effect.Effect<Releases[], PromptCancelled> {
   const { releasesByType, releaseTypeAnswers } = doState;
   const prop = `${releaseType}Answers`;
   const releases = releasesByType[releaseType];
@@ -307,7 +305,7 @@ function promptForReleaseType(
     : Effect.succeed([]);
 }
 
-function groupByReleaseType(releases: Releases[]): Effect.Effect<never, never, ReleasesByType> {
+function groupByReleaseType(releases: Releases[]): Effect.Effect<ReleasesByType> {
   return Effect.succeed(
     releases.reduce(
       (releasesByType: ReleasesByType, release) => {
@@ -337,9 +335,9 @@ function groupByReleaseType(releases: Releases[]): Effect.Effect<never, never, R
 }
 
 // @TODO: add a cache with a short TTL on disk in $TMPDIR
-function fetchJson(url: string): Effect.Effect<never, HttpError | NpmRegistryError, unknown> {
+function fetchJson(url: string): Effect.Effect<unknown, HttpError | NpmRegistryError> {
   return pipe(
-    Effect.async<never, HttpError, string>((resume) => {
+    Effect.async<string, HttpError>((resume) => {
       // setTimeout(
       //   () => {
       //     resume(
diff --git a/src/config/get-custom-types.ts b/src/config/get-custom-types.ts
index 838fdde7..f8c017c5 100644
--- a/src/config/get-custom-types.ts
+++ b/src/config/get-custom-types.ts
@@ -24,7 +24,7 @@ export class InvalidCustomTypeError extends Data.TaggedClass('InvalidCustomTypeE
 
 export function getCustomTypes({
   rcFile,
-}: Ctx['config']): Effect.Effect<never, InvalidCustomTypeError, Strategy.Any[]> {
+}: Ctx['config']): Effect.Effect<Strategy.Any[], InvalidCustomTypeError> {
   if (!isNonEmptyObject(rcFile.customTypes)) return Effect.succeed([]);
 
   return Effect.all(
diff --git a/src/config/get-enabled-types.ts b/src/config/get-enabled-types.ts
index 0d846e5c..3ae687a8 100644
--- a/src/config/get-enabled-types.ts
+++ b/src/config/get-enabled-types.ts
@@ -23,9 +23,8 @@ export function getEnabledTypes({
   cli,
   rcFile,
 }: Ctx['config']): Effect.Effect<
-  never,
-  DeprecatedTypesError | InvalidCustomTypeError | RenamedWorkspaceTypeError,
-  Strategy.Any[]
+  Strategy.Any[],
+  DeprecatedTypesError | InvalidCustomTypeError | RenamedWorkspaceTypeError
 > {
   return pipe(
     // Look for dependency types defined using the old `{ prod: true }` syntax
@@ -37,7 +36,7 @@ export function getEnabledTypes({
     Effect.flatMap((deprecatedTypeProps) =>
       deprecatedTypeProps.length > 0
         ? Effect.fail(new DeprecatedTypesError({ types: deprecatedTypeProps }))
-        : Effect.unit,
+        : Effect.void,
     ),
     Effect.flatMap(() =>
       pipe(
diff --git a/src/config/tag.ts b/src/config/tag.ts
index 5a33ef06..853a773d 100644
--- a/src/config/tag.ts
+++ b/src/config/tag.ts
@@ -1,4 +1,4 @@
 import { Context } from 'effect';
 import type { CliConfig } from './types.js';
 
-export const CliConfigTag = Context.Tag<Partial<CliConfig>>();
+export const CliConfigTag = Context.GenericTag<Partial<CliConfig>>('@services/CliConfigTag');
diff --git a/src/error-handlers/default-error-handlers.ts b/src/error-handlers/default-error-handlers.ts
index b46369b9..743b0fb2 100644
--- a/src/error-handlers/default-error-handlers.ts
+++ b/src/error-handlers/default-error-handlers.ts
@@ -14,7 +14,7 @@ import type { WriteFileError } from '../io/write-file-sync.js';
 import type { SemverGroup } from '../semver-group/index.js';
 import type { VersionGroup } from '../version-group/index.js';
 
-type R = Effect.Effect<never, never, void>;
+type R = Effect.Effect<void>;
 
 export interface ErrorHandlers {
   // getInstances
diff --git a/src/get-context/index.ts b/src/get-context/index.ts
index b4ac455c..864d5564 100644
--- a/src/get-context/index.ts
+++ b/src/get-context/index.ts
@@ -25,7 +25,7 @@ interface Input {
   errorHandlers: ErrorHandlers;
 }
 
-export function getContext({ io, cli, errorHandlers }: Input): Effect.Effect<never, never, Ctx> {
+export function getContext({ io, cli, errorHandlers }: Input): Effect.Effect<Ctx> {
   const exitOnError = Effect.flatMap(() => Effect.failSync(() => io.process.exit(1)));
   return pipe(
     Effect.Do,
diff --git a/src/get-instances/index.ts b/src/get-instances/index.ts
index a445a686..a9ef1d4f 100644
--- a/src/get-instances/index.ts
+++ b/src/get-instances/index.ts
@@ -21,7 +21,7 @@ export function getInstances(
   ctx: Ctx,
   io: Io,
   errorHandlers: ErrorHandlers,
-): Effect.Effect<never, never, Instances> {
+): Effect.Effect<Instances> {
   const exitOnError = Effect.flatMap(() => Effect.failSync(() => io.process.exit(1)));
   return pipe(
     Effect.Do,
diff --git a/src/get-instances/instance.ts b/src/get-instances/instance.ts
index d936c6c4..2dfd7ee0 100644
--- a/src/get-instances/instance.ts
+++ b/src/get-instances/instance.ts
@@ -38,7 +38,7 @@ export class Instance {
   }
 
   /** Mutate the package.json file in memory with the latest version specifier */
-  write(rawSpecifier: string | Delete): Effect.Effect<never, never, PackageJsonFile> {
+  write(rawSpecifier: string | Delete): Effect.Effect<PackageJsonFile> {
     this.rawSpecifier = Specifier.create(this, rawSpecifier);
     return this.strategy.write(this.packageJsonFile, [this.name, this.rawSpecifier.raw]);
   }
diff --git a/src/get-package-json-files/get-file-paths.ts b/src/get-package-json-files/get-file-paths.ts
index 53a29c62..cfd9b5b5 100644
--- a/src/get-package-json-files/get-file-paths.ts
+++ b/src/get-package-json-files/get-file-paths.ts
@@ -22,7 +22,7 @@ export class NoSourcesFoundError extends Data.TaggedClass('NoSourcesFoundError')
 export function getFilePaths(
   io: Io,
   config: Ctx['config'],
-): Effect.Effect<never, GlobError | NoSourcesFoundError, string[]> {
+): Effect.Effect<string[], GlobError | NoSourcesFoundError> {
   return pipe(
     Effect.Do,
     Effect.bind('patterns', () => getPatterns(io, config)),
diff --git a/src/get-package-json-files/get-patterns/get-lerna-patterns.ts b/src/get-package-json-files/get-patterns/get-lerna-patterns.ts
index 516e3517..324144d8 100644
--- a/src/get-package-json-files/get-patterns/get-lerna-patterns.ts
+++ b/src/get-package-json-files/get-patterns/get-lerna-patterns.ts
@@ -8,7 +8,7 @@ interface LernaJson {
   packages?: string[];
 }
 
-export function getLernaPatterns(io: Io): Effect.Effect<never, never, O.Option<string[]>> {
+export function getLernaPatterns(io: Io): Effect.Effect<O.Option<string[]>> {
   return pipe(
     readJsonFileSync<LernaJson>(io, join(io.process.cwd(), 'lerna.json')),
     Effect.map((file) =>
diff --git a/src/get-package-json-files/get-patterns/get-pnpm-patterns.ts b/src/get-package-json-files/get-patterns/get-pnpm-patterns.ts
index 903f1ff3..47583493 100644
--- a/src/get-package-json-files/get-patterns/get-pnpm-patterns.ts
+++ b/src/get-package-json-files/get-patterns/get-pnpm-patterns.ts
@@ -8,7 +8,7 @@ interface PnpmWorkspace {
   packages?: string[];
 }
 
-export function getPnpmPatterns(io: Io): Effect.Effect<never, never, O.Option<string[]>> {
+export function getPnpmPatterns(io: Io): Effect.Effect<O.Option<string[]>> {
   return pipe(
     // packages:
     //   - "packages/**"
diff --git a/src/get-package-json-files/get-patterns/get-yarn-patterns.ts b/src/get-package-json-files/get-patterns/get-yarn-patterns.ts
index 5515eb48..8121daf6 100644
--- a/src/get-package-json-files/get-patterns/get-yarn-patterns.ts
+++ b/src/get-package-json-files/get-patterns/get-yarn-patterns.ts
@@ -6,7 +6,7 @@ import type { Io } from '../../io/index.js';
 import { readJsonFileSync } from '../../io/read-json-file-sync.js';
 import type { PackageJson } from '../package-json-file.js';
 
-export function getYarnPatterns(io: Io): Effect.Effect<never, never, O.Option<string[]>> {
+export function getYarnPatterns(io: Io): Effect.Effect<O.Option<string[]>> {
   return pipe(
     readJsonFileSync<PackageJson>(io, join(io.process.cwd(), 'package.json')),
     Effect.map((file) =>
diff --git a/src/get-package-json-files/get-patterns/index.ts b/src/get-package-json-files/get-patterns/index.ts
index 5b451d18..793c3126 100644
--- a/src/get-package-json-files/get-patterns/index.ts
+++ b/src/get-package-json-files/get-patterns/index.ts
@@ -12,7 +12,7 @@ import { getYarnPatterns } from './get-yarn-patterns.js';
  * Find every glob pattern which should be used to find package.json files for
  * this monorepo.
  */
-export function getPatterns(io: Io, config: Ctx['config']): Effect.Effect<never, never, string[]> {
+export function getPatterns(io: Io, config: Ctx['config']): Effect.Effect<string[]> {
   return pipe(
     getCliPatterns(),
     Effect.flatMap((opt) => (O.isSome(opt) ? Effect.succeed(opt) : getWorkspacePatterns())),
@@ -20,11 +20,11 @@ export function getPatterns(io: Io, config: Ctx['config']): Effect.Effect<never,
     Effect.map(O.getOrElse(() => [...DEFAULT_CONFIG.source])),
   );
 
-  function getCliPatterns(): Effect.Effect<never, never, O.Option<string[]>> {
+  function getCliPatterns(): Effect.Effect<O.Option<string[]>> {
     return pipe(O.some(getSource(config)), O.filter(isArrayOfStrings), Effect.succeed);
   }
 
-  function getWorkspacePatterns(): Effect.Effect<never, never, O.Option<string[]>> {
+  function getWorkspacePatterns(): Effect.Effect<O.Option<string[]>> {
     return pipe(
       getYarnPatterns(io),
       Effect.flatMap((opt) => (O.isSome(opt) ? Effect.succeed(opt) : getPnpmPatterns(io))),
diff --git a/src/get-package-json-files/index.ts b/src/get-package-json-files/index.ts
index 81935284..2a0c48c6 100644
--- a/src/get-package-json-files/index.ts
+++ b/src/get-package-json-files/index.ts
@@ -15,9 +15,8 @@ export function getPackageJsonFiles(
   io: Io,
   config: Ctx['config'],
 ): Effect.Effect<
-  never,
-  NoSourcesFoundError | GlobError | ReadFileError | JsonParseError,
-  PackageJsonFile[]
+  PackageJsonFile[],
+  NoSourcesFoundError | GlobError | ReadFileError | JsonParseError
 > {
   return pipe(
     getFilePaths(io, config),
diff --git a/src/get-package-json-files/package-json-file.ts b/src/get-package-json-files/package-json-file.ts
index 14b360bc..6a37f828 100644
--- a/src/get-package-json-files/package-json-file.ts
+++ b/src/get-package-json-files/package-json-file.ts
@@ -50,7 +50,7 @@ export class PackageJsonFile {
     this.name = jsonFile.contents.name;
   }
 
-  getInstances(enabledTypes: Strategy.Any[]): Effect.Effect<never, never, Instance[]> {
+  getInstances(enabledTypes: Strategy.Any[]): Effect.Effect<Instance[]> {
     if (!this._instances) {
       return pipe(
         Effect.all(
diff --git a/src/io/ask-for-choice.ts b/src/io/ask-for-choice.ts
index 9637a79f..136de25c 100644
--- a/src/io/ask-for-choice.ts
+++ b/src/io/ask-for-choice.ts
@@ -9,7 +9,7 @@ class AskForChoiceError extends Data.TaggedClass('AskForChoiceError')<{
 export function askForChoice(opts: {
   message: string;
   choices: string[];
-}): Effect.Effect<Io, AskForChoiceError, string> {
+}): Effect.Effect<string, AskForChoiceError, Io> {
   return pipe(
     IoTag,
     Effect.flatMap((io) =>
diff --git a/src/io/ask-for-input.ts b/src/io/ask-for-input.ts
index 5b7a24f1..5fded9b2 100644
--- a/src/io/ask-for-input.ts
+++ b/src/io/ask-for-input.ts
@@ -8,7 +8,7 @@ class AskForInputError extends Data.TaggedClass('AskForInputError')<{
 
 export function askForInput(opts: {
   message: string;
-}): Effect.Effect<Io, AskForInputError, string> {
+}): Effect.Effect<string, AskForInputError, Io> {
   return pipe(
     IoTag,
     Effect.flatMap((io) =>
diff --git a/src/io/exit-if-invalid.ts b/src/io/exit-if-invalid.ts
index ee757512..d3c86ea0 100644
--- a/src/io/exit-if-invalid.ts
+++ b/src/io/exit-if-invalid.ts
@@ -2,7 +2,7 @@ import { Effect, pipe } from 'effect';
 import type { Ctx } from '../get-context/index.js';
 import { IoTag, type Io } from './index.js';
 
-export function exitIfInvalid(ctx: Ctx): Effect.Effect<Io, never, Ctx> {
+export function exitIfInvalid(ctx: Ctx): Effect.Effect<Ctx, never, Io> {
   return pipe(
     IoTag,
     Effect.tap((io) =>
diff --git a/src/io/glob-sync.ts b/src/io/glob-sync.ts
index a0aac50a..cdb240b0 100644
--- a/src/io/glob-sync.ts
+++ b/src/io/glob-sync.ts
@@ -5,7 +5,7 @@ export class GlobError extends Data.TaggedClass('GlobError')<{
   readonly error: string;
 }> {}
 
-export function globSync(io: Io, patterns: string[]): Effect.Effect<never, GlobError, string[]> {
+export function globSync(io: Io, patterns: string[]): Effect.Effect<string[], GlobError> {
   return Effect.try({
     try: () =>
       io.globby.sync(patterns, {
diff --git a/src/io/index.ts b/src/io/index.ts
index 498ee1dc..1825e10d 100644
--- a/src/io/index.ts
+++ b/src/io/index.ts
@@ -25,7 +25,7 @@ export interface Io {
   };
 }
 
-export const IoTag = Context.Tag<Io>();
+export const IoTag = Context.GenericTag<Io>('@services/IoTag');
 
 export const io: Io = {
   cosmiconfig: {
diff --git a/src/io/read-config-file.ts b/src/io/read-config-file.ts
index ab59f21e..14a8691d 100644
--- a/src/io/read-config-file.ts
+++ b/src/io/read-config-file.ts
@@ -12,10 +12,7 @@ const getOptionOfNonEmptyObject = Option.liftPredicate(isNonEmptyObject<any>);
 
 type UnverifiedRcConfig = O.Partial<RcConfig, 'deep'>;
 
-export function readConfigFile(
-  io: Io,
-  configPath?: string,
-): Effect.Effect<never, never, UnverifiedRcConfig> {
+export function readConfigFile(io: Io, configPath?: string): Effect.Effect<UnverifiedRcConfig> {
   return pipe(
     Effect.try(() => io.cosmiconfig.cosmiconfig('syncpack')),
     Effect.flatMap((client) =>
@@ -34,7 +31,7 @@ export function readConfigFile(
  * Look for a .config.syncpack property in the root package.json.
  * @see https://github.com/JamieMason/syncpack/issues/86
  */
-function findConfigInPackageJson(io: Io): Effect.Effect<never, unknown, UnverifiedRcConfig> {
+function findConfigInPackageJson(io: Io): Effect.Effect<UnverifiedRcConfig, unknown> {
   return pipe(
     Effect.Do,
     Effect.bind('rcPath', () => Effect.succeed(join(io.process.cwd(), 'package.json'))),
@@ -53,7 +50,7 @@ function findConfigInPackageJson(io: Io): Effect.Effect<never, unknown, Unverifi
 /** Extract the value from a successful search by cosmiconfig */
 function getValueFromCosmiconfig(
   result: Exclude<CosmiconfigResult, null>,
-): Effect.Effect<never, unknown, UnverifiedRcConfig> {
+): Effect.Effect<UnverifiedRcConfig, unknown> {
   return pipe(
     Effect.succeed(result),
     Effect.tap((result) => Effect.logDebug(`cosmiconfig found ${result.filepath}`)),
diff --git a/src/io/read-file-sync.ts b/src/io/read-file-sync.ts
index 596078ab..4b4fce60 100644
--- a/src/io/read-file-sync.ts
+++ b/src/io/read-file-sync.ts
@@ -6,10 +6,7 @@ export class ReadFileError extends Data.TaggedClass('ReadFileError')<{
   readonly error: string;
 }> {}
 
-export function readFileSync(
-  io: Io,
-  filePath: string,
-): Effect.Effect<never, ReadFileError, string> {
+export function readFileSync(io: Io, filePath: string): Effect.Effect<string, ReadFileError> {
   return Effect.try({
     try: () => io.fs.readFileSync(filePath, { encoding: 'utf8' }),
     catch: (err) => new ReadFileError({ filePath, error: String(err) }),
diff --git a/src/io/read-json-file-sync.ts b/src/io/read-json-file-sync.ts
index 76ab3360..a64ff05b 100644
--- a/src/io/read-json-file-sync.ts
+++ b/src/io/read-json-file-sync.ts
@@ -26,7 +26,7 @@ export class JsonFile<T> extends Data.TaggedClass('JsonFile')<{
 export function readJsonFileSync<T>(
   io: Io,
   filePath: string,
-): Effect.Effect<never, ReadFileError | JsonParseError, JsonFile<T>> {
+): Effect.Effect<JsonFile<T>, ReadFileError | JsonParseError> {
   return pipe(
     Effect.Do,
     Effect.bind('json', () => readFileSync(io, filePath)),
diff --git a/src/io/read-yaml-file-sync.ts b/src/io/read-yaml-file-sync.ts
index d8c567d8..3ea0b51a 100644
--- a/src/io/read-yaml-file-sync.ts
+++ b/src/io/read-yaml-file-sync.ts
@@ -9,7 +9,7 @@ class ReadYamlFileError extends Data.TaggedClass('ReadYamlFileError')<{
 export function readYamlFileSync<T = unknown>(
   io: Io,
   filePath: string,
-): Effect.Effect<never, ReadYamlFileError, T> {
+): Effect.Effect<T, ReadYamlFileError> {
   return Effect.try({
     try: () => io.readYamlFile.sync(filePath),
     catch: (err) => new ReadYamlFileError({ filePath, error: String(err) }),
diff --git a/src/io/write-file-sync.ts b/src/io/write-file-sync.ts
index b9d919b0..8632cc66 100644
--- a/src/io/write-file-sync.ts
+++ b/src/io/write-file-sync.ts
@@ -10,7 +10,7 @@ export class WriteFileError extends Data.TaggedClass('WriteFileError')<{
 export function writeFileSync(
   filePath: string,
   contents: string,
-): Effect.Effect<Io, WriteFileError, void> {
+): Effect.Effect<void, WriteFileError, Io> {
   return pipe(
     IoTag,
     Effect.flatMap((io) =>
diff --git a/src/io/write-if-changed.ts b/src/io/write-if-changed.ts
index 2902bea4..60e959bd 100644
--- a/src/io/write-if-changed.ts
+++ b/src/io/write-if-changed.ts
@@ -8,7 +8,7 @@ import { toJson } from './to-json.js';
 import type { WriteFileError } from './write-file-sync.js';
 import { writeFileSync } from './write-file-sync.js';
 
-export function writeIfChanged(ctx: Ctx): Effect.Effect<Io, WriteFileError, Ctx> {
+export function writeIfChanged(ctx: Ctx): Effect.Effect<Ctx, WriteFileError, Io> {
   return pipe(
     Effect.all(
       ctx.packageJsonFiles.map((file: PackageJsonFile) =>
diff --git a/src/lib/get.ts b/src/lib/get.ts
index 92d285e4..d6bd1784 100644
--- a/src/lib/get.ts
+++ b/src/lib/get.ts
@@ -10,7 +10,7 @@ export function get<
 >(
   obj: T,
   prop1: P1
-): Either.Either<Error, NonNullable<T>[P1]>;
+): Either.Either<NonNullable<T>[P1], Error>;
 
 // prettier-ignore
 export function get<
@@ -21,7 +21,7 @@ export function get<
   obj: T,
   prop1: P1,
   prop2: P2
-): Either.Either<Error, NonNullable<NonNullable<T>[P1]>[P2]>;
+): Either.Either<NonNullable<NonNullable<T>[P1]>[P2], Error>;
 
 // prettier-ignore
 export function get<
@@ -34,7 +34,7 @@ export function get<
   prop1: P1,
   prop2: P2,
   prop3: P3
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3], Error>;
 
 // prettier-ignore
 export function get<
@@ -49,7 +49,7 @@ export function get<
   prop2: P2,
   prop3: P3,
   prop4: P4
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4], Error>;
 
 // prettier-ignore
 export function get<
@@ -66,7 +66,7 @@ export function get<
   prop3: P3,
   prop4: P4,
   prop5: P5
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5], Error>;
 
 // prettier-ignore
 export function get<
@@ -85,7 +85,7 @@ export function get<
   prop4: P4,
   prop5: P5,
   prop6: P6
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6], Error>;
 
 // prettier-ignore
 export function get<
@@ -106,7 +106,7 @@ export function get<
   prop5: P5,
   prop6: P6,
   prop7: P7
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7], Error>;
 
 // prettier-ignore
 export function get<
@@ -129,7 +129,7 @@ export function get<
   prop6: P6,
   prop7: P7,
   prop8: P8
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8], Error>;
 
 // prettier-ignore
 export function get<
@@ -154,16 +154,16 @@ export function get<
   prop7: P7,
   prop8: P8,
   prop9: P9
-): Either.Either<Error, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>[P9]>;
+): Either.Either<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>[P1]>[P2]>[P3]>[P4]>[P5]>[P6]>[P7]>[P8]>[P9], Error>;
 
-export function get<T>(obj: T, ...props: any[]): Either.Either<Error, unknown>;
+export function get<T>(obj: T, ...props: any[]): Either.Either<unknown, Error>;
 
-export function get(origin: any, ...props: any[]): Either.Either<Error, unknown> {
+export function get(origin: any, ...props: any[]): Either.Either<unknown, Error> {
   return isReadable(origin) ? props.reduce(getChild, origin) : ERR_UNREADABLE_ORIGIN(props, origin);
 }
 
 /** Used internally by get to retrieve a single child property from a parent object. */
-function getChild(parent: unknown, prop: string): unknown | Either.Either<Error, never> {
+function getChild(parent: unknown, prop: string): unknown | Either.Either<never, Error> {
   // quit if any ancestor was already not found
   if (Either.isEither(parent) && Either.isLeft(parent)) return parent;
   // ensure we have a plain value and not an Ok
diff --git a/src/lib/with-logger.ts b/src/lib/with-logger.ts
index 4bec97b3..64df2675 100644
--- a/src/lib/with-logger.ts
+++ b/src/lib/with-logger.ts
@@ -1,7 +1,7 @@
 import chalk from 'chalk-template';
 import { Effect, Logger, LogLevel } from 'effect';
 
-export function withLogger(program: Effect.Effect<never, never, unknown>) {
+export function withLogger(program: Effect.Effect<unknown>) {
   const logger = Logger.make(({ logLevel, message }) => {
     if (logLevel === LogLevel.Info) {
       globalThis.console.info(message);
diff --git a/src/semver-group/create-semver-groups.ts b/src/semver-group/create-semver-groups.ts
index 7673f593..a8a90f01 100644
--- a/src/semver-group/create-semver-groups.ts
+++ b/src/semver-group/create-semver-groups.ts
@@ -13,9 +13,9 @@ import { WithRangeSemverGroup } from './with-range.js';
 
 export function createSemverGroups(
   ctx: Ctx,
-): Effect.Effect<never, SemverGroup.ConfigError, SemverGroup.Any[]> {
+): Effect.Effect<SemverGroup.Any[], SemverGroup.ConfigError> {
   const { rcFile } = ctx.config;
-  const semverGroups: Effect.Effect<never, SemverGroup.ConfigError, SemverGroup.Any>[] = [
+  const semverGroups: Effect.Effect<SemverGroup.Any, SemverGroup.ConfigError>[] = [
     Effect.succeed(new FilteredOutSemverGroup(ctx)),
     Effect.succeed(
       new WithRangeSemverGroup(false, {
diff --git a/src/semver-group/disabled.ts b/src/semver-group/disabled.ts
index 940327b3..d13b06e7 100644
--- a/src/semver-group/disabled.ts
+++ b/src/semver-group/disabled.ts
@@ -28,7 +28,7 @@ export class DisabledSemverGroup extends Data.TaggedClass('Disabled')<{
     return true;
   }
 
-  getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError> {
     return Effect.succeed(specifier);
   }
 
@@ -36,7 +36,7 @@ export class DisabledSemverGroup extends Data.TaggedClass('Disabled')<{
     return Effect.all(this.instances.map((instance) => this.inspect(instance)));
   }
 
-  inspect(instance: Instance): Effect.Effect<never, never, Report.Disabled> {
+  inspect(instance: Instance): Effect.Effect<Report.Disabled> {
     return Effect.succeed(new Report.Disabled(instance));
   }
 }
diff --git a/src/semver-group/filtered-out.ts b/src/semver-group/filtered-out.ts
index d334d147..9ee96e09 100644
--- a/src/semver-group/filtered-out.ts
+++ b/src/semver-group/filtered-out.ts
@@ -35,7 +35,7 @@ export class FilteredOutSemverGroup extends Data.TaggedClass('FilteredOut')<{
     return instance.name.search(new RegExp(this.filter)) === -1;
   }
 
-  getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError> {
     return Effect.succeed(specifier);
   }
 
@@ -43,7 +43,7 @@ export class FilteredOutSemverGroup extends Data.TaggedClass('FilteredOut')<{
     return Effect.all(this.instances.map((instance) => this.inspect(instance)));
   }
 
-  inspect(instance: Instance): Effect.Effect<never, never, Report.FilteredOut> {
+  inspect(instance: Instance): Effect.Effect<Report.FilteredOut> {
     return Effect.succeed(new Report.FilteredOut(instance));
   }
 }
diff --git a/src/semver-group/ignored.ts b/src/semver-group/ignored.ts
index a257c986..b08a7075 100644
--- a/src/semver-group/ignored.ts
+++ b/src/semver-group/ignored.ts
@@ -23,7 +23,7 @@ export class IgnoredSemverGroup extends Data.TaggedClass('Ignored')<{
     return true;
   }
 
-  getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError> {
     return Effect.succeed(specifier);
   }
 
@@ -31,7 +31,7 @@ export class IgnoredSemverGroup extends Data.TaggedClass('Ignored')<{
     return Effect.all(this.instances.map((instance) => this.inspect(instance)));
   }
 
-  inspect(instance: Instance): Effect.Effect<never, never, Report.Ignored> {
+  inspect(instance: Instance): Effect.Effect<Report.Ignored> {
     return Effect.succeed(new Report.Ignored(instance));
   }
 }
diff --git a/src/semver-group/with-range.ts b/src/semver-group/with-range.ts
index 39e32d68..164a54ec 100644
--- a/src/semver-group/with-range.ts
+++ b/src/semver-group/with-range.ts
@@ -26,7 +26,7 @@ export class WithRangeSemverGroup extends Data.TaggedClass('WithRange')<{
     return true;
   }
 
-  getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError> {
     return pipe(
       specifier.getSemver(),
       Effect.map((semver) => setSemverRange(this.config.range, semver)),
@@ -40,11 +40,7 @@ export class WithRangeSemverGroup extends Data.TaggedClass('WithRange')<{
 
   inspect(
     instance: Instance,
-  ): Effect.Effect<
-    never,
-    never,
-    Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid
-  > {
+  ): Effect.Effect<Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid> {
     const current = Specifier.create(instance, instance.rawSpecifier.raw);
     return pipe(
       this.getFixed(current),
diff --git a/src/specifier/alias.ts b/src/specifier/alias.ts
index e82fcc8c..5334ad4b 100644
--- a/src/specifier/alias.ts
+++ b/src/specifier/alias.ts
@@ -14,7 +14,7 @@ export class AliasSpecifier extends BaseSpecifier<T> {
   name = 'alias' as const;
 
   /** Return the version portion if it is valid semver */
-  getSemver(): Effect.Effect<never, NonSemverError, string> {
+  getSemver(): Effect.Effect<string, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
@@ -28,7 +28,7 @@ export class AliasSpecifier extends BaseSpecifier<T> {
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
diff --git a/src/specifier/base.ts b/src/specifier/base.ts
index 612c8d4b..53071077 100644
--- a/src/specifier/base.ts
+++ b/src/specifier/base.ts
@@ -41,7 +41,7 @@ export class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
    * Parse the raw version specifier using
    * https://github.com/npm/npm-package-arg
    */
-  protected parse(): Effect.Effect<never, unknown, T> {
+  protected parse(): Effect.Effect<T, unknown> {
     const name = this.instance.name;
     const raw = this.raw;
     const packageJsonFile = this.instance.packageJsonFile;
@@ -56,15 +56,12 @@ export class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
   }
 
   /** Return the version portion if it is valid semver */
-  getSemver(this: Specifier.Any): Effect.Effect<never, NonSemverError, string> {
+  getSemver(this: Specifier.Any): Effect.Effect<string, NonSemverError> {
     return NonSemverError.asEffect(this);
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(
-    this: Specifier.Any,
-    _version: string,
-  ): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  setSemver(this: Specifier.Any, _version: string): Effect.Effect<Specifier.Any, NonSemverError> {
     return NonSemverError.asEffect(this);
   }
 
diff --git a/src/specifier/exact.ts b/src/specifier/exact.ts
index ad2ef900..c687ae19 100644
--- a/src/specifier/exact.ts
+++ b/src/specifier/exact.ts
@@ -17,7 +17,7 @@ export class ExactSpecifier extends BaseSpecifier<T> {
   name = 'exact' as const;
 
   /** Return the semver version */
-  getSemver(): Effect.Effect<never, NonSemverError, string> {
+  getSemver(): Effect.Effect<string, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
@@ -26,7 +26,7 @@ export class ExactSpecifier extends BaseSpecifier<T> {
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(version: string): Effect.Effect<never, never, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any> {
     return Effect.succeed(Specifier.create(this.instance, version));
   }
 }
diff --git a/src/specifier/hosted-git.ts b/src/specifier/hosted-git.ts
index f8e69544..679ef7b4 100644
--- a/src/specifier/hosted-git.ts
+++ b/src/specifier/hosted-git.ts
@@ -13,7 +13,7 @@ export class HostedGitSpecifier extends BaseSpecifier<HostedGitResult> {
   name = 'hosted-git' as const;
 
   /** Return the git tag if it is valid semver */
-  getSemver(): Effect.Effect<never, NonSemverError, string> {
+  getSemver(): Effect.Effect<string, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
@@ -25,7 +25,7 @@ export class HostedGitSpecifier extends BaseSpecifier<HostedGitResult> {
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
diff --git a/src/specifier/latest.ts b/src/specifier/latest.ts
index cc84e681..1792ab29 100644
--- a/src/specifier/latest.ts
+++ b/src/specifier/latest.ts
@@ -16,7 +16,7 @@ export class LatestSpecifier extends BaseSpecifier<T> {
   name = 'latest' as const;
 
   /** Return the semver version including the range */
-  getSemver(): Effect.Effect<never, NonSemverError, string> {
+  getSemver(): Effect.Effect<string, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
@@ -25,7 +25,7 @@ export class LatestSpecifier extends BaseSpecifier<T> {
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(version: string): Effect.Effect<never, never, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any> {
     return Effect.succeed(Specifier.create(this.instance, version));
   }
 }
diff --git a/src/specifier/lib/non-semver-error.ts b/src/specifier/lib/non-semver-error.ts
index 65c28836..18986eaa 100644
--- a/src/specifier/lib/non-semver-error.ts
+++ b/src/specifier/lib/non-semver-error.ts
@@ -4,7 +4,7 @@ import type { Specifier } from '../index.js';
 export class NonSemverError extends Data.TaggedClass('NonSemverError')<{
   specifier: Specifier.Any;
 }> {
-  static asEffect<T>(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, T> {
+  static asEffect<T>(specifier: Specifier.Any): Effect.Effect<T, NonSemverError> {
     return Effect.fail(new NonSemverError({ specifier }));
   }
 }
diff --git a/src/specifier/range.ts b/src/specifier/range.ts
index 2f06b5ae..00af9499 100644
--- a/src/specifier/range.ts
+++ b/src/specifier/range.ts
@@ -16,7 +16,7 @@ export class RangeSpecifier extends BaseSpecifier<T> {
   name = 'range' as const;
 
   /** Return the semver version including the range */
-  getSemver(): Effect.Effect<never, NonSemverError, string> {
+  getSemver(): Effect.Effect<string, NonSemverError> {
     return pipe(
       this.parse(),
       Effect.mapError(() => new NonSemverError({ specifier: this })),
@@ -25,7 +25,7 @@ export class RangeSpecifier extends BaseSpecifier<T> {
   }
 
   /** Get a new `Specifier` from the given semver version applied to this one */
-  setSemver(version: string): Effect.Effect<never, never, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any> {
     return Effect.succeed(Specifier.create(this.instance, version));
   }
 }
diff --git a/src/specifier/workspace-protocol.ts b/src/specifier/workspace-protocol.ts
index 0f6b9733..528d2a06 100644
--- a/src/specifier/workspace-protocol.ts
+++ b/src/specifier/workspace-protocol.ts
@@ -16,7 +16,7 @@ export class WorkspaceProtocolSpecifier extends BaseSpecifier<WorkspaceProtocolR
    * with tools which expect values which conform to the spec. This value is
    * used only when sorting versions.
    */
-  getSemverEquivalent(ctx: Ctx): Effect.Effect<never, never, string> {
+  getSemverEquivalent(ctx: Ctx): Effect.Effect<string> {
     if (this.raw === 'workspace:*') {
       return Effect.succeed('*');
     }
@@ -30,11 +30,11 @@ export class WorkspaceProtocolSpecifier extends BaseSpecifier<WorkspaceProtocolR
   }
 
   // @TODO: this name is inaccurate, check how it is used and change logic or rename
-  getSemver(): Effect.Effect<never, never, string> {
+  getSemver(): Effect.Effect<string> {
     return Effect.succeed(this.raw);
   }
 
-  setSemver(version: string): Effect.Effect<never, never, Specifier.Any> {
+  setSemver(version: string): Effect.Effect<Specifier.Any> {
     return Effect.succeed(Specifier.create(this.instance, version));
   }
 }
diff --git a/src/strategy/lib/get-non-empty-string-prop.ts b/src/strategy/lib/get-non-empty-string-prop.ts
index a98d7f4e..49ca6e6a 100644
--- a/src/strategy/lib/get-non-empty-string-prop.ts
+++ b/src/strategy/lib/get-non-empty-string-prop.ts
@@ -8,7 +8,7 @@ const getOptionOfNonEmptyString = Option.liftPredicate(isNonEmptyString);
 export function getNonEmptyStringProp(
   propPath: string,
   file: PackageJsonFile,
-): Effect.Effect<never, unknown, string> {
+): Effect.Effect<string, unknown> {
   return pipe(
     get(file.jsonFile.contents, ...propPath.split('.')),
     Effect.flatMap((value) => getOptionOfNonEmptyString(value)),
diff --git a/src/strategy/name-and-version-props.ts b/src/strategy/name-and-version-props.ts
index 7787029f..8b272d6f 100644
--- a/src/strategy/name-and-version-props.ts
+++ b/src/strategy/name-and-version-props.ts
@@ -20,7 +20,7 @@ export class NameAndVersionPropsStrategy {
     this.namePath = namePath;
   }
 
-  read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]> {
+  read(file: PackageJsonFile): Effect.Effect<[string, string][]> {
     return pipe(
       Effect.Do,
       // get the name prop
@@ -59,7 +59,7 @@ export class NameAndVersionPropsStrategy {
   write(
     file: PackageJsonFile,
     [, version]: [string, string | Delete],
-  ): Effect.Effect<never, never, PackageJsonFile> {
+  ): Effect.Effect<PackageJsonFile> {
     const path = this.path;
     const { contents } = file.jsonFile;
     const isNestedPath = path.includes('.');
diff --git a/src/strategy/named-version-string.ts b/src/strategy/named-version-string.ts
index 284e1b88..c2ed4def 100644
--- a/src/strategy/named-version-string.ts
+++ b/src/strategy/named-version-string.ts
@@ -20,7 +20,7 @@ export class NamedVersionStringStrategy {
     this.path = path;
   }
 
-  read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]> {
+  read(file: PackageJsonFile): Effect.Effect<[string, string][]> {
     const path = this.path;
     return pipe(
       // get version prop
@@ -46,7 +46,7 @@ export class NamedVersionStringStrategy {
   write(
     file: PackageJsonFile,
     [name, version]: [string, string | Delete],
-  ): Effect.Effect<never, never, PackageJsonFile> {
+  ): Effect.Effect<PackageJsonFile> {
     const { contents } = file.jsonFile;
     const isNestedPath = this.path.includes('.');
     const nextValue = version === DELETE ? undefined : `${name}@${version}`;
diff --git a/src/strategy/unnamed-version-string.ts b/src/strategy/unnamed-version-string.ts
index 9c3f2827..1e22f301 100644
--- a/src/strategy/unnamed-version-string.ts
+++ b/src/strategy/unnamed-version-string.ts
@@ -18,7 +18,7 @@ export class UnnamedVersionStringStrategy {
     this.path = path;
   }
 
-  read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]> {
+  read(file: PackageJsonFile): Effect.Effect<[string, string][]> {
     return pipe(
       // get version prop
       getNonEmptyStringProp(this.path, file),
@@ -40,7 +40,7 @@ export class UnnamedVersionStringStrategy {
   write(
     file: PackageJsonFile,
     [, version]: [string, string | Delete],
-  ): Effect.Effect<never, never, PackageJsonFile> {
+  ): Effect.Effect<PackageJsonFile> {
     const { contents } = file.jsonFile;
     const isNestedPath = this.path.includes('.');
     const nextValue = version === DELETE ? undefined : version;
diff --git a/src/strategy/versions-by-name.ts b/src/strategy/versions-by-name.ts
index 5118d532..2f9a3eec 100644
--- a/src/strategy/versions-by-name.ts
+++ b/src/strategy/versions-by-name.ts
@@ -17,7 +17,7 @@ export class VersionsByNameStrategy {
     this.path = path;
   }
 
-  read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]> {
+  read(file: PackageJsonFile): Effect.Effect<[string, string][]> {
     return pipe(
       get(file.jsonFile.contents, ...this.path.split('.')),
       Effect.flatMap((value) => getOptionOfNonEmptyObject(value)),
@@ -35,7 +35,7 @@ export class VersionsByNameStrategy {
   write(
     file: PackageJsonFile,
     [name, version]: [string, string | Delete],
-  ): Effect.Effect<never, never, PackageJsonFile> {
+  ): Effect.Effect<PackageJsonFile> {
     const nextValue = version === DELETE ? undefined : version;
     return pipe(
       get(file.jsonFile.contents, ...this.path.split('.')),
diff --git a/src/version-group/banned.ts b/src/version-group/banned.ts
index 783abcc2..32bb1c58 100644
--- a/src/version-group/banned.ts
+++ b/src/version-group/banned.ts
@@ -23,7 +23,7 @@ export class BannedVersionGroup extends Data.TaggedClass('Banned')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.succeed(
       Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
         name,
diff --git a/src/version-group/create-version-groups.ts b/src/version-group/create-version-groups.ts
index a7d25fc5..bd1ea45c 100644
--- a/src/version-group/create-version-groups.ts
+++ b/src/version-group/create-version-groups.ts
@@ -15,9 +15,9 @@ import { StandardVersionGroup } from './standard.js';
 
 export function createVersionGroups(
   ctx: Ctx,
-): Effect.Effect<never, VersionGroup.ConfigError, VersionGroup.Any[]> {
+): Effect.Effect<VersionGroup.Any[], VersionGroup.ConfigError> {
   const { rcFile } = ctx.config;
-  const versionGroups: Effect.Effect<never, VersionGroup.ConfigError, VersionGroup.Any>[] = [
+  const versionGroups: Effect.Effect<VersionGroup.Any, VersionGroup.ConfigError>[] = [
     Effect.succeed(new FilteredOutVersionGroup(ctx)),
   ];
 
diff --git a/src/version-group/filtered-out.ts b/src/version-group/filtered-out.ts
index df7ccf24..192e63df 100644
--- a/src/version-group/filtered-out.ts
+++ b/src/version-group/filtered-out.ts
@@ -30,7 +30,7 @@ export class FilteredOutVersionGroup extends Data.TaggedClass('FilteredOut')<{
     return instance.name.search(new RegExp(this.filter)) === -1;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.succeed(
       Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
         name,
diff --git a/src/version-group/ignored.ts b/src/version-group/ignored.ts
index d4a791f5..788c77ab 100644
--- a/src/version-group/ignored.ts
+++ b/src/version-group/ignored.ts
@@ -21,7 +21,7 @@ export class IgnoredVersionGroup extends Data.TaggedClass('Ignored')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.succeed(
       Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
         name,
diff --git a/src/version-group/lib/get-preferred-version.ts b/src/version-group/lib/get-preferred-version.ts
index c8089ac1..d351bdd7 100644
--- a/src/version-group/lib/get-preferred-version.ts
+++ b/src/version-group/lib/get-preferred-version.ts
@@ -10,7 +10,7 @@ import { getRangeScore } from './get-range-score.js';
 export function getPreferredVersion(
   preferVersion: VersionGroupConfig.Standard['preferVersion'],
   specifiers: Specifier.Any[],
-): Effect.Effect<never, NonSemverError, Specifier.Any> {
+): Effect.Effect<Specifier.Any, NonSemverError> {
   return pipe(
     // every instance must have a semver version
     Effect.all(
diff --git a/src/version-group/pinned.ts b/src/version-group/pinned.ts
index 0257d373..842aad84 100644
--- a/src/version-group/pinned.ts
+++ b/src/version-group/pinned.ts
@@ -22,7 +22,7 @@ export class PinnedVersionGroup extends Data.TaggedClass('Pinned')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.all(
       Object.entries(groupBy('name', this.instances)).map(([name, instances]) =>
         pipe(
diff --git a/src/version-group/same-range.ts b/src/version-group/same-range.ts
index 309f37c4..4ef2176b 100644
--- a/src/version-group/same-range.ts
+++ b/src/version-group/same-range.ts
@@ -28,7 +28,7 @@ export class SameRangeVersionGroup extends Data.TaggedClass('SameRange')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.all(
       Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) =>
         pipe(
diff --git a/src/version-group/snapped-to.ts b/src/version-group/snapped-to.ts
index b9b038d8..39599a79 100644
--- a/src/version-group/snapped-to.ts
+++ b/src/version-group/snapped-to.ts
@@ -22,7 +22,7 @@ export class SnappedToVersionGroup extends Data.TaggedClass('SnappedTo')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.all(
       Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) =>
         pipe(
@@ -118,7 +118,7 @@ function findSnappedToInstance(
   name: string,
   snapTo: string[],
   instances: Instance[],
-): Effect.Effect<never, string, Instance> {
+): Effect.Effect<Instance, string> {
   for (const instance of instances) {
     if (snapTo.includes(instance.pkgName) && instance.rawSpecifier.raw) {
       return pipe(
diff --git a/src/version-group/standard.ts b/src/version-group/standard.ts
index 9ccf6734..28a9777a 100644
--- a/src/version-group/standard.ts
+++ b/src/version-group/standard.ts
@@ -26,7 +26,7 @@ export class StandardVersionGroup extends Data.TaggedClass('Standard')<{
     return true;
   }
 
-  inspectAll(): Effect.Effect<never, never, Report.Version.Group[]> {
+  inspectAll(): Effect.Effect<Report.Version.Group[]> {
     return Effect.all(
       Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => {
         const localInstance = getLocalInstance(instances);