syncpack 13.0.1 → 14.0.0-alpha.2

package/dist/version-group/create-version-groups.js

@@ -1,118 +0,0 @@
-import { Effect } from 'effect';
-import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
-import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
-import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
-import { isObject } from 'tightrope/guard/is-object.js';
-import { BannedVersionGroup } from './banned.js';
-import { FilteredOutVersionGroup } from './filtered-out.js';
-import { IgnoredVersionGroup } from './ignored.js';
-import { VersionGroup } from './index.js';
-import { PinnedVersionGroup } from './pinned.js';
-import { SameRangeVersionGroup } from './same-range.js';
-import { SnappedToVersionGroup } from './snapped-to.js';
-import { StandardVersionGroup } from './standard.js';
-export function createVersionGroups(ctx) {
-    const { rcFile } = ctx.config;
-    const versionGroups = [Effect.succeed(new FilteredOutVersionGroup(ctx))];
-    if (isNonEmptyArray(rcFile.versionGroups)) {
-        rcFile.versionGroups.forEach((config) => {
-            if (!isObject(config)) {
-                return versionGroups.push(Effect.fail(new VersionGroup.ConfigError({
-                    config,
-                    error: 'config is not an object',
-                })));
-            }
-            const mutuallyExclusiveProps = ['isBanned', 'isIgnored', 'pinVersion', 'snapTo', 'policy'].filter(prop => Boolean(config[prop]));
-            if (mutuallyExclusiveProps.length > 1) {
-                return versionGroups.push(Effect.fail(new VersionGroup.ConfigError({
-                    config,
-                    error: `it's unclear what kind of version group you want, as it contains both ${mutuallyExclusiveProps.join(' and ')}`,
-                })));
-            }
-            const label = isNonEmptyString(config.label) ? config.label : '';
-            const dependencyTypes = isArrayOfStrings(config.dependencyTypes)
-                ? config.dependencyTypes
-                : ['**'];
-            const dependencies = isArrayOfStrings(config.dependencies)
-                ? config.dependencies
-                : ['**'];
-            const packages = isArrayOfStrings(config.packages)
-                ? config.packages
-                : ['**'];
-            const specifierTypes = isArrayOfStrings(config.specifierTypes)
-                ? config.specifierTypes
-                : ['**'];
-            if (config.isBanned === true) {
-                versionGroups.push(Effect.succeed(new BannedVersionGroup({
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    isBanned: true,
-                    label,
-                    packages,
-                })));
-            }
-            else if (config.isIgnored === true) {
-                versionGroups.push(Effect.succeed(new IgnoredVersionGroup({
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    isIgnored: true,
-                    label,
-                    packages,
-                })));
-            }
-            else if (isNonEmptyString(config.pinVersion)) {
-                versionGroups.push(Effect.succeed(new PinnedVersionGroup({
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    label,
-                    packages,
-                    pinVersion: config.pinVersion,
-                })));
-            }
-            else if (isArrayOfStrings(config.snapTo)) {
-                versionGroups.push(Effect.succeed(new SnappedToVersionGroup({
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    label,
-                    packages,
-                    snapTo: config.snapTo,
-                })));
-            }
-            else if (config.policy === 'sameRange') {
-                versionGroups.push(Effect.succeed(new SameRangeVersionGroup(ctx, {
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    label,
-                    packages,
-                    policy: config.policy,
-                })));
-            }
-            else {
-                versionGroups.push(Effect.succeed(new StandardVersionGroup(false, {
-                    dependencies,
-                    dependencyTypes,
-                    specifierTypes,
-                    label,
-                    packages,
-                    preferVersion: config.preferVersion === 'lowestSemver'
-                        ? 'lowestSemver'
-                        : 'highestSemver',
-                })));
-            }
-        });
-    }
-    versionGroups.push(Effect.succeed(new StandardVersionGroup(true, {
-        dependencies: ['**'],
-        dependencyTypes: ['**'],
-        specifierTypes: ['**'],
-        label: 'Default Version Group',
-        packages: ['**'],
-        preferVersion: 'highestSemver',
-    })));
-    return Effect.all(versionGroups);
-}

package/dist/version-group/filtered-out.d.ts

@@ -1,19 +0,0 @@
-import { Effect } from 'effect';
-import type { GroupConfig } from '../config/types.js';
-import type { Ctx } from '../get-context/index.js';
-import type { Instance } from '../get-instances/instance.js';
-import { Report } from '../report.js';
-declare const FilteredOutVersionGroup_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: "FilteredOut";
-};
-export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_base<{
-    config: GroupConfig;
-    filter: string;
-    instances: Instance[];
-}> {
-    groupType: string;
-    constructor(ctx: Ctx);
-    canAdd(instance: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};

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

@@ -1,30 +0,0 @@
-import { Data, Effect } from 'effect';
-import { getFilter } from '../config/get-filter.js';
-import { Report } from '../report.js';
-import { groupBy } from './lib/group-by.js';
-export class FilteredOutVersionGroup extends Data.TaggedClass('FilteredOut') {
-    groupType = 'versionGroup';
-    constructor(ctx) {
-        super({
-            config: {
-                dependencies: ['**'],
-                dependencyTypes: ['**'],
-                label: 'Filtered out',
-                packages: ['**'],
-            },
-            filter: getFilter(ctx.config),
-            instances: [],
-        });
-    }
-    canAdd(instance) {
-        return instance.name.search(new RegExp(this.filter)) === -1;
-    }
-    inspectAll() {
-        return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
-            name,
-            reports: instances.map(instance => 
-            // ✓ is ignored and dismissed as valid
-            new Report.FilteredOut(instance)),
-        })));
-    }
-}

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

@@ -1,17 +0,0 @@
-import { Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types.js';
-import type { Instance } from '../get-instances/instance.js';
-import { Report } from '../report.js';
-declare const IgnoredVersionGroup_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: "Ignored";
-};
-export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
-    config: VersionGroupConfig.Ignored;
-    instances: Instance[];
-}> {
-    groupType: string;
-    constructor(config: VersionGroupConfig.Ignored);
-    canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};

package/dist/version-group/ignored.js

@@ -1,23 +0,0 @@
-import { Data, Effect } from 'effect';
-import { Report } from '../report.js';
-import { groupBy } from './lib/group-by.js';
-export class IgnoredVersionGroup extends Data.TaggedClass('Ignored') {
-    groupType = 'versionGroup';
-    constructor(config) {
-        super({
-            config,
-            instances: [],
-        });
-    }
-    canAdd(_) {
-        return true;
-    }
-    inspectAll() {
-        return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
-            name,
-            reports: instances.map(instance => 
-            // ✓ is ignored and dismissed as valid
-            new Report.Ignored(instance)),
-        })));
-    }
-}

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

@@ -1,26 +0,0 @@
-import type { BannedVersionGroup } from './banned.js';
-import type { FilteredOutVersionGroup } from './filtered-out.js';
-import type { IgnoredVersionGroup } from './ignored.js';
-import type { PinnedVersionGroup } from './pinned.js';
-import type { SameRangeVersionGroup } from './same-range.js';
-import type { SnappedToVersionGroup } from './snapped-to.js';
-import type { StandardVersionGroup } from './standard.js';
-export declare namespace VersionGroup {
-    export type Banned = BannedVersionGroup;
-    export type FilteredOut = FilteredOutVersionGroup;
-    export type Ignored = IgnoredVersionGroup;
-    export type Pinned = PinnedVersionGroup;
-    export type SameRange = SameRangeVersionGroup;
-    export type SnappedTo = SnappedToVersionGroup;
-    export type Standard = StandardVersionGroup;
-    export type Any = Banned | FilteredOut | Ignored | Pinned | SameRange | SnappedTo | Standard;
-    const ConfigError_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: "VersionGroupConfigError";
-    };
-    export class ConfigError extends ConfigError_base<{
-        readonly config: unknown;
-        readonly error: string;
-    }> {
-    }
-    export {};
-}

package/dist/version-group/index.js

@@ -1,7 +0,0 @@
-import { Data } from 'effect';
-export var VersionGroup;
-(function (VersionGroup) {
-    class ConfigError extends Data.TaggedClass('VersionGroupConfigError') {
-    }
-    VersionGroup.ConfigError = ConfigError;
-})(VersionGroup || (VersionGroup = {}));

package/dist/version-group/lib/clean.d.ts

@@ -1,2 +0,0 @@
-/** Convert eg "1" to "1.0.0" which the semver lib does not understand */
-export declare function clean(v: string): string;

package/dist/version-group/lib/clean.js

@@ -1,6 +0,0 @@
-import coerce from 'semver/functions/coerce.js';
-import valid from 'semver/functions/valid.js';
-/** Convert eg "1" to "1.0.0" which the semver lib does not understand */
-export function clean(v) {
-    return valid(coerce(v)) || '';
-}

package/dist/version-group/lib/delete.d.ts

@@ -1,2 +0,0 @@
-export declare const DELETE: unique symbol;
-export type Delete = typeof DELETE;

package/dist/version-group/lib/delete.js

@@ -1 +0,0 @@
-export const DELETE = Symbol('DELETE');

package/dist/version-group/lib/get-highest-version.d.ts

@@ -1,6 +0,0 @@
-import type { Specifier } from '../../specifier/index.js';
-/**
- * From an array of instances where every instance contains a valid semver
- * version, return the highest version number
- */
-export declare function getHighestVersion(specifiers: Specifier.Any[]): import("effect/Effect").Effect<Specifier.Any, import("../../specifier/lib/non-semver-error.js").NonSemverError, never>;

package/dist/version-group/lib/get-highest-version.js

@@ -1,8 +0,0 @@
-import { getPreferredVersion } from './get-preferred-version.js';
-/**
- * From an array of instances where every instance contains a valid semver
- * version, return the highest version number
- */
-export function getHighestVersion(specifiers) {
-    return getPreferredVersion('highestSemver', specifiers);
-}

package/dist/version-group/lib/get-lowest-version.d.ts

@@ -1,6 +0,0 @@
-import type { Specifier } from '../../specifier/index.js';
-/**
- * From an array of instances where every instance contains a valid semver
- * version, return the lowest version number
- */
-export declare function getLowestVersion(specifiers: Specifier.Any[]): import("effect/Effect").Effect<Specifier.Any, import("../../specifier/lib/non-semver-error.js").NonSemverError, never>;

package/dist/version-group/lib/get-lowest-version.js

@@ -1,8 +0,0 @@
-import { getPreferredVersion } from './get-preferred-version.js';
-/**
- * From an array of instances where every instance contains a valid semver
- * version, return the lowest version number
- */
-export function getLowestVersion(specifiers) {
-    return getPreferredVersion('lowestSemver', specifiers);
-}

package/dist/version-group/lib/get-preferred-version.d.ts

@@ -1,5 +0,0 @@
-import { Effect } from 'effect';
-import type { VersionGroupConfig } from '../../config/types.js';
-import type { Specifier } from '../../specifier/index.js';
-import type { NonSemverError } from '../../specifier/lib/non-semver-error.js';
-export declare function getPreferredVersion(preferVersion: VersionGroupConfig.Standard['preferVersion'], specifiers: Specifier.Any[]): Effect.Effect<Specifier.Any, NonSemverError>;

package/dist/version-group/lib/get-preferred-version.js

@@ -1,53 +0,0 @@
-import { Effect, pipe } from 'effect';
-import gt from 'semver/functions/gt.js';
-import lt from 'semver/functions/lt.js';
-import { clean } from './clean.js';
-import { getRangeScore } from './get-range-score.js';
-export function getPreferredVersion(preferVersion, specifiers) {
-    return pipe(
-    // every instance must have a semver version
-    Effect.all(specifiers.map(specifier => pipe(specifier.getSemver(), Effect.map(semver => ({ semver, specifier }))))), 
-    // comparing semver can error on some loose ranges, all must succeed
-    Effect.map(semvers => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
-    // get the preferred value from the list
-    Effect.map(sorted => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
-    // return just the specifier
-    Effect.map(preferred => preferred?.specifier));
-}
-const EQ = 0;
-const LT = -1;
-const GT = 1;
-function compareSemver(a, b) {
-    if (a.startsWith('workspace:')) {
-        return LT;
-    }
-    if (b.startsWith('workspace:')) {
-        return GT;
-    }
-    if (a === b) {
-        return EQ;
-    }
-    if (a === '*') {
-        return GT;
-    }
-    if (b === '*') {
-        return LT;
-    }
-    const cleanA = clean(a);
-    const cleanB = clean(b);
-    if (gt(cleanA, cleanB)) {
-        return GT;
-    }
-    if (lt(cleanA, cleanB)) {
-        return LT;
-    }
-    const scoreA = getRangeScore(a);
-    const scoreB = getRangeScore(b);
-    if (scoreA < scoreB) {
-        return LT;
-    }
-    if (scoreA > scoreB) {
-        return GT;
-    }
-    return EQ;
-}

package/dist/version-group/lib/get-range-score.d.ts

@@ -1,2 +0,0 @@
-/** Rank a Semver Range according to its greediness */
-export declare function getRangeScore(version: string): number;

package/dist/version-group/lib/get-range-score.js

@@ -1,20 +0,0 @@
-import { RANGE } from '../../constants.js';
-const scoresByRange = {
-    [RANGE.ANY]: 9,
-    [RANGE.WORKSPACE]: 8,
-    [RANGE.GT]: 7,
-    [RANGE.GTE]: 6,
-    [RANGE.MINOR]: 5,
-    [RANGE.LOOSE]: 4,
-    [RANGE.PATCH]: 3,
-    [RANGE.EXACT]: 2,
-    [RANGE.LTE]: 1,
-    [RANGE.LT]: 0,
-};
-/** Rank a Semver Range according to its greediness */
-export function getRangeScore(version) {
-    const range = version.indexOf('.x') !== -1
-        ? RANGE.LOOSE
-        : version.slice(0, version.search(/[0-9]/));
-    return scoresByRange[range] || 0;
-}

package/dist/version-group/lib/group-by.d.ts

@@ -1,5 +0,0 @@
-/**
- * Convert an array of objects to an object, where each property of the new
- * object is an array whose members share the same value for the given key.
- */
-export declare function groupBy<A extends any[]>(key: string, array: A): Record<string, A>;

package/dist/version-group/lib/group-by.js

@@ -1,11 +0,0 @@
-/**
- * Convert an array of objects to an object, where each property of the new
- * object is an array whose members share the same value for the given key.
- */
-export function groupBy(key, array) {
-    return array.reduce((objectsByKeyValue, obj) => {
-        const value = obj[key];
-        objectsByKeyValue[value] = (objectsByKeyValue[value] || []).concat(obj);
-        return objectsByKeyValue;
-    }, {});
-}

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

@@ -1,17 +0,0 @@
-import { Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types.js';
-import type { Instance } from '../get-instances/instance.js';
-import { Report } from '../report.js';
-declare const PinnedVersionGroup_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: "Pinned";
-};
-export declare class PinnedVersionGroup extends PinnedVersionGroup_base<{
-    config: VersionGroupConfig.Pinned;
-    instances: Instance[];
-}> {
-    groupType: string;
-    constructor(config: VersionGroupConfig.Pinned);
-    canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};

package/dist/version-group/pinned.js

@@ -1,26 +0,0 @@
-import { Data, Effect, pipe } from 'effect';
-import { Report } from '../report.js';
-import { Specifier } from '../specifier/index.js';
-import { groupBy } from './lib/group-by.js';
-export class PinnedVersionGroup extends Data.TaggedClass('Pinned') {
-    groupType = 'versionGroup';
-    constructor(config) {
-        super({
-            config,
-            instances: [],
-        });
-    }
-    canAdd(_) {
-        return true;
-    }
-    inspectAll() {
-        return Effect.all(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => pipe(instances, Effect.forEach(instance => pipe(Effect.succeed(Specifier.create(instance, this.config.pinVersion)), Effect.map(expected => instance.rawSpecifier.raw === expected.raw
-            ? // ✓ pinned takes precedence over any semver group
-                // ✓ current version matches expected
-                new Report.Valid(expected)
-            : // ✓ pinned takes precedence over any semver group
-                // ✘ current version mismatches expected
-                // ✓ is a mismatch we can auto-fix
-                new Report.PinnedMismatch(expected)))), Effect.map(reports => ({ name, reports })))));
-    }
-}

package/dist/version-group/same-range.d.ts

@@ -1,19 +0,0 @@
-import { Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types.js';
-import type { Ctx } from '../get-context/index.js';
-import type { Instance } from '../get-instances/instance.js';
-import { Report } from '../report.js';
-declare const SameRangeVersionGroup_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: "SameRange";
-};
-export declare class SameRangeVersionGroup extends SameRangeVersionGroup_base<{
-    ctx: Ctx;
-    config: VersionGroupConfig.SameRange;
-    instances: Instance[];
-}> {
-    groupType: string;
-    constructor(ctx: Ctx, config: VersionGroupConfig.SameRange);
-    canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};

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

@@ -1,96 +0,0 @@
-import { Data, Effect, pipe } from 'effect';
-import intersects from 'semver/ranges/intersects.js';
-import { uniq } from 'tightrope/array/uniq.js';
-import { Report } from '../report.js';
-import { Specifier } from '../specifier/index.js';
-import { groupBy } from './lib/group-by.js';
-export class SameRangeVersionGroup extends Data.TaggedClass('SameRange') {
-    groupType = 'versionGroup';
-    constructor(ctx, config) {
-        super({
-            ctx,
-            config,
-            instances: [],
-        });
-    }
-    canAdd(_) {
-        return true;
-    }
-    inspectAll() {
-        return Effect.all(Object.entries(groupBy('name', this.instances)).flatMap(([name, instances]) => pipe(instances, Effect.partition(instance => pipe(Effect.succeed(Specifier.create(instance, instance.rawSpecifier.raw)), Effect.flatMap(specifier => pipe(specifier.getSemver(), Effect.matchEffect({
-            onFailure: () => Effect.fail(
-            // ✘ expected version is not semver
-            // ✘ is a mismatch we can't auto-fix
-            new Report.UnsupportedMismatch(specifier.instance)),
-            onSuccess: () => pipe(specifier.instance.semverGroup.getFixed(specifier), Effect.matchEffect({
-                onFailure: () => Effect.fail(
-                // ✓ expected version is semver
-                // ✘ expected version is not fixable by its semver group
-                // ✘ is a mismatch we can't auto-fix
-                new Report.UnsupportedMismatch(specifier.instance)),
-                onSuccess: valid => specifier.instance.rawSpecifier.raw === valid.raw
-                    ? Effect.succeed(
-                    // ✓ expected version is semver
-                    // ✓ expected version matches its semver group
-                    // ✓ current version matches expected
-                    new Report.Valid(specifier))
-                    : Effect.fail(
-                    // ✓ expected version is semver
-                    // ✓ expected version matches its semver group
-                    // ✘ current version mismatches expected
-                    // ✓ is a mismatch we can auto-fix
-                    new Report.SemverRangeMismatch(valid)),
-            })),
-        }))))), Effect.map(([allMismatches, allMatches]) => allMismatches.length === 0
-            ? allMatches.map(thisMatch => {
-                if (thisMatch.specifier.instance.strategy.name === 'local') {
-                    // ✓ every instance is valid on its own
-                    // ✓ expected version is semver
-                    // ! is the original local package
-                    // ✓ others must match this, not the other way around
-                    return thisMatch;
-                }
-                const mismatches = getRangeMismatches(this.ctx, thisMatch, allMatches);
-                if (mismatches.length === 0) {
-                    // ✓ every instance is valid on its own
-                    // ✓ expected version is semver
-                    // ✓ expected version matches its semver group
-                    // ✓ current version matches expected
-                    // ! is not the original local package
-                    // ✓ current specifier matches every other specifier
-                    return thisMatch;
-                }
-                // ✓ every instance is valid on its own
-                // ✓ expected version is semver
-                // ✓ expected version matches its semver group
-                // ✓ current version matches expected
-                // ! is not the original local package
-                // ✘ current specifier does not match every other specifier
-                return new Report.SameRangeMismatch(thisMatch.specifier.instance, uniq(mismatches.map(report => String(report.specifier.instance.rawSpecifier.raw))));
-            })
-            : // ✘ not every instance is valid on its own
-                // ! report on their validity individually ! when all are valid
-                //   they can progress to being checked for having compatible
-                //   ranges
-                [...allMatches, ...allMismatches]), Effect.map(reports => ({ name, reports })))));
-    }
-}
-/** Find all ranges/versions which this semver version does not cover */
-function getRangeMismatches(ctx, report, others) {
-    return others.filter(other => !matchesRange(ctx, report, other));
-}
-/** Does semver version `a` match semver version `b`? */
-function matchesRange(ctx, a, b) {
-    const loose = true;
-    return intersects(unwrapSemver(ctx, a.specifier), unwrapSemver(ctx, b.specifier), loose);
-}
-/** Get the semver version synchronously from a specifier known to contain semver */
-function unwrapSemver(ctx, specifier) {
-    if (specifier._tag === 'Range' || specifier._tag === 'Exact') {
-        return specifier.raw;
-    }
-    if (specifier._tag === 'WorkspaceProtocol') {
-        return Effect.runSync(specifier.getSemverEquivalent(ctx));
-    }
-    return Effect.runSync(specifier.getSemver());
-}

package/dist/version-group/snapped-to.d.ts

@@ -1,17 +0,0 @@
-import { Effect } from 'effect';
-import type { VersionGroupConfig } from '../config/types.js';
-import type { Instance } from '../get-instances/instance.js';
-import { Report } from '../report.js';
-declare const SnappedToVersionGroup_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: "SnappedTo";
-};
-export declare class SnappedToVersionGroup extends SnappedToVersionGroup_base<{
-    config: VersionGroupConfig.SnappedTo;
-    instances: Instance[];
-}> {
-    groupType: string;
-    constructor(config: VersionGroupConfig.SnappedTo);
-    canAdd(_: Instance): boolean;
-    inspectAll(): Effect.Effect<Report.Version.Group[]>;
-}
-export {};