syncpack 12.3.0 → 12.3.1

package/dist/bin-set-semver-ranges/set-semver-ranges.js

@@ -1,28 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSemverRanges = void 0;
-const effect_1 = require("effect");
-const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
-const fix_mismatches_1 = require("../bin-fix-mismatches/fix-mismatches");
-const lint_semver_ranges_1 = require("../bin-lint-semver-ranges/lint-semver-ranges");
-const list_mismatches_1 = require("../bin-list-mismatches/list-mismatches");
-const tag_1 = require("../config/tag");
-const default_error_handlers_1 = require("../error-handlers/default-error-handlers");
-const get_context_1 = require("../get-context");
-const get_instances_1 = require("../get-instances");
-const io_1 = require("../io");
-const exit_if_invalid_1 = require("../io/exit-if-invalid");
-const write_if_changed_1 = require("../io/write-if-changed");
-const with_logger_1 = require("../lib/with-logger");
-function setSemverRanges({ io, cli, errorHandlers = default_error_handlers_1.defaultErrorHandlers }) {
-    return (0, effect_1.pipe)((0, get_context_1.getContext)({ io, cli, errorHandlers }), effect_1.Effect.flatMap((ctx) => (0, effect_1.pipe)(effect_1.Effect.gen(function* ($) {
+import { Context, Effect, flow, pipe } from 'effect';
+import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
+import { fixMismatch, logAlreadyValidSize, logFixedSize, logUnfixableSize, } from '../bin-fix-mismatches/fix-mismatches.js';
+import { logSemverGroupsDisabledWarning } from '../bin-lint-semver-ranges/lint-semver-ranges.js';
+import { logUnsupportedMismatch } from '../bin-list-mismatches/list-mismatches.js';
+import { CliConfigTag } from '../config/tag.js';
+import { defaultErrorHandlers } from '../error-handlers/default-error-handlers.js';
+import { getContext } from '../get-context/index.js';
+import { getInstances } from '../get-instances/index.js';
+import { exitIfInvalid } from '../io/exit-if-invalid.js';
+import { IoTag } from '../io/index.js';
+import { writeIfChanged } from '../io/write-if-changed.js';
+import { withLogger } from '../lib/with-logger.js';
+export function setSemverRanges({ io, cli, errorHandlers = defaultErrorHandlers }) {
+    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap((ctx) => pipe(Effect.gen(function* ($) {
         // no semver groups have been configured, they are disabled by default
-        if (!(0, is_non_empty_array_1.isNonEmptyArray)(ctx.config.rcFile.semverGroups)) {
+        if (!isNonEmptyArray(ctx.config.rcFile.semverGroups)) {
             ctx.isInvalid = true;
-            yield* $((0, lint_semver_ranges_1.logSemverGroupsDisabledWarning)());
+            yield* $(logSemverGroupsDisabledWarning());
             return ctx;
         }
-        const { semverGroups } = yield* $((0, get_instances_1.getInstances)(ctx, io, errorHandlers));
+        const { semverGroups } = yield* $(getInstances(ctx, io, errorHandlers));
         let fixedCount = 0;
         let unfixableCount = 0;
         let validCount = 0;
@@ -32,11 +29,11 @@ function setSemverRanges({ io, cli, errorHandlers = default_error_handlers_1.def
                     const report = yield* $(group.inspect(instance));
                     const _tag = report._tag;
                     if (_tag === 'SemverRangeMismatch') {
-                        yield* $((0, fix_mismatches_1.fixMismatch)(report));
+                        yield* $(fixMismatch(report));
                         fixedCount++;
                     }
                     else if (_tag === 'UnsupportedMismatch') {
-                        yield* $((0, list_mismatches_1.logUnsupportedMismatch)(report));
+                        yield* $(logUnsupportedMismatch(report));
                         unfixableCount++;
                     }
                     else {
@@ -46,17 +43,16 @@ function setSemverRanges({ io, cli, errorHandlers = default_error_handlers_1.def
             }
         }
         if (validCount)
-            yield* $((0, fix_mismatches_1.logAlreadyValidSize)(validCount));
+            yield* $(logAlreadyValidSize(validCount));
         if (fixedCount)
-            yield* $((0, fix_mismatches_1.logFixedSize)(fixedCount));
+            yield* $(logFixedSize(fixedCount));
         if (unfixableCount)
-            yield* $((0, fix_mismatches_1.logUnfixableSize)(unfixableCount));
+            yield* $(logUnfixableSize(unfixableCount));
         return ctx;
-    }), effect_1.Effect.flatMap(write_if_changed_1.writeIfChanged), effect_1.Effect.catchTags({
-        WriteFileError: (0, effect_1.flow)(errorHandlers.WriteFileError, effect_1.Effect.map(() => {
+    }), Effect.flatMap(writeIfChanged), Effect.catchTags({
+        WriteFileError: flow(errorHandlers.WriteFileError, Effect.map(() => {
             ctx.isInvalid = true;
             return ctx;
         })),
-    }), effect_1.Effect.flatMap(exit_if_invalid_1.exitIfInvalid))), effect_1.Effect.provide((0, effect_1.pipe)(effect_1.Context.empty(), effect_1.Context.add(tag_1.CliConfigTag, cli), effect_1.Context.add(io_1.IoTag, io))), with_logger_1.withLogger);
+    }), Effect.flatMap(exitIfInvalid))), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
 }
-exports.setSemverRanges = setSemverRanges;

package/dist/bin-update/effects.d.ts

@@ -1,8 +1,8 @@
-import { Data, Effect } from 'effect';
-import type { Instance } from '../get-instances/instance';
-declare const Releases_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> & {
+import { Effect } from 'effect';
+import type { Instance } from '../get-instances/instance.js';
+declare const Releases_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "Releases";
-}>;
+};
 /** full release history from the npm registry for a given package */
 declare class Releases extends Releases_base<{
     instance: Instance;
@@ -13,40 +13,40 @@ declare class Releases extends Releases_base<{
     repoUrl: string | undefined;
 }> {
 }
-declare const PromptCancelled_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> & {
+declare const PromptCancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "PromptCancelled";
-}>;
+};
 declare class PromptCancelled extends PromptCancelled_base<{
     name: string;
 }> {
 }
-declare const HttpError_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> & {
+declare const HttpError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "HttpError";
-}>;
+};
 declare class HttpError extends HttpError_base<{
     error: string;
 }> {
 }
-declare const NpmRegistryError_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> & {
+declare const NpmRegistryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "NpmRegistryError";
-}>;
+};
 declare class NpmRegistryError extends NpmRegistryError_base<{
     error: string;
 }> {
 }
 export declare const updateEffects: {
-    onFetchAllStart(): Effect.Effect<never, never, void>;
-    onFetchStart(instance: Instance, totalCount: number): Effect.Effect<never, never, void>;
-    onFetchEnd(instance: Instance, versions?: Releases['versions']): Effect.Effect<never, never, void>;
+    onFetchAllStart(): Effect.Effect<void, never, never>;
+    onFetchStart(instance: Instance, totalCount: number): Effect.Effect<void, never, never>;
+    onFetchEnd(instance: Instance, versions?: Releases['versions']): Effect.Effect<void, never, never>;
     /** After checking the registry, store this instance known to be up to date */
-    onUpToDate(instance: Instance): Effect.Effect<never, never, void>;
+    onUpToDate(instance: Instance): Effect.Effect<void, never, never>;
     /** After checking the registry, store this instance known to have newer versions available */
-    onOutdated(instance: Instance, latest: string): Effect.Effect<never, never, void>;
+    onOutdated(instance: Instance, latest: string): Effect.Effect<void, never, never>;
     /** As the last request completes, remove the progress information */
-    onFetchAllEnd(): Effect.Effect<never, never, void>;
+    onFetchAllEnd(): Effect.Effect<void, never, never>;
     /** 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>;
     /** 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>;
 };
 export {};

package/dist/bin-update/effects.js

@@ -1,57 +1,28 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateEffects = void 0;
-const Schema = __importStar(require("@effect/schema/Schema"));
-const chalk_1 = __importDefault(require("chalk"));
-const effect_1 = require("effect");
-const https_1 = __importDefault(require("https"));
-const ora_1 = __importDefault(require("ora"));
-const os_1 = require("os");
-const prompts_1 = __importDefault(require("prompts"));
-const semver_1 = require("semver");
-const gtr_1 = __importDefault(require("semver/ranges/gtr"));
-const is_array_1 = require("tightrope/guard/is-array");
-const is_empty_object_1 = require("tightrope/guard/is-empty-object");
-const constants_1 = require("../constants");
-const format_repository_url_1 = require("../lib/format-repository-url");
-const ring_buffer_1 = require("../lib/ring-buffer");
-const set_semver_range_1 = require("../lib/set-semver-range");
-const specifier_1 = require("../specifier");
+import * as Schema from '@effect/schema/Schema';
+import chalk from 'chalk-template';
+import { Data, Effect, identity, pipe } from 'effect';
+import https from 'https';
+import ora from 'ora';
+import { EOL } from 'os';
+import prompts from 'prompts';
+import { diff } from 'semver';
+import gtr from 'semver/ranges/gtr.js';
+import { isArray } from 'tightrope/guard/is-array.js';
+import { isEmptyObject } from 'tightrope/guard/is-empty-object.js';
+import { ICON } from '../constants.js';
+import { formatRepositoryUrl } from '../lib/format-repository-url.js';
+import { RingBuffer } from '../lib/ring-buffer.js';
+import { setSemverRange } from '../lib/set-semver-range.js';
+import { Specifier } from '../specifier/index.js';
 /** full release history from the npm registry for a given package */
-class Releases extends effect_1.Data.TaggedClass('Releases') {
+class Releases extends Data.TaggedClass('Releases') {
 }
 // https://github.com/terkelg/prompts?tab=readme-ov-file#prompts
-class PromptCancelled extends effect_1.Data.TaggedClass('PromptCancelled') {
+class PromptCancelled extends Data.TaggedClass('PromptCancelled') {
 }
-class HttpError extends effect_1.Data.TaggedClass('HttpError') {
+class HttpError extends Data.TaggedClass('HttpError') {
 }
-class NpmRegistryError extends effect_1.Data.TaggedClass('NpmRegistryError') {
+class NpmRegistryError extends Data.TaggedClass('NpmRegistryError') {
 }
 /** the API client for the terminal spinner */
 let spinner = null;
@@ -62,12 +33,12 @@ let outdatedCount = 0;
 /** names of instances currently being fetched from npm */
 const inFlight = new Set();
 /** names of instances most recently finished being fetched from npm */
-const mostRecent = new ring_buffer_1.RingBuffer(5);
+const mostRecent = new RingBuffer(5);
 /** page size when prompting */
 const optionsPerPage = 50;
 /** instance names in `inFlight` are formatted for display */
 function format(instance) {
-    return (0, chalk_1.default) `{gray ${instance.name}}`;
+    return chalk `{gray ${instance.name}}`;
 }
 /** we need to remove colours when sorting loading status output */
 function stripAnsi(str) {
@@ -75,49 +46,49 @@ function stripAnsi(str) {
     const ansiChars = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
     return str.replace(ansiChars, '');
 }
-exports.updateEffects = {
+export const updateEffects = {
     onFetchAllStart() {
         if (!spinner)
-            spinner = (0, ora_1.default)().start();
+            spinner = ora().start();
         fetchedCount = 0;
-        return effect_1.Effect.unit;
+        return Effect.void;
     },
     onFetchStart(instance, totalCount) {
         inFlight.add(format(instance));
         fetchedCount++;
         if (spinner) {
-            const indent = `${os_1.EOL}  `;
+            const indent = `${EOL}  `;
             const progress = new Set([...mostRecent.filter(Boolean), ...inFlight.values()]);
             const sortedProgress = Array.from(progress).sort((a, b) => stripAnsi(a).localeCompare(stripAnsi(b)));
             const suffixText = sortedProgress.join(indent);
-            spinner.text = (0, chalk_1.default) `${outdatedCount} updates found in ${fetchedCount}/${totalCount} dependencies${indent}${suffixText}`;
+            spinner.text = chalk `${outdatedCount} updates found in ${fetchedCount}/${totalCount} dependencies${indent}${suffixText}`;
         }
-        return effect_1.Effect.unit;
+        return Effect.void;
     },
     onFetchEnd(instance, versions) {
         inFlight.delete(format(instance));
         const latest = versions?.latest;
         if (latest) {
-            if ((0, gtr_1.default)(latest, String(instance.rawSpecifier.raw), true)) {
+            if (gtr(latest, String(instance.rawSpecifier.raw), true)) {
                 outdatedCount++;
-                mostRecent.push((0, chalk_1.default) `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${constants_1.ICON.rightArrow}} {green ${latest}}`);
+                mostRecent.push(chalk `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${ICON.rightArrow}} {green ${latest}}`);
             }
             else {
-                mostRecent.push((0, chalk_1.default) `{green ${instance.name}}`);
+                mostRecent.push(chalk `{green ${instance.name}}`);
             }
         }
-        return effect_1.Effect.unit;
+        return Effect.void;
     },
     /** After checking the registry, store this instance known to be up to date */
     onUpToDate(instance) {
-        mostRecent.push((0, chalk_1.default) `{green ${instance.name}}`);
-        return effect_1.Effect.unit;
+        mostRecent.push(chalk `{green ${instance.name}}`);
+        return Effect.void;
     },
     /** After checking the registry, store this instance known to have newer versions available */
     onOutdated(instance, latest) {
         outdatedCount++;
-        mostRecent.push((0, chalk_1.default) `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${constants_1.ICON.rightArrow}} {green ${latest}}`);
-        return effect_1.Effect.unit;
+        mostRecent.push(chalk `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${ICON.rightArrow}} {green ${latest}}`);
+        return Effect.void;
     },
     /** As the last request completes, remove the progress information */
     onFetchAllEnd() {
@@ -125,20 +96,20 @@ exports.updateEffects = {
             spinner.stop();
         spinner = null;
         fetchedCount = 0;
-        return effect_1.Effect.unit;
+        return Effect.void;
     },
     /** Fetch available versions for a given package from the npm registry */
     fetchLatestVersions(instance) {
-        return (0, effect_1.pipe)(fetchJson(`https://registry.npmjs.org/${instance.name}`), 
+        return pipe(fetchJson(`https://registry.npmjs.org/${instance.name}`), 
         // parse and validate the specific data we expect
-        effect_1.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),
-            'repository': Schema.optional(Schema.union(Schema.string, Schema.struct({ url: Schema.optional(Schema.string) }))),
+        Effect.flatMap(Schema.decodeUnknownEither(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) }))),
         }))), 
         // transform it into something more appropriate
-        effect_1.Effect.map((struct) => {
+        Effect.map((struct) => {
             const rawRepoUrl = typeof struct.repository === 'object' ? struct.repository.url : struct.repository;
             return new Releases({
                 instance,
@@ -146,42 +117,42 @@ exports.updateEffects = {
                     all: Object.keys(struct.time).filter((key) => key !== 'modified' && key !== 'created'),
                     latest: struct['dist-tags'].latest,
                 },
-                repoUrl: (0, format_repository_url_1.formatRepositoryUrl)(rawRepoUrl),
+                repoUrl: formatRepositoryUrl(rawRepoUrl),
             });
         }), 
         // hide ParseErrors and just treat them as another kind of NpmRegistryError
-        effect_1.Effect.catchTags({
-            ParseError: () => effect_1.Effect.fail(new NpmRegistryError({ error: `Invalid response for ${instance.name}` })),
+        Effect.catchTags({
+            ParseError: () => Effect.fail(new NpmRegistryError({ error: `Invalid response for ${instance.name}` })),
         }));
     },
     /** Given responses from npm, ask the user which they want */
     promptForUpdates(outdated) {
-        return (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('releasesByType', () => groupByReleaseType(outdated)), 
+        return pipe(Effect.Do, Effect.bind('releasesByType', () => groupByReleaseType(outdated)), 
         // Create choices to ask if they want major, minor, patch etc
-        effect_1.Effect.bind('releaseTypeQuestions', ({ releasesByType }) => effect_1.Effect.succeed(Object.keys(releasesByType)
+        Effect.bind('releaseTypeQuestions', ({ releasesByType }) => Effect.succeed(Object.keys(releasesByType)
             .filter((type) => releasesByType[type].length > 0)
             .map((type) => ({
-            title: (0, chalk_1.default) `${releasesByType[type].length} ${type}`,
+            title: chalk `${releasesByType[type].length} ${type}`,
             selected: true,
             value: type,
         })))), 
         // Ask which release types (major, minor, patch etc) they want
-        effect_1.Effect.bind('releaseTypeAnswers', ({ releaseTypeQuestions }) => releaseTypeQuestions.length > 0
-            ? (0, effect_1.pipe)(effect_1.Effect.tryPromise({
-                try: () => (0, prompts_1.default)({
+        Effect.bind('releaseTypeAnswers', ({ releaseTypeQuestions }) => releaseTypeQuestions.length > 0
+            ? pipe(Effect.tryPromise({
+                try: () => prompts({
                     name: 'releaseTypeAnswers',
                     type: 'multiselect',
                     instructions: true,
                     message: `${outdated.length} updates are available`,
                     choices: releaseTypeQuestions,
                 }).then((res) => res?.releaseTypeAnswers || []),
-                catch: effect_1.identity,
-            }), effect_1.Effect.catchAll(() => (0, effect_1.pipe)(effect_1.Effect.logError('Error when prompting for releaseTypeAnswers'), effect_1.Effect.map(() => []))))
-            : effect_1.Effect.succeed([])), 
+                catch: identity,
+            }), Effect.catchAll(() => pipe(Effect.logError('Error when prompting for releaseTypeAnswers'), Effect.map(() => []))))
+            : Effect.succeed([])), 
         // For each chosen release type, list the available updates to choose from
-        effect_1.Effect.bind('prepatchAnswers', (doState) => promptForReleaseType('prepatch', doState)), effect_1.Effect.bind('patchAnswers', (doState) => promptForReleaseType('patch', doState)), effect_1.Effect.bind('preminorAnswers', (doState) => promptForReleaseType('preminor', doState)), effect_1.Effect.bind('minorAnswers', (doState) => promptForReleaseType('minor', doState)), effect_1.Effect.bind('premajorAnswers', (doState) => promptForReleaseType('premajor', doState)), effect_1.Effect.bind('majorAnswers', (doState) => promptForReleaseType('major', doState)), effect_1.Effect.bind('prereleaseAnswers', (doState) => promptForReleaseType('prerelease', doState)), 
+        Effect.bind('prepatchAnswers', (doState) => promptForReleaseType('prepatch', doState)), Effect.bind('patchAnswers', (doState) => promptForReleaseType('patch', doState)), Effect.bind('preminorAnswers', (doState) => promptForReleaseType('preminor', doState)), Effect.bind('minorAnswers', (doState) => promptForReleaseType('minor', doState)), Effect.bind('premajorAnswers', (doState) => promptForReleaseType('premajor', doState)), Effect.bind('majorAnswers', (doState) => promptForReleaseType('major', doState)), Effect.bind('prereleaseAnswers', (doState) => promptForReleaseType('prerelease', doState)), 
         /** Apply every update to the package.json files */
-        effect_1.Effect.flatMap((doState) => (0, effect_1.pipe)([
+        Effect.flatMap((doState) => pipe([
             ...doState.prepatchAnswers,
             ...doState.patchAnswers,
             ...doState.preminorAnswers,
@@ -189,7 +160,7 @@ exports.updateEffects = {
             ...doState.premajorAnswers,
             ...doState.majorAnswers,
             ...doState.prereleaseAnswers,
-        ], effect_1.Effect.forEach(({ instance, versions }) => (0, effect_1.pipe)(instance.semverGroup.getFixed(specifier_1.Specifier.create(instance, versions.latest)), effect_1.Effect.flatMap((latestWithRange) => instance.write(latestWithRange.raw)), effect_1.Effect.catchTag('NonSemverError', effect_1.Effect.logError))), effect_1.Effect.flatMap(() => effect_1.Effect.unit))));
+        ], Effect.forEach((release) => pipe(release.instance.versionGroup.instances, Effect.forEach((instance) => pipe(instance.semverGroup.getFixed(Specifier.create(instance, release.versions.latest)), Effect.flatMap((latestWithRange) => instance.write(latestWithRange.raw)), Effect.catchTag('NonSemverError', Effect.logError))))), Effect.flatMap(() => Effect.void))));
     },
 };
 function promptForReleaseType(releaseType, doState) {
@@ -197,8 +168,8 @@ function promptForReleaseType(releaseType, doState) {
     const prop = `${releaseType}Answers`;
     const releases = releasesByType[releaseType];
     return releaseTypeAnswers.includes(releaseType)
-        ? (0, effect_1.pipe)(effect_1.Effect.tryPromise({
-            try: () => (0, prompts_1.default)({
+        ? pipe(Effect.tryPromise({
+            try: () => prompts({
                 name: prop,
                 type: 'multiselect',
                 instructions: false,
@@ -212,33 +183,33 @@ function promptForReleaseType(releaseType, doState) {
                         updateable.versions.latest.length;
                     const spacing = Array.from({ length: spacingValue }).fill(' ').join('');
                     const repoUrl = updateable.repoUrl
-                        ? (0, chalk_1.default) `${spacing} {white - ${updateable.repoUrl}}`
+                        ? chalk `${spacing} {white - ${updateable.repoUrl}}`
                         : '';
                     return {
-                        title: (0, chalk_1.default) `${updateable.instance.name} {gray ${updateable.instance.rawSpecifier.raw} ${constants_1.ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
+                        title: chalk `${updateable.instance.name} {gray ${updateable.instance.rawSpecifier.raw} ${ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
                         selected: true,
                         value: updateable,
                     };
                 }),
             }),
-            catch: effect_1.identity,
+            catch: identity,
         }), 
         // Paper over errors in terkelg/prompts for now
-        effect_1.Effect.catchAll(() => (0, effect_1.pipe)(effect_1.Effect.logError(`terkelg/prompts errored while prompting for ${prop}`), effect_1.Effect.map(() => ({ [prop]: [] })))), 
+        Effect.catchAll(() => pipe(Effect.logError(`terkelg/prompts errored while prompting for ${prop}`), Effect.map(() => ({ [prop]: [] })))), 
         // In terkelg/prompts, an empty object means that the user cancelled via
         // ctrl+c or the escape key etc. Handle this case so we can skip any
         // remaining steps.
-        effect_1.Effect.flatMap((res) => (0, is_empty_object_1.isEmptyObject)(res)
-            ? effect_1.Effect.fail(new PromptCancelled({ name: releaseType }))
-            : effect_1.Effect.succeed((0, is_array_1.isArray)(res?.[prop]) ? res?.[prop] : [])))
-        : effect_1.Effect.succeed([]);
+        Effect.flatMap((res) => isEmptyObject(res)
+            ? Effect.fail(new PromptCancelled({ name: releaseType }))
+            : Effect.succeed(isArray(res?.[prop]) ? res?.[prop] : [])))
+        : Effect.succeed([]);
 }
 function groupByReleaseType(releases) {
-    return effect_1.Effect.succeed(releases.reduce((releasesByType, release) => {
-        const previous = (0, set_semver_range_1.setSemverRange)('', String(release.instance.rawSpecifier.raw));
+    return Effect.succeed(releases.reduce((releasesByType, release) => {
+        const previous = setSemverRange('', String(release.instance.rawSpecifier.raw));
         const latest = release.versions.latest;
         try {
-            const type = (0, semver_1.diff)(previous, latest);
+            const type = diff(previous, latest);
             if (type && releasesByType[type]) {
                 releasesByType[type].push(release);
             }
@@ -259,7 +230,7 @@ function groupByReleaseType(releases) {
 }
 // @TODO: add a cache with a short TTL on disk in $TMPDIR
 function fetchJson(url) {
-    return (0, effect_1.pipe)(effect_1.Effect.async((resume) => {
+    return pipe(Effect.async((resume) => {
         // setTimeout(
         //   () => {
         //     resume(
@@ -275,7 +246,7 @@ function fetchJson(url) {
         //   },
         //   Math.floor(Math.random() * 500) + 1,
         // );
-        https_1.default
+        https
             .get(url, (res) => {
             let body = '';
             res.setEncoding('utf8');
@@ -283,13 +254,13 @@ function fetchJson(url) {
                 body = `${body}${chunk}`;
             });
             res.on('end', () => {
-                resume(effect_1.Effect.succeed(body));
+                resume(Effect.succeed(body));
             });
         })
             .on('error', (err) => {
-            resume(effect_1.Effect.fail(new HttpError({ error: `Node https threw on ${url}: ${String(err)}` })));
+            resume(Effect.fail(new HttpError({ error: `Node https threw on ${url}: ${String(err)}` })));
         });
-    }), effect_1.Effect.flatMap((body) => effect_1.Effect.try({
+    }), Effect.flatMap((body) => Effect.try({
         try: () => JSON.parse(body),
         catch: () => new NpmRegistryError({ error: `JSON.parse threw on response from ${url}` }),
     })));

package/dist/bin-update/index.js

@@ -1,19 +1,14 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const effect_1 = require("effect");
-const io_1 = require("../io");
-const show_help_on_error_1 = require("../lib/show-help-on-error");
-const option_1 = require("../option");
-const update_1 = require("./update");
-commander_1.program.description('  Update to the latest versions on the npm registry.');
-commander_1.program.on('--help', () => {
-    console.log((0, chalk_1.default) `
+import chalk from 'chalk-template';
+import { program } from 'commander';
+import { Effect } from 'effect';
+import { io } from '../io/index.js';
+import { showHelpOnError } from '../lib/show-help-on-error.js';
+import { option } from '../option.js';
+import { update } from './update.js';
+program.description('  Update to the latest versions on the npm registry.');
+program.on('--help', () => {
+    console.log(chalk `
 Examples:
   {dim # uses defaults for resolving packages}
   syncpack update
@@ -42,18 +37,18 @@ Reference:
   Pnpm Workspaces  {blue.underline https://pnpm.js.org/en/workspaces}
 `);
 });
-(0, show_help_on_error_1.showHelpOnError)(commander_1.program);
-commander_1.program
-    .option(...option_1.option.source)
-    .option(...option_1.option.filter)
-    .option(...option_1.option.config)
-    .option(...option_1.option.specs)
-    .option(...option_1.option.types)
+showHelpOnError(program);
+program
+    .option(...option.source)
+    .option(...option.filter)
+    .option(...option.config)
+    .option(...option.specs)
+    .option(...option.types)
     .parse(process.argv);
-effect_1.Effect.runPromise((0, update_1.update)(io_1.io, {
-    configPath: commander_1.program.opts().config,
-    filter: commander_1.program.opts().filter,
-    source: commander_1.program.opts().source,
-    specs: commander_1.program.opts().specs,
-    types: commander_1.program.opts().types,
+Effect.runPromise(update(io, {
+    configPath: program.opts().config,
+    filter: program.opts().filter,
+    source: program.opts().source,
+    specs: program.opts().specs,
+    types: program.opts().types,
 }));

package/dist/bin-update/update.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
-import { type CliConfig } from '../config/types';
-import type { ErrorHandlers } from '../error-handlers/default-error-handlers';
-import type { Io } from '../io';
-import { updateEffects } from './effects';
-export declare function update(io: Io, cli: Partial<CliConfig>, effects?: typeof updateEffects, errorHandlers?: ErrorHandlers): Effect.Effect<never, never, unknown>;
+import { type CliConfig } from '../config/types.js';
+import type { ErrorHandlers } from '../error-handlers/default-error-handlers.js';
+import type { Io } from '../io/index.js';
+import { updateEffects } from './effects.js';
+export declare function update(io: Io, cli: Partial<CliConfig>, effects?: typeof updateEffects, errorHandlers?: ErrorHandlers): Effect.Effect<unknown, never, never>;