@effected/package-json 0.16.0 → 0.18.0-next-20260927062352

package/PackageManagerRange.js

@@ -3,11 +3,90 @@ import { Effect, Exit, Option, Result, Schema, SchemaIssue, SchemaTransformation
 import { Range, SemVer } from "@effected/semver";
 
 //#region src/PackageManagerRange.ts
+const SINGLE_COMPARATOR_RE = /^([\^~]?)(.+)$/;
+const singleComparator = (range) => {
+	const match = SINGLE_COMPARATOR_RE.exec(range);
+	if (match === null) return Option.none();
+	const operator = match[1];
+	const version = match[2];
+	return SemVer.isPinnable(version) ? Option.some({
+		operator,
+		version
+	}) : Option.none();
+};
 const PACKAGE_MANAGER_NAME_RE = /^[a-z]+$/;
-const invalid = (input, message) => Effect.fail(new SchemaIssue.InvalidValue({ message }, input));
 /** `Schema.String` refined to parse as a semver range (`Range.parseResult` succeeds). The check is erased from the built type. */
 const SemVerRangeString = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.length > 0 && Result.isSuccess(Range.parseResult(value)) ? void 0 : "Expected a semver range (an exact version, a caret/tilde range, a comparator set, ...)")));
 /**
+* Indicates that a `packageManager` value, or a `devEngines.packageManager`
+* entry, could not be read as a {@link PackageManagerRange}.
+*
+* Raised by {@link PackageManagerRange.parse},
+* {@link PackageManagerRange.parseResult},
+* {@link PackageManagerRange.fromDevEngine} and
+* {@link PackageManagerRange.fromDevEngineResult}; the decode direction of
+* {@link PackageManagerRange.FromString} reports the same failure through a
+* generic `Schema` parse error carrying the same message.
+*
+* @public
+*/
+var InvalidPackageManagerRangeError = class extends Schema.TaggedError()("InvalidPackageManagerRangeError", {
+	/**
+	* The offending value: the raw `packageManager` string, or for a
+	* `devEngines` entry its `name` and `version` joined as
+	* `<name>@<version>` (just `<name>` when `version` is absent).
+	*/
+	input: Schema.String,
+	/**
+	* Which component failed: `format` (a `packageManager` string with no
+	* `@`), `name` (not a lowercase name), `range` (absent, empty, or not a
+	* semver range) or `integrity` (the tail after the first `+` is not a
+	* corepack `<algo>.<hex>` hash).
+	*/
+	reason: Schema.Literals([
+		"format",
+		"name",
+		"range",
+		"integrity"
+	])
+}) {
+	get message() {
+		return this.reason === "format" ? `Invalid packageManager format: "${this.input}": expected <name>@<range>[+<integrity>]` : this.reason === "name" ? `Invalid packageManager name: "${this.input}": name must be a lowercase package-manager name` : this.reason === "range" ? `Invalid packageManager range: "${this.input}": the range is missing or is not a semver range` : `Invalid packageManager integrity: "${this.input}": integrity must be a corepack <algo>.<hex> hash`;
+	}
+};
+/**
+* The shared component validation behind both entry points: `name`, and the
+* `<range>[+<integrity>]` tail split on its FIRST `+`. `input` is only the
+* text the error reports.
+*/
+const fromParts = (input, name, tail) => {
+	if (!PACKAGE_MANAGER_NAME_RE.test(name)) return Result.fail(new InvalidPackageManagerRangeError({
+		input,
+		reason: "name"
+	}));
+	const plus = tail.indexOf("+");
+	const range = plus === -1 ? tail : tail.slice(0, plus);
+	if (range.length === 0 || Result.isFailure(Range.parseResult(range))) return Result.fail(new InvalidPackageManagerRangeError({
+		input,
+		reason: "range"
+	}));
+	if (plus === -1) return Result.succeed(PackageManagerRange.make({
+		name,
+		range,
+		integrity: Option.none()
+	}));
+	const decoded = Schema.decodeUnknownExit(CorepackIntegrityHash)(tail.slice(plus + 1));
+	if (Exit.isFailure(decoded)) return Result.fail(new InvalidPackageManagerRangeError({
+		input,
+		reason: "integrity"
+	}));
+	return Result.succeed(PackageManagerRange.make({
+		name,
+		range,
+		integrity: Option.some(decoded.value)
+	}));
+};
+/**
 * A structured `packageManager` value whose version position is a semver
 * **range**, carried verbatim: `name`, `range` and an optional `integrity`
 * hash.
@@ -67,44 +146,111 @@ var PackageManagerRange = class PackageManagerRange extends Schema.Class("Packag
 	* {@link PackageManagerRange}.
 	*
 	* @remarks
-	* Decoding splits on the first `@`, then on the first `+` — which always
-	* begins the integrity, never semver build metadata — and validates each
-	* component: the name against the lowercase grammar, the range through
-	* `@effected/semver`'s `Range.parseResult`, the integrity through
-	* `CorepackIntegrityHash`. Every failure is a typed decode failure naming
-	* the component that failed. Encoding reconstructs the string from the
-	* verbatim parts, so it is byte-identical to any input this codec accepts.
+	* Decoding parses via {@link PackageManagerRange.parseResult}, so every
+	* failure is a typed decode failure naming the component that failed.
+	* Encoding prints `toString()`, reconstructed from the verbatim parts, so
+	* it is byte-identical to any input this codec accepts.
 	*/
 	static FromString = Schema.String.pipe(Schema.decodeTo(Schema.instanceOf(PackageManagerRange), SchemaTransformation.transformEffect({
 		decode: (input) => {
-			const at = input.indexOf("@");
-			if (at === -1) return invalid(input, `Invalid packageManager format: "${input}"`);
-			const name = input.slice(0, at);
-			if (!PACKAGE_MANAGER_NAME_RE.test(name)) return invalid(input, `Invalid packageManager name: "${name}"`);
-			const rest = input.slice(at + 1);
-			const plus = rest.indexOf("+");
-			const range = plus === -1 ? rest : rest.slice(0, plus);
-			if (range.length === 0 || Result.isFailure(Range.parseResult(range))) return invalid(input, `Invalid packageManager range: "${range}"`);
-			if (plus === -1) return Effect.succeed(PackageManagerRange.make({
-				name,
-				range,
-				integrity: Option.none()
-			}));
-			const rawIntegrity = rest.slice(plus + 1);
-			const decoded = Schema.decodeUnknownExit(CorepackIntegrityHash)(rawIntegrity);
-			if (Exit.isFailure(decoded)) return invalid(input, `Invalid packageManager integrity: "${rawIntegrity}"`);
-			return Effect.succeed(PackageManagerRange.make({
-				name,
-				range,
-				integrity: Option.some(decoded.value)
-			}));
+			const parsed = PackageManagerRange.parseResult(input);
+			return Result.isSuccess(parsed) ? Effect.succeed(parsed.success) : Effect.fail(new SchemaIssue.InvalidValue({ message: parsed.failure.message }, input));
 		},
-		encode: (pm) => Effect.succeed(Option.match(pm.integrity, {
-			onNone: () => `${pm.name}@${pm.range}`,
-			onSome: (integrity) => `${pm.name}@${pm.range}+${integrity}`
-		}))
+		encode: (pm) => Effect.succeed(pm.toString())
 	})));
 	/**
+	* Parse a `packageManager` string (`name@range[+integrity]`), synchronously,
+	* returning a `Result` instead of an `Effect`.
+	*
+	* @remarks
+	* Splits on the first `@`, then on the first `+` — which always begins the
+	* integrity, never semver build metadata — and validates each component:
+	* the name against the lowercase grammar, the range through
+	* `@effected/semver`'s `Range.parseResult`, the integrity through
+	* `CorepackIntegrityHash`. {@link PackageManagerRange.parse} is defined in
+	* terms of this function.
+	*
+	* @param input - the `packageManager` value to parse
+	* @returns a `Result` succeeding with the parsed {@link PackageManagerRange},
+	* or failing with {@link InvalidPackageManagerRangeError} naming the
+	* component that failed.
+	*/
+	static parseResult(input) {
+		const at = input.indexOf("@");
+		return at === -1 ? Result.fail(new InvalidPackageManagerRangeError({
+			input,
+			reason: "format"
+		})) : fromParts(input, input.slice(0, at), input.slice(at + 1));
+	}
+	/**
+	* Parse a `packageManager` string. Defined in terms of
+	* {@link PackageManagerRange.parseResult}.
+	*
+	* @param input - the `packageManager` value to parse
+	* @returns the parsed {@link PackageManagerRange}. Fails with
+	* {@link InvalidPackageManagerRangeError} when `input` is malformed.
+	*/
+	static parse = Effect.fn("PackageManagerRange.parse")((input) => Effect.fromResult(PackageManagerRange.parseResult(input)));
+	/**
+	* Read a `devEngines.packageManager` entry onto this model, synchronously,
+	* returning a `Result`.
+	*
+	* @remarks
+	* The entry's `name` is the package-manager name and its `version` is the
+	* same `<range>[+<integrity>]` tail the `packageManager` field carries after
+	* its `@` — `^12.6.0`, `12.6.0`, or `12.6.0+sha512.<hex>` as
+	* `pnpm self-update` historically wrote it. Both are validated exactly as
+	* {@link PackageManagerRange.parseResult} validates them. The `version`
+	* slot is optional on a {@link DevEngine}, but an entry without one names
+	* no range, so it fails with `reason: "range"`; `onFail` is ignored. The
+	* parameter is the encoded {@link DevEnginePackageManagerEntry} shape, so a
+	* plain object read off disk needs no `DevEngine` construction first.
+	*
+	* To write the entry back without its integrity (the bare form pnpm 11+
+	* writes), use `range` — the verbatim range with its operator kept and the
+	* integrity dropped.
+	*
+	* @param engine - the `devEngines.packageManager` entry to read
+	* @returns a `Result` succeeding with the {@link PackageManagerRange}, or
+	* failing with {@link InvalidPackageManagerRangeError}.
+	*/
+	static fromDevEngineResult(engine) {
+		if (engine.version === void 0) return Result.fail(new InvalidPackageManagerRangeError({
+			input: engine.name,
+			reason: "range"
+		}));
+		return fromParts(`${engine.name}@${engine.version}`, engine.name, engine.version);
+	}
+	/**
+	* Read a `devEngines.packageManager` entry onto this model. Defined in
+	* terms of {@link PackageManagerRange.fromDevEngineResult}.
+	*
+	* @param engine - the `devEngines.packageManager` entry to read
+	* @returns the {@link PackageManagerRange}. Fails with
+	* {@link InvalidPackageManagerRangeError} when the name, range or integrity
+	* is malformed, or the entry has no `version`.
+	*/
+	static fromDevEngine = Effect.fn("PackageManagerRange.fromDevEngine")((engine) => Effect.fromResult(PackageManagerRange.fromDevEngineResult(engine)));
+	/**
+	* The `packageManager` value without its integrity: `<name>@<range>`, range
+	* operator kept (`pnpm@^12.6.0+sha512.<hex>` → `pnpm@^12.6.0`). The
+	* `devEngines` counterpart is `range` itself.
+	*/
+	get bare() {
+		return `${this.name}@${this.range}`;
+	}
+	/**
+	* The value as parsed: `<name>@<range>` or `<name>@<range>+<integrity>`.
+	* The encode direction of {@link PackageManagerRange.FromString} prints
+	* exactly this.
+	*/
+	toString() {
+		return Option.match(this.integrity, {
+			onNone: () => this.bare,
+			onSome: (integrity) => `${this.bare}+${integrity}`
+		});
+	}
+	/**
 	* Whether the range is an exact, pinnable version (`11.2.0`) rather than a
 	* genuine range (`^11.20.0`) — decided by `SemVer.isPinnable` over the
 	* verbatim text, so `=11.2.0` and other range spellings of a single
@@ -114,6 +260,64 @@ var PackageManagerRange = class PackageManagerRange extends Schema.Class("Packag
 	get isExact() {
 		return SemVer.isPinnable(this.range);
 	}
+	/**
+	* The range's operator when it is a single exact, caret or tilde comparator
+	* over a pinnable version: `""` for `12.6.0`, `"^"` for `^12.6.0`, `"~"` for
+	* `~12.6.0`. `Option.none()` for anything else (`>=12 <13`, `12.x`,
+	* `=12.6.0`, `^12`), whose operator cannot be carried onto a new version
+	* unambiguously.
+	*/
+	get operator() {
+		return Option.map(singleComparator(this.range), (parts) => parts.operator);
+	}
+	/**
+	* The version a single exact, caret or tilde comparator is anchored on
+	* (`^12.6.0` → `12.6.0`); `Option.none()` exactly when
+	* {@link PackageManagerRange.operator} is.
+	*/
+	get baseVersion() {
+		return Option.map(singleComparator(this.range), (parts) => parts.version);
+	}
+	/**
+	* The same range re-anchored on `version`, operator kept and integrity
+	* dropped (`^12.6.0+sha512.<hex>` with `12.8.1` → `^12.8.1`), synchronously,
+	* returning a `Result`.
+	*
+	* @remarks
+	* Only a single exact, caret or tilde comparator can be re-anchored (see
+	* {@link PackageManagerRange.operator}); any other range, or a `version`
+	* that is not a pinnable semver version, fails with `reason: "range"`. The
+	* integrity is dropped because it named the old version's artifact.
+	*
+	* @param version - the pinnable version to anchor the range on
+	* @returns a `Result` succeeding with the re-anchored
+	* {@link PackageManagerRange}, or failing with
+	* {@link InvalidPackageManagerRangeError}.
+	*/
+	withVersionResult(version) {
+		const parts = singleComparator(this.range);
+		if (Option.isNone(parts) || !SemVer.isPinnable(version)) return Result.fail(new InvalidPackageManagerRangeError({
+			input: `${this.name}@${this.range} -> ${version}`,
+			reason: "range"
+		}));
+		return Result.succeed(PackageManagerRange.make({
+			name: this.name,
+			range: `${parts.value.operator}${version}`,
+			integrity: Option.none()
+		}));
+	}
+	/**
+	* The same range re-anchored on `version`. Defined in terms of
+	* {@link PackageManagerRange.withVersionResult}.
+	*
+	* @param version - the pinnable version to anchor the range on
+	* @returns the re-anchored {@link PackageManagerRange}. Fails with
+	* {@link InvalidPackageManagerRangeError} when the range is not a single
+	* exact, caret or tilde comparator, or `version` is not pinnable.
+	*/
+	withVersion(version) {
+		return Effect.fromResult(this.withVersionResult(version));
+	}
 	/** Whether an integrity hash is present. */
 	get hasIntegrity() {
 		return Option.isSome(this.integrity);
@@ -121,4 +325,4 @@ var PackageManagerRange = class PackageManagerRange extends Schema.Class("Packag
 };
 
 //#endregion
-export { PackageManagerRange };
+export { InvalidPackageManagerRangeError, PackageManagerRange };

package/index.d.ts

@@ -1395,6 +1395,49 @@ export declare class LenientManifest extends LenientManifest_base {
 }
 //#endregion
 //#region src/PackageManagerRange.d.ts
+/**
+ * The encoded shape of a `devEngines.packageManager` entry: what a raw
+ * `package.json` object carries. A {@link DevEngine} instance satisfies it
+ * structurally, so both a decoded entry and the plain object read straight off
+ * disk are accepted.
+ *
+ * @public
+ */
+interface DevEnginePackageManagerEntry {
+  readonly name: string;
+  readonly version?: string | undefined;
+}
+declare const InvalidPackageManagerRangeError_base: Schema.Class<InvalidPackageManagerRangeError, Schema.TaggedStruct<"InvalidPackageManagerRangeError", {
+  /**
+   * The offending value: the raw `packageManager` string, or for a
+   * `devEngines` entry its `name` and `version` joined as
+   * `<name>@<version>` (just `<name>` when `version` is absent).
+   */
+  readonly input: Schema.String;
+  /**
+   * Which component failed: `format` (a `packageManager` string with no
+   * `@`), `name` (not a lowercase name), `range` (absent, empty, or not a
+   * semver range) or `integrity` (the tail after the first `+` is not a
+   * corepack `<algo>.<hex>` hash).
+   */
+  readonly reason: Schema.Literals<readonly ["format", "name", "range", "integrity"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a `packageManager` value, or a `devEngines.packageManager`
+ * entry, could not be read as a {@link PackageManagerRange}.
+ *
+ * Raised by {@link PackageManagerRange.parse},
+ * {@link PackageManagerRange.parseResult},
+ * {@link PackageManagerRange.fromDevEngine} and
+ * {@link PackageManagerRange.fromDevEngineResult}; the decode direction of
+ * {@link PackageManagerRange.FromString} reports the same failure through a
+ * generic `Schema` parse error carrying the same message.
+ *
+ * @public
+ */
+export declare class InvalidPackageManagerRangeError extends InvalidPackageManagerRangeError_base {
+  get message(): string;
+}
 declare const PackageManagerRange_base: Schema.Class<PackageManagerRange, Schema.Struct<{
   /** The package-manager name (e.g. `pnpm`). Any lowercase name — the same latitude as {@link PackageManager}, for the same evidence. */
   readonly name: Schema.String;
@@ -1459,15 +1502,85 @@ export declare class PackageManagerRange extends PackageManagerRange_base {
    * {@link PackageManagerRange}.
    *
    * @remarks
-   * Decoding splits on the first `@`, then on the first `+` — which always
-   * begins the integrity, never semver build metadata — and validates each
-   * component: the name against the lowercase grammar, the range through
-   * `@effected/semver`'s `Range.parseResult`, the integrity through
-   * `CorepackIntegrityHash`. Every failure is a typed decode failure naming
-   * the component that failed. Encoding reconstructs the string from the
-   * verbatim parts, so it is byte-identical to any input this codec accepts.
+   * Decoding parses via {@link PackageManagerRange.parseResult}, so every
+   * failure is a typed decode failure naming the component that failed.
+   * Encoding prints `toString()`, reconstructed from the verbatim parts, so
+   * it is byte-identical to any input this codec accepts.
    */
   static readonly FromString: Schema.Codec<PackageManagerRange, string>;
+  /**
+   * Parse a `packageManager` string (`name@range[+integrity]`), synchronously,
+   * returning a `Result` instead of an `Effect`.
+   *
+   * @remarks
+   * Splits on the first `@`, then on the first `+` — which always begins the
+   * integrity, never semver build metadata — and validates each component:
+   * the name against the lowercase grammar, the range through
+   * `@effected/semver`'s `Range.parseResult`, the integrity through
+   * `CorepackIntegrityHash`. {@link PackageManagerRange.parse} is defined in
+   * terms of this function.
+   *
+   * @param input - the `packageManager` value to parse
+   * @returns a `Result` succeeding with the parsed {@link PackageManagerRange},
+   * or failing with {@link InvalidPackageManagerRangeError} naming the
+   * component that failed.
+   */
+  static parseResult(input: string): Result.Result<PackageManagerRange, InvalidPackageManagerRangeError>;
+  /**
+   * Parse a `packageManager` string. Defined in terms of
+   * {@link PackageManagerRange.parseResult}.
+   *
+   * @param input - the `packageManager` value to parse
+   * @returns the parsed {@link PackageManagerRange}. Fails with
+   * {@link InvalidPackageManagerRangeError} when `input` is malformed.
+   */
+  static readonly parse: (input: string) => Effect.Effect<PackageManagerRange, InvalidPackageManagerRangeError, never>;
+  /**
+   * Read a `devEngines.packageManager` entry onto this model, synchronously,
+   * returning a `Result`.
+   *
+   * @remarks
+   * The entry's `name` is the package-manager name and its `version` is the
+   * same `<range>[+<integrity>]` tail the `packageManager` field carries after
+   * its `@` — `^12.6.0`, `12.6.0`, or `12.6.0+sha512.<hex>` as
+   * `pnpm self-update` historically wrote it. Both are validated exactly as
+   * {@link PackageManagerRange.parseResult} validates them. The `version`
+   * slot is optional on a {@link DevEngine}, but an entry without one names
+   * no range, so it fails with `reason: "range"`; `onFail` is ignored. The
+   * parameter is the encoded {@link DevEnginePackageManagerEntry} shape, so a
+   * plain object read off disk needs no `DevEngine` construction first.
+   *
+   * To write the entry back without its integrity (the bare form pnpm 11+
+   * writes), use `range` — the verbatim range with its operator kept and the
+   * integrity dropped.
+   *
+   * @param engine - the `devEngines.packageManager` entry to read
+   * @returns a `Result` succeeding with the {@link PackageManagerRange}, or
+   * failing with {@link InvalidPackageManagerRangeError}.
+   */
+  static fromDevEngineResult(engine: DevEnginePackageManagerEntry): Result.Result<PackageManagerRange, InvalidPackageManagerRangeError>;
+  /**
+   * Read a `devEngines.packageManager` entry onto this model. Defined in
+   * terms of {@link PackageManagerRange.fromDevEngineResult}.
+   *
+   * @param engine - the `devEngines.packageManager` entry to read
+   * @returns the {@link PackageManagerRange}. Fails with
+   * {@link InvalidPackageManagerRangeError} when the name, range or integrity
+   * is malformed, or the entry has no `version`.
+   */
+  static readonly fromDevEngine: (engine: DevEnginePackageManagerEntry) => Effect.Effect<PackageManagerRange, InvalidPackageManagerRangeError, never>;
+  /**
+   * The `packageManager` value without its integrity: `<name>@<range>`, range
+   * operator kept (`pnpm@^12.6.0+sha512.<hex>` → `pnpm@^12.6.0`). The
+   * `devEngines` counterpart is `range` itself.
+   */
+  get bare(): string;
+  /**
+   * The value as parsed: `<name>@<range>` or `<name>@<range>+<integrity>`.
+   * The encode direction of {@link PackageManagerRange.FromString} prints
+   * exactly this.
+   */
+  toString(): string;
   /**
    * Whether the range is an exact, pinnable version (`11.2.0`) rather than a
    * genuine range (`^11.20.0`) — decided by `SemVer.isPinnable` over the
@@ -1476,6 +1589,47 @@ export declare class PackageManagerRange extends PackageManagerRange_base {
    * must re-emit the same spelling it read.
    */
   get isExact(): boolean;
+  /**
+   * The range's operator when it is a single exact, caret or tilde comparator
+   * over a pinnable version: `""` for `12.6.0`, `"^"` for `^12.6.0`, `"~"` for
+   * `~12.6.0`. `Option.none()` for anything else (`>=12 <13`, `12.x`,
+   * `=12.6.0`, `^12`), whose operator cannot be carried onto a new version
+   * unambiguously.
+   */
+  get operator(): Option.Option<"" | "^" | "~">;
+  /**
+   * The version a single exact, caret or tilde comparator is anchored on
+   * (`^12.6.0` → `12.6.0`); `Option.none()` exactly when
+   * {@link PackageManagerRange.operator} is.
+   */
+  get baseVersion(): Option.Option<string>;
+  /**
+   * The same range re-anchored on `version`, operator kept and integrity
+   * dropped (`^12.6.0+sha512.<hex>` with `12.8.1` → `^12.8.1`), synchronously,
+   * returning a `Result`.
+   *
+   * @remarks
+   * Only a single exact, caret or tilde comparator can be re-anchored (see
+   * {@link PackageManagerRange.operator}); any other range, or a `version`
+   * that is not a pinnable semver version, fails with `reason: "range"`. The
+   * integrity is dropped because it named the old version's artifact.
+   *
+   * @param version - the pinnable version to anchor the range on
+   * @returns a `Result` succeeding with the re-anchored
+   * {@link PackageManagerRange}, or failing with
+   * {@link InvalidPackageManagerRangeError}.
+   */
+  withVersionResult(version: string): Result.Result<PackageManagerRange, InvalidPackageManagerRangeError>;
+  /**
+   * The same range re-anchored on `version`. Defined in terms of
+   * {@link PackageManagerRange.withVersionResult}.
+   *
+   * @param version - the pinnable version to anchor the range on
+   * @returns the re-anchored {@link PackageManagerRange}. Fails with
+   * {@link InvalidPackageManagerRangeError} when the range is not a single
+   * exact, caret or tilde comparator, or `version` is not pinnable.
+   */
+  withVersion(version: string): Effect.Effect<PackageManagerRange, InvalidPackageManagerRangeError>;
   /** Whether an integrity hash is present. */
   get hasIntegrity(): boolean;
 }
@@ -1865,5 +2019,5 @@ export declare class PackageValidator extends PackageValidator_base {
   }): Layer.Layer<PackageValidator>;
 }
 //#endregion
-export { type DependencyKind, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, type DevEngines, type EntryPointManifest, InvalidDependencySpecifierError, JsoncEdit, type JsoncPath, type LenientFieldIssue, type PackageFieldEdit, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, type PackageJsonFileShape, type PackagePatch, type ResolveEntryPointOptions, type RuleFailure, type UnresolvedDependency, type ValidationRule, isValidDependencySpecifier };
+export { type DependencyKind, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, type DevEnginePackageManagerEntry, type DevEngines, type EntryPointManifest, InvalidDependencySpecifierError, JsoncEdit, type JsoncPath, type LenientFieldIssue, type PackageFieldEdit, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, type PackageJsonFileShape, type PackagePatch, type ResolveEntryPointOptions, type RuleFailure, type UnresolvedDependency, type ValidationRule, isValidDependencySpecifier };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -10,11 +10,11 @@ import { Bugs, Repository } from "./Repository.js";
 import { BinField, DependencyMapField, ExportsField, Package, PackageDecodeError, PeerDependenciesMetaField, PublishConfigField, RepositoryField, StringMapField } from "./Package.js";
 import { PackageJsonFormat, PackageJsonModifyError, PackageJsonSyntaxError } from "./PackageJsonFormat.js";
 import { LenientManifest } from "./LenientManifest.js";
-import { PackageManagerRange } from "./PackageManagerRange.js";
+import { InvalidPackageManagerRangeError, PackageManagerRange } from "./PackageManagerRange.js";
 import { PackageManifest } from "./PackageManifest.js";
 import { PackageJsonFile, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonWriteError } from "./PackageJsonFile.js";
 import { PackageValidationError, PackageValidator, defaultRules, noLocalDepsRule, noUnresolvedDepsRule } from "./PackageValidator.js";
 import { JsoncEdit } from "@effected/jsonc";
 import { DependencySpecifier, InvalidDependencySpecifierError, isValidDependencySpecifier } from "@effected/npm";
 
-export { BinField, Bugs, Dependency, DependencyMapField, DependencySpecifier, DevEngine, DevEngineOrArray, DevEnginesSchema, ExportsField, Funding, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, LenientManifest, Package, PackageDecodeError, PackageJsonFile, PackageJsonFormat, PackageJsonModifyError, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageManagerRange, PackageManifest, PackageName, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, Repository, RepositoryField, ScopedPackageName, SpdxLicense, StringMapField, UnresolvedEntryPointError, UnscopedPackageName, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, licenseExpressionOf, noLocalDepsRule, noUnresolvedDepsRule, resolveEntryPoint };
+export { BinField, Bugs, Dependency, DependencyMapField, DependencySpecifier, DevEngine, DevEngineOrArray, DevEnginesSchema, ExportsField, Funding, InvalidDependencySpecifierError, InvalidPackageManagerRangeError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, LenientManifest, Package, PackageDecodeError, PackageJsonFile, PackageJsonFormat, PackageJsonModifyError, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageManagerRange, PackageManifest, PackageName, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, Repository, RepositoryField, ScopedPackageName, SpdxLicense, StringMapField, UnresolvedEntryPointError, UnscopedPackageName, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, licenseExpressionOf, noLocalDepsRule, noUnresolvedDepsRule, resolveEntryPoint };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/package-json",
-	"version": "0.16.0",
+	"version": "0.18.0-next-20260927062352",
 	"private": false,
 	"description": "package.json parsing, editing, validation and file IO as Effect schemas.",
 	"keywords": [
@@ -38,13 +38,13 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/jsonc": "^0.12.0",
-		"@effected/npm": "^0.15.0",
-		"@effected/semver": "^0.8.0",
-		"@effected/spdx": "^0.8.0"
+		"@effected/jsonc": "^0.13.0",
+		"@effected/npm": "^0.17.0-next-20260927062352",
+		"@effected/semver": "^0.9.0",
+		"@effected/spdx": "^0.9.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.116"
+		"effect": "4.0.0-rc.117"
 	},
 	"engines": {
 		"node": ">=24.11.0"