package-json-effect - npm Package Compare versions

Comparing version 0.2.0 to 0.3.0

domain/Dependency.js

+import { Effect, Option, Schema } from "effect";
+import { parseRange } from "semver-effect";
+
+//#region src/domain/Dependency.ts
+const isBarePath = (s) => s.startsWith("./") || s.startsWith("../") || s.startsWith("~/") || s.startsWith("/");
+/**
+* Returns true if the specifier points to a local path (file:, link:, portal:, or a bare path).
+*
+* @public
+*/
+const isLocalSpecifier = (s) => s.startsWith("file:") || s.startsWith("link:") || s.startsWith("portal:") || isBarePath(s);
+/** Bare GitHub shorthand `user/repo[#ref]`, excluding local-path-looking strings. */
+const isGitHubShorthand = (s) => !s.startsWith(".") && !s.startsWith("~") && !s.startsWith("/") && /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(#.*)?$/.test(s);
+/**
+* Returns true if the specifier resolves to a git source (git URLs and hosted-git shorthands).
+*
+* @public
+*/
+const isGitSpecifier = (s) => s.startsWith("git+") || s.startsWith("git://") || s.startsWith("github:") || s.startsWith("gist:") || s.startsWith("bitbucket:") || s.startsWith("gitlab:") || isGitHubShorthand(s);
+/**
+* Returns true if the specifier is a parseable semver range.
+*
+* @public
+*/
+const isRangeSpecifier = (s) => Option.isSome(parseRangeOption(s));
+/**
+* Returns true if the specifier is a dist-tag (e.g. "latest", "next").
+*
+* @public
+*/
+const isTagSpecifier = (s) => protocolOf(s) === "tag";
+/**
+* Parse the specifier as a semver Range, returning None when it is not a range.
+*
+* @public
+*/
+const parseRangeOption = (s) => Effect.runSync(Effect.option(parseRange(s)));
+/**
+* Classify a specifier string into a single protocol; "unknown" for unrecognized input.
+*
+* @public
+*/
+const protocolOf = (s) => {
+	if (s.startsWith("catalog:")) return "catalog";
+	if (s.startsWith("workspace:")) return "workspace";
+	if (s.startsWith("link:")) return "link";
+	if (s.startsWith("portal:")) return "portal";
+	if (s.startsWith("file:") || isBarePath(s)) return "file";
+	if (s.startsWith("npm:")) return "npm";
+	if (isGitSpecifier(s)) return "git";
+	if (s.startsWith("http://") || s.startsWith("https://")) return "url";
+	if (Option.isSome(parseRangeOption(s))) return "range";
+	if (/^[a-zA-Z][a-zA-Z0-9._-]*$/.test(s)) return "tag";
+	return "unknown";
+};
+/**
+* A resolved dependency entry pairing a package name with its version specifier.
+*
+* @public
+*/
+var Dependency = class extends Schema.TaggedClass()("Dependency", {
+	name: Schema.String,
+	specifier: Schema.String
+}) {
+	get protocol() {
+		return this.specifier.length === 0 ? Option.none() : Option.some(protocolOf(this.specifier));
+	}
+	get range() {
+		return parseRangeOption(this.specifier);
+	}
+	get isLocal() {
+		return isLocalSpecifier(this.specifier);
+	}
+	get isLink() {
+		return this.specifier.startsWith("link:");
+	}
+	get isPortal() {
+		return this.specifier.startsWith("portal:");
+	}
+	get isCatalog() {
+		return this.specifier.startsWith("catalog:");
+	}
+	get isWorkspace() {
+		return this.specifier.startsWith("workspace:");
+	}
+	get isUnresolved() {
+		return this.isCatalog || this.isWorkspace;
+	}
+	get isGit() {
+		return isGitSpecifier(this.specifier);
+	}
+	get isRange() {
+		return isRangeSpecifier(this.specifier);
+	}
+	get isTag() {
+		return isTagSpecifier(this.specifier);
+	}
+};
+/**
+* Type guard narrowing any dependency-like value to UnresolvedDependency, preserving the concrete type.
+*
+* @public
+*/
+const isUnresolvedDependency = (dep) => dep.isUnresolved === true;
+
+//#endregion
+export { Dependency, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, parseRangeOption, protocolOf };

domain/DevDependency.js

+import { isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, parseRangeOption, protocolOf } from "./Dependency.js";
+import { Option, Schema } from "effect";
+
+//#region src/domain/DevDependency.ts
+/**
+* A `devDependencies` entry pairing a package name with its version specifier.
+*
+* @public
+*/
+var DevDependency = class extends Schema.TaggedClass()("DevDependency", {
+	name: Schema.String,
+	specifier: Schema.String
+}) {
+	get protocol() {
+		return this.specifier.length === 0 ? Option.none() : Option.some(protocolOf(this.specifier));
+	}
+	get range() {
+		return parseRangeOption(this.specifier);
+	}
+	get isLocal() {
+		return isLocalSpecifier(this.specifier);
+	}
+	get isLink() {
+		return this.specifier.startsWith("link:");
+	}
+	get isPortal() {
+		return this.specifier.startsWith("portal:");
+	}
+	get isCatalog() {
+		return this.specifier.startsWith("catalog:");
+	}
+	get isWorkspace() {
+		return this.specifier.startsWith("workspace:");
+	}
+	get isUnresolved() {
+		return this.isCatalog || this.isWorkspace;
+	}
+	get isGit() {
+		return isGitSpecifier(this.specifier);
+	}
+	get isRange() {
+		return isRangeSpecifier(this.specifier);
+	}
+	get isTag() {
+		return isTagSpecifier(this.specifier);
+	}
+};
+
+//#endregion
+export { DevDependency };

domain/OptionalDependency.js

+import { isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, parseRangeOption, protocolOf } from "./Dependency.js";
+import { Option, Schema } from "effect";
+
+//#region src/domain/OptionalDependency.ts
+/**
+* An `optionalDependencies` entry pairing a package name with its version specifier.
+*
+* @public
+*/
+var OptionalDependency = class extends Schema.TaggedClass()("OptionalDependency", {
+	name: Schema.String,
+	specifier: Schema.String
+}) {
+	get protocol() {
+		return this.specifier.length === 0 ? Option.none() : Option.some(protocolOf(this.specifier));
+	}
+	get range() {
+		return parseRangeOption(this.specifier);
+	}
+	get isLocal() {
+		return isLocalSpecifier(this.specifier);
+	}
+	get isLink() {
+		return this.specifier.startsWith("link:");
+	}
+	get isPortal() {
+		return this.specifier.startsWith("portal:");
+	}
+	get isCatalog() {
+		return this.specifier.startsWith("catalog:");
+	}
+	get isWorkspace() {
+		return this.specifier.startsWith("workspace:");
+	}
+	get isUnresolved() {
+		return this.isCatalog || this.isWorkspace;
+	}
+	get isGit() {
+		return isGitSpecifier(this.specifier);
+	}
+	get isRange() {
+		return isRangeSpecifier(this.specifier);
+	}
+	get isTag() {
+		return isTagSpecifier(this.specifier);
+	}
+};
+
+//#endregion
+export { OptionalDependency };

domain/Package.js

+import { Dependency } from "./Dependency.js";
+import { DevDependency } from "./DevDependency.js";
+import { OptionalDependency } from "./OptionalDependency.js";
+import { InvalidPackageNameError } from "../errors/InvalidPackageNameError.js";
+import { InvalidSpdxLicenseError } from "../errors/InvalidSpdxLicenseError.js";
+import { BinSchema } from "../schemas/bin.js";
+import { DependencyMapSchema } from "../schemas/dependency-map.js";
+import { DevEnginesSchema } from "../schemas/dev-engines.js";
+import { EnginesSchema } from "../schemas/engines.js";
+import { ExportsFieldSchema } from "../schemas/exports-field.js";
+import { SpdxLicense } from "../schemas/license.js";
+import { PackageName, isValidPackageName } from "../schemas/name.js";
+import { PackageManagerSchema } from "../schemas/package-manager.js";
+import { PublishConfigSchema } from "../schemas/publish-config.js";
+import { ScriptsSchema } from "../schemas/scripts.js";
+import { VersionSchema } from "../schemas/version.js";
+import { CatalogResolver } from "../services/CatalogResolver.js";
+import { WorkspaceResolver } from "../services/WorkspaceResolver.js";
+import { PackageNameUtil } from "./PackageName.js";
+import { PeerDependency } from "./PeerDependency.js";
+import { Data, Effect, HashMap, Option, Pipeable, Schema } from "effect";
+import { parseValidSemVer } from "semver-effect";
+import { dual } from "effect/Function";
+
+//#region src/domain/Package.ts
+const applyWorkspaceModifier = (specifier, version) => {
+	const mod = specifier.slice(10);
+	if (mod === "*" || mod === "") return version;
+	if (mod === "^") return `^${version}`;
+	if (mod === "~") return `~${version}`;
+	return mod;
+};
+const catalogName = (specifier) => {
+	const name = specifier.slice(8);
+	return name.length === 0 ? Option.none() : Option.some(name);
+};
+/**
+* Domain model for a package.json document. A Schema.Class carrying typed
+* known fields plus a `rest` catch-all that preserves any unmodeled top-level
+* fields for round-trip fidelity. The literal `rest` key is flattened away by
+* the wire transform in src/schemas/package-json.ts.
+*
+* @public
+*/
+var Package = class Package extends Schema.Class("Package")({
+	name: PackageName,
+	version: VersionSchema,
+	description: Schema.optionalWith(Schema.String, { as: "Option" }),
+	private: Schema.optionalWith(Schema.Boolean, { as: "Option" }),
+	type: Schema.optionalWith(Schema.Literal("module", "commonjs"), { as: "Option" }),
+	main: Schema.optionalWith(Schema.String, { as: "Option" }),
+	license: Schema.optionalWith(Schema.String, { as: "Option" }),
+	dependencies: Schema.optionalWith(DependencyMapSchema, { default: () => HashMap.empty() }),
+	devDependencies: Schema.optionalWith(DependencyMapSchema, { default: () => HashMap.empty() }),
+	peerDependencies: Schema.optionalWith(DependencyMapSchema, { default: () => HashMap.empty() }),
+	optionalDependencies: Schema.optionalWith(DependencyMapSchema, { default: () => HashMap.empty() }),
+	peerDependenciesMeta: Schema.optionalWith(Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({ optional: Schema.optional(Schema.Boolean) })
+	}), { as: "Option" }),
+	scripts: Schema.optionalWith(ScriptsSchema, { default: () => HashMap.empty() }),
+	bin: Schema.optionalWith(BinSchema, { as: "Option" }),
+	engines: Schema.optionalWith(EnginesSchema, { as: "Option" }),
+	exports: Schema.optionalWith(ExportsFieldSchema, { as: "Option" }),
+	publishConfig: Schema.optionalWith(PublishConfigSchema, { as: "Option" }),
+	packageManager: Schema.optionalWith(PackageManagerSchema, { as: "Option" }),
+	devEngines: Schema.optionalWith(DevEnginesSchema, { as: "Option" }),
+	rest: Schema.optionalWith(Schema.Data(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})), { default: () => Data.struct({}) })
+}) {
+	get isPrivate() {
+		return Option.getOrElse(this.private, () => false);
+	}
+	get isScoped() {
+		return PackageNameUtil.isScoped(this.name);
+	}
+	get isESM() {
+		return Option.match(this.type, {
+			onNone: () => false,
+			onSome: (t) => t === "module"
+		});
+	}
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+	hasDependency(name) {
+		return HashMap.has(this.dependencies, name) || HashMap.has(this.devDependencies, name) || HashMap.has(this.peerDependencies, name) || HashMap.has(this.optionalDependencies, name);
+	}
+	getDependencies() {
+		return HashMap.map(this.dependencies, (specifier, name) => new Dependency({
+			name,
+			specifier
+		}));
+	}
+	getDevDependencies() {
+		return HashMap.map(this.devDependencies, (specifier, name) => new DevDependency({
+			name,
+			specifier
+		}));
+	}
+	getPeerDependencies() {
+		const meta = Option.getOrElse(this.peerDependenciesMeta, () => ({}));
+		return HashMap.map(this.peerDependencies, (specifier, name) => new PeerDependency({
+			name,
+			specifier,
+			isOptional: meta[name]?.optional ?? false
+		}));
+	}
+	getOptionalDependencies() {
+		return HashMap.map(this.optionalDependencies, (specifier, name) => new OptionalDependency({
+			name,
+			specifier
+		}));
+	}
+	/** Return a new Package with the given fields replaced. */
+	copyWith(patch) {
+		return new Package({
+			...this,
+			...patch
+		}, { disableValidation: true });
+	}
+	/** Construct a Package from an already-decoded data record. */
+	static fromData(data) {
+		return new Package(data, { disableValidation: true });
+	}
+	static setVersion = dual(2, (pkg, version) => parseValidSemVer(version).pipe(Effect.map((semver) => pkg.copyWith({ version: semver }))));
+	static setName = dual(2, (pkg, name) => isValidPackageName(name) ? Effect.succeed(pkg.copyWith({ name })) : Effect.fail(new InvalidPackageNameError({
+		input: name,
+		reason: "Does not satisfy npm naming rules"
+	})));
+	static addDependency = dual(3, (pkg, name, specifier) => pkg.copyWith({ dependencies: HashMap.set(pkg.dependencies, name, specifier) }));
+	static removeDependency = dual(2, (pkg, name) => pkg.copyWith({ dependencies: HashMap.remove(pkg.dependencies, name) }));
+	static addDevDependency = dual(3, (pkg, name, specifier) => pkg.copyWith({ devDependencies: HashMap.set(pkg.devDependencies, name, specifier) }));
+	static removeDevDependency = dual(2, (pkg, name) => pkg.copyWith({ devDependencies: HashMap.remove(pkg.devDependencies, name) }));
+	static addPeerDependency = dual(3, (pkg, name, specifier) => pkg.copyWith({ peerDependencies: HashMap.set(pkg.peerDependencies, name, specifier) }));
+	static removePeerDependency = dual(2, (pkg, name) => pkg.copyWith({ peerDependencies: HashMap.remove(pkg.peerDependencies, name) }));
+	static addOptionalDependency = dual(3, (pkg, name, specifier) => pkg.copyWith({ optionalDependencies: HashMap.set(pkg.optionalDependencies, name, specifier) }));
+	static removeOptionalDependency = dual(2, (pkg, name) => pkg.copyWith({ optionalDependencies: HashMap.remove(pkg.optionalDependencies, name) }));
+	static setScript = dual(3, (pkg, name, command) => pkg.copyWith({ scripts: HashMap.set(pkg.scripts, name, command) }));
+	static removeScript = dual(2, (pkg, name) => pkg.copyWith({ scripts: HashMap.remove(pkg.scripts, name) }));
+	static setLicense = dual(2, (pkg, license) => Schema.decodeUnknown(SpdxLicense)(license).pipe(Effect.mapError(() => new InvalidSpdxLicenseError({
+		input: license,
+		reason: "Not a recognized SPDX identifier or expression"
+	})), Effect.map(() => pkg.copyWith({ license: Option.some(license) }))));
+	/**
+	* Resolve catalog: and workspace: specifiers across all four dependency maps
+	* using the CatalogResolver and WorkspaceResolver from context. Returns a new
+	* Package. Specifiers the resolvers return None for are left unchanged.
+	*/
+	static resolve(pkg) {
+		return Effect.gen(function* () {
+			const ws = yield* WorkspaceResolver;
+			const cat = yield* CatalogResolver;
+			const resolveMap = (map) => Effect.gen(function* () {
+				let next = map;
+				for (const [name, specifier] of HashMap.entries(map)) if (specifier.startsWith("workspace:")) {
+					const version = yield* ws.versionOf(name);
+					if (Option.isSome(version)) next = HashMap.set(next, name, applyWorkspaceModifier(specifier, version.value));
+				} else if (specifier.startsWith("catalog:")) {
+					const range = yield* cat.rangeOf(name, catalogName(specifier));
+					if (Option.isSome(range)) next = HashMap.set(next, name, range.value);
+				}
+				return next;
+			});
+			return pkg.copyWith({
+				dependencies: yield* resolveMap(pkg.dependencies),
+				devDependencies: yield* resolveMap(pkg.devDependencies),
+				peerDependencies: yield* resolveMap(pkg.peerDependencies),
+				optionalDependencies: yield* resolveMap(pkg.optionalDependencies)
+			});
+		});
+	}
+};
+
+//#endregion
+export { Package };

domain/PackageName.js

+import { Option } from "effect";
+
+//#region src/domain/PackageName.ts
+/**
+* Utility functions for working with package name strings.
+*
+* @public
+*/
+const PackageNameUtil = {
+	scope: (name) => {
+		if (!name.startsWith("@")) return Option.none();
+		const slashIndex = name.indexOf("/");
+		if (slashIndex === -1) return Option.none();
+		return Option.some(name.slice(1, slashIndex));
+	},
+	unscoped: (name) => {
+		if (!name.startsWith("@")) return name;
+		const slashIndex = name.indexOf("/");
+		return slashIndex === -1 ? name : name.slice(slashIndex + 1);
+	},
+	isScoped: (name) => name.startsWith("@")
+};
+
+//#endregion
+export { PackageNameUtil };

domain/PeerDependency.js

+import { isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, parseRangeOption, protocolOf } from "./Dependency.js";
+import { Option, Schema } from "effect";
+
+//#region src/domain/PeerDependency.ts
+/**
+* A `peerDependencies` entry pairing a package name, version specifier, and optionality flag.
+*
+* @public
+*/
+var PeerDependency = class extends Schema.TaggedClass()("PeerDependency", {
+	name: Schema.String,
+	specifier: Schema.String,
+	isOptional: Schema.Boolean
+}) {
+	get protocol() {
+		return this.specifier.length === 0 ? Option.none() : Option.some(protocolOf(this.specifier));
+	}
+	get range() {
+		return parseRangeOption(this.specifier);
+	}
+	get isLocal() {
+		return isLocalSpecifier(this.specifier);
+	}
+	get isLink() {
+		return this.specifier.startsWith("link:");
+	}
+	get isPortal() {
+		return this.specifier.startsWith("portal:");
+	}
+	get isCatalog() {
+		return this.specifier.startsWith("catalog:");
+	}
+	get isWorkspace() {
+		return this.specifier.startsWith("workspace:");
+	}
+	get isUnresolved() {
+		return this.isCatalog || this.isWorkspace;
+	}
+	get isGit() {
+		return isGitSpecifier(this.specifier);
+	}
+	get isRange() {
+		return isRangeSpecifier(this.specifier);
+	}
+	get isTag() {
+		return isTagSpecifier(this.specifier);
+	}
+};
+
+//#endregion
+export { PeerDependency };

errors/DependencyResolutionError.js

+import { Data } from "effect";
+
+//#region src/errors/DependencyResolutionError.ts
+/**
+* Tagged error base for {@link DependencyResolutionError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link DependencyResolutionError} appears in public type signatures.
+* Consumers should use {@link DependencyResolutionError} directly.
+*
+* @public
+*/
+const DependencyResolutionErrorBase = Data.TaggedError("DependencyResolutionError");
+/**
+* Indicates that a catalog: or workspace: specifier could not be resolved.
+*
+* @public
+*/
+var DependencyResolutionError = class extends DependencyResolutionErrorBase {
+	get message() {
+		return `Failed to resolve "${this.specifier}" for "${this.packageName}": ${this.reason}`;
+	}
+};
+
+//#endregion
+export { DependencyResolutionError, DependencyResolutionErrorBase };

errors/InvalidDependencySpecifierError.js

+import { Data } from "effect";
+
+//#region src/errors/InvalidDependencySpecifierError.ts
+/**
+* Tagged error base for {@link InvalidDependencySpecifierError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link InvalidDependencySpecifierError} appears in public type signatures.
+* Consumers should use {@link InvalidDependencySpecifierError} directly.
+*
+* @public
+*/
+const InvalidDependencySpecifierErrorBase = Data.TaggedError("InvalidDependencySpecifierError");
+/**
+* Indicates that a string could not be parsed as a valid dependency specifier.
+*
+* @public
+*/
+var InvalidDependencySpecifierError = class extends InvalidDependencySpecifierErrorBase {
+	get message() {
+		return `Invalid dependency specifier "${this.input}": ${this.reason}`;
+	}
+};
+
+//#endregion
+export { InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase };

errors/InvalidPackageNameError.js

+import { Data } from "effect";
+
+//#region src/errors/InvalidPackageNameError.ts
+/**
+* Tagged error base for {@link InvalidPackageNameError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link InvalidPackageNameError} appears in public type signatures.
+* Consumers should use {@link InvalidPackageNameError} directly.
+*
+* @public
+*/
+const InvalidPackageNameErrorBase = Data.TaggedError("InvalidPackageNameError");
+/**
+* Indicates that a string could not be used as a valid npm package name.
+*
+* @public
+*/
+var InvalidPackageNameError = class extends InvalidPackageNameErrorBase {
+	get message() {
+		return `Invalid package name "${this.input}": ${this.reason}`;
+	}
+};
+
+//#endregion
+export { InvalidPackageNameError, InvalidPackageNameErrorBase };

errors/InvalidSpdxLicenseError.js

+import { Data } from "effect";
+
+//#region src/errors/InvalidSpdxLicenseError.ts
+/**
+* Tagged error base for {@link InvalidSpdxLicenseError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link InvalidSpdxLicenseError} appears in public type signatures.
+* Consumers should use {@link InvalidSpdxLicenseError} directly.
+*
+* @public
+*/
+const InvalidSpdxLicenseErrorBase = Data.TaggedError("InvalidSpdxLicenseError");
+/**
+* Indicates that a string is not a valid SPDX license identifier or expression.
+*
+* @public
+*/
+var InvalidSpdxLicenseError = class extends InvalidSpdxLicenseErrorBase {
+	get message() {
+		return `Invalid SPDX license "${this.input}": ${this.reason}`;
+	}
+};
+
+//#endregion
+export { InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase };

errors/PackageJsonDecodeError.js

+import { Data } from "effect";
+
+//#region src/errors/PackageJsonDecodeError.ts
+/**
+* Tagged error base for {@link PackageJsonDecodeError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonDecodeError} appears in public type signatures.
+* Consumers should use {@link PackageJsonDecodeError} directly.
+*
+* @public
+*/
+const PackageJsonDecodeErrorBase = Data.TaggedError("PackageJsonDecodeError");
+/**
+* Indicates that a parsed JSON value could not be decoded into a valid PackageJson structure.
+*
+* @public
+*/
+var PackageJsonDecodeError = class extends PackageJsonDecodeErrorBase {};
+
+//#endregion
+export { PackageJsonDecodeError, PackageJsonDecodeErrorBase };

errors/PackageJsonNotFoundError.js

+import { Data } from "effect";
+
+//#region src/errors/PackageJsonNotFoundError.ts
+/**
+* Tagged error base for {@link PackageJsonNotFoundError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonNotFoundError} appears in public type signatures.
+* Consumers should use {@link PackageJsonNotFoundError} directly.
+*
+* @public
+*/
+const PackageJsonNotFoundErrorBase = Data.TaggedError("PackageJsonNotFoundError");
+/**
+* Indicates that a package.json file was not found at the expected location.
+*
+* @public
+*/
+var PackageJsonNotFoundError = class extends PackageJsonNotFoundErrorBase {
+	get message() {
+		return `package.json not found at "${this.source}"`;
+	}
+};
+
+//#endregion
+export { PackageJsonNotFoundError, PackageJsonNotFoundErrorBase };

errors/PackageJsonParseError.js

+import { Data, Option } from "effect";
+
+//#region src/errors/PackageJsonParseError.ts
+/**
+* Tagged error base for {@link PackageJsonParseError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonParseError} appears in public type signatures.
+* Consumers should use {@link PackageJsonParseError} directly.
+*
+* @public
+*/
+const PackageJsonParseErrorBase = Data.TaggedError("PackageJsonParseError");
+/**
+* Indicates that a string could not be parsed as valid JSON for a package.json file.
+*
+* @public
+*/
+var PackageJsonParseError = class extends PackageJsonParseErrorBase {
+	get message() {
+		const base = "Failed to parse package.json";
+		return Option.match(this.position, {
+			onNone: () => base,
+			onSome: (pos) => `${base} at position ${pos}`
+		});
+	}
+};
+
+//#endregion
+export { PackageJsonParseError, PackageJsonParseErrorBase };

errors/PackageJsonReadError.js

+import { Data } from "effect";
+
+//#region src/errors/PackageJsonReadError.ts
+/**
+* Tagged error base for {@link PackageJsonReadError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonReadError} appears in public type signatures.
+* Consumers should use {@link PackageJsonReadError} directly.
+*
+* @public
+*/
+const PackageJsonReadErrorBase = Data.TaggedError("PackageJsonReadError");
+/**
+* Indicates that a package.json file could not be read from the filesystem.
+*
+* @public
+*/
+var PackageJsonReadError = class extends PackageJsonReadErrorBase {
+	get message() {
+		return `Failed to read package.json from "${this.source}"`;
+	}
+};
+
+//#endregion
+export { PackageJsonReadError, PackageJsonReadErrorBase };

errors/PackageJsonValidationError.js

+import { Data, Option } from "effect";
+
+//#region src/errors/PackageJsonValidationError.ts
+/**
+* Tagged error base for {@link PackageJsonValidationError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonValidationError} appears in public type signatures.
+* Consumers should use {@link PackageJsonValidationError} directly.
+*
+* @public
+*/
+const PackageJsonValidationErrorBase = Data.TaggedError("PackageJsonValidationError");
+/**
+* Indicates that a package.json file failed one or more validation rules.
+*
+* @public
+*/
+var PackageJsonValidationError = class extends PackageJsonValidationErrorBase {
+	get message() {
+		return `package.json validation failed:\n${this.failures.map((f) => {
+			const pathPart = Option.match(f.path, {
+				onNone: () => "",
+				onSome: (p) => ` (at ${p})`
+			});
+			return `  - [${f.rule}]${pathPart}: ${f.message}`;
+		}).join("\n")}`;
+	}
+};
+
+//#endregion
+export { PackageJsonValidationError, PackageJsonValidationErrorBase };

errors/PackageJsonWriteError.js

+import { Data } from "effect";
+
+//#region src/errors/PackageJsonWriteError.ts
+/**
+* Tagged error base for {@link PackageJsonWriteError}.
+*
+* @privateRemarks
+* Exported because TypeScript declaration bundling requires the base class to be
+* accessible when {@link PackageJsonWriteError} appears in public type signatures.
+* Consumers should use {@link PackageJsonWriteError} directly.
+*
+* @public
+*/
+const PackageJsonWriteErrorBase = Data.TaggedError("PackageJsonWriteError");
+/**
+* Indicates that a package.json file could not be written to the filesystem.
+*
+* @public
+*/
+var PackageJsonWriteError = class extends PackageJsonWriteErrorBase {
+	get message() {
+		return `Failed to write package.json to "${this.target}"`;
+	}
+};
+
+//#endregion
+export { PackageJsonWriteError, PackageJsonWriteErrorBase };

layers/CatalogResolverLive.js

+import { CatalogResolver } from "../services/CatalogResolver.js";
+import { Effect, Layer, Option } from "effect";
+
+//#region src/layers/CatalogResolverLive.ts
+/**
+* Default CatalogResolver: resolves nothing. Provide a real implementation
+* (e.g. backed by workspaces-effect) to resolve catalog: specifiers.
+*
+* @public
+*/
+const CatalogResolverLive = Layer.succeed(CatalogResolver, CatalogResolver.of({ rangeOf: () => Effect.succeed(Option.none()) }));
+
+//#endregion
+export { CatalogResolverLive };

layers/PackageJsonFormatterLive.js

+import { PackageJsonFormatter } from "../services/PackageJsonFormatter.js";
+import { Layer } from "effect";
+
+//#region src/layers/PackageJsonFormatterLive.ts
+const KEY_ORDER = [
+	"$schema",
+	"name",
+	"version",
+	"private",
+	"description",
+	"keywords",
+	"homepage",
+	"bugs",
+	"repository",
+	"funding",
+	"license",
+	"author",
+	"contributors",
+	"type",
+	"imports",
+	"exports",
+	"main",
+	"module",
+	"browser",
+	"bin",
+	"man",
+	"files",
+	"directories",
+	"workspaces",
+	"scripts",
+	"config",
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"optionalDependencies",
+	"bundleDependencies",
+	"overrides",
+	"engines",
+	"devEngines",
+	"os",
+	"cpu",
+	"publishConfig",
+	"packageManager"
+];
+const DEPENDENCY_KEYS = /* @__PURE__ */ new Set([
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies",
+	"bundleDependencies"
+]);
+const sortKeys = (obj) => {
+	const known = [];
+	const unknown = [];
+	for (const key of Object.keys(obj)) if (KEY_ORDER.includes(key)) known.push([key, obj[key]]);
+	else unknown.push([key, obj[key]]);
+	known.sort((a, b) => KEY_ORDER.indexOf(a[0]) - KEY_ORDER.indexOf(b[0]));
+	unknown.sort((a, b) => a[0].localeCompare(b[0]));
+	const result = {};
+	for (const [key, value] of [...known, ...unknown]) if (DEPENDENCY_KEYS.has(key) && value !== null && typeof value === "object" && !Array.isArray(value)) result[key] = Object.keys(value).sort((a, b) => a.localeCompare(b)).reduce((acc, k) => {
+		acc[k] = value[k];
+		return acc;
+	}, {});
+	else result[key] = value;
+	return result;
+};
+/**
+* Live Layer providing the PackageJsonFormatter service, which orders top-level
+* keys canonically and alphabetizes dependency maps.
+*
+* @public
+*/
+const PackageJsonFormatterLive = Layer.succeed(PackageJsonFormatter, PackageJsonFormatter.of({ format: sortKeys }));
+
+//#endregion
+export { PackageJsonFormatterLive };

layers/PackageJsonLive.js

+import { CatalogResolverLive } from "./CatalogResolverLive.js";
+import { PackageJsonFormatterLive } from "./PackageJsonFormatterLive.js";
+import { PackageJsonReaderLive } from "./PackageJsonReaderLive.js";
+import { PackageJsonTransformerLive } from "./PackageJsonTransformerLive.js";
+import { PackageJsonValidatorLive } from "./PackageJsonValidatorLive.js";
+import { PackageJsonWriterLive } from "./PackageJsonWriterLive.js";
+import { WorkspaceResolverLive } from "./WorkspaceResolverLive.js";
+import { Layer } from "effect";
+
+//#region src/layers/PackageJsonLive.ts
+/**
+* Composite layer providing all package-json-effect services.
+* Requires \@effect/platform FileSystem to be provided by the consumer.
+*
+* @public
+*/
+const PackageJsonLive = Layer.mergeAll(PackageJsonReaderLive, PackageJsonWriterLive.pipe(Layer.provide(PackageJsonFormatterLive), Layer.provide(CatalogResolverLive), Layer.provide(WorkspaceResolverLive), Layer.provide(PackageJsonTransformerLive)), PackageJsonFormatterLive, CatalogResolverLive, WorkspaceResolverLive, PackageJsonTransformerLive, PackageJsonValidatorLive);
+
+//#endregion
+export { PackageJsonLive };

layers/PackageJsonReaderLive.js

+import { PackageJsonDecodeError } from "../errors/PackageJsonDecodeError.js";
+import { PackageJsonNotFoundError } from "../errors/PackageJsonNotFoundError.js";
+import { PackageJsonParseError } from "../errors/PackageJsonParseError.js";
+import { PackageJsonReadError } from "../errors/PackageJsonReadError.js";
+import { PackageJsonSchema } from "../schemas/package-json.js";
+import { PackageJsonReader } from "../services/PackageJsonReader.js";
+import { Effect, Layer, Option, Schema } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/layers/PackageJsonReaderLive.ts
+/**
+* Live Layer providing the PackageJsonReader service backed by \@effect/platform
+* FileSystem.
+*
+* @public
+*/
+const PackageJsonReaderLive = Layer.effect(PackageJsonReader, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	return PackageJsonReader.of({ read: (source) => Effect.gen(function* () {
+		if (!(yield* fs.exists(source).pipe(Effect.mapError((cause) => new PackageJsonReadError({
+			source,
+			cause
+		}))))) return yield* new PackageJsonNotFoundError({ source });
+		const content = yield* fs.readFileString(source).pipe(Effect.mapError((cause) => new PackageJsonReadError({
+			source,
+			cause
+		})));
+		const json = yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: (err) => {
+				return new PackageJsonParseError({
+					input: content,
+					position: err instanceof SyntaxError && typeof err.position === "number" ? Option.some(err.position) : Option.none()
+				});
+			}
+		});
+		return yield* Schema.decodeUnknown(PackageJsonSchema)(json).pipe(Effect.mapError((cause) => new PackageJsonDecodeError({
+			input: json,
+			message: cause.message ?? "Failed to decode package.json"
+		})));
+	}) });
+}));
+
+//#endregion
+export { PackageJsonReaderLive };

layers/PackageJsonTransformerLive.js

+import { PackageJsonTransformer } from "../services/PackageJsonTransformer.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/PackageJsonTransformerLive.ts
+const DEPENDENCY_MAP_KEYS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const stripEmptyDependencyMaps = (raw) => {
+	const result = { ...raw };
+	for (const key of DEPENDENCY_MAP_KEYS) {
+		const value = result[key];
+		if (value !== void 0 && typeof value === "object" && value !== null && Object.keys(value).length === 0) delete result[key];
+	}
+	return result;
+};
+/**
+* Default PackageJsonTransformer: removes empty dependency map fields.
+* Replace or compose with custom transformers for additional processing.
+*
+* @public
+*/
+const PackageJsonTransformerLive = Layer.succeed(PackageJsonTransformer, PackageJsonTransformer.of({ transform: (raw) => Effect.succeed(stripEmptyDependencyMaps(raw)) }));
+
+//#endregion
+export { PackageJsonTransformerLive };

layers/PackageJsonValidatorLive.js

+import { PackageJsonValidationError } from "../errors/PackageJsonValidationError.js";
+import { PackageJsonValidator } from "../services/PackageJsonValidator.js";
+import { Effect, HashMap, Layer, Option } from "effect";
+
+//#region src/layers/PackageJsonValidatorLive.ts
+const hasLicense = {
+	name: "has-license",
+	validate: (pkg) => Option.isSome(pkg.license) ? Effect.void : Effect.fail({
+		message: "Missing license field",
+		path: Option.some("license")
+	})
+};
+const hasDescription = {
+	name: "has-description",
+	validate: (pkg) => Option.isSome(pkg.description) ? Effect.void : Effect.fail({
+		message: "Missing description field",
+		path: Option.some("description")
+	})
+};
+const hasRepository = {
+	name: "has-repository",
+	validate: (pkg) => Object.hasOwn(pkg, "repository") || Object.hasOwn(pkg.rest, "repository") ? Effect.void : Effect.fail({
+		message: "Missing repository field",
+		path: Option.some("repository")
+	})
+};
+const notPrivate = {
+	name: "not-private",
+	validate: (pkg) => pkg.isPrivate ? Effect.fail({
+		message: "Package is private",
+		path: Option.some("private")
+	}) : Effect.void
+};
+const anyDepMatches = (pkg, pred) => {
+	return [
+		pkg.dependencies,
+		pkg.devDependencies,
+		pkg.peerDependencies,
+		pkg.optionalDependencies
+	].some((m) => Array.from(HashMap.values(m)).some(pred));
+};
+/**
+* Validation rule that fails when any dependency uses an unresolved
+* workspace: or catalog: specifier.
+*
+* @public
+*/
+const noUnresolvedDepsRule = {
+	name: "no-unresolved-deps",
+	validate: (pkg) => anyDepMatches(pkg, (s) => s.startsWith("workspace:") || s.startsWith("catalog:")) ? Effect.fail({
+		message: "Unresolved workspace:/catalog: dependency",
+		path: Option.none()
+	}) : Effect.void
+};
+/**
+* Validation rule that fails when any dependency uses a local
+* file:, link:, or portal: specifier.
+*
+* @public
+*/
+const noLocalDepsRule = {
+	name: "no-local-deps",
+	validate: (pkg) => anyDepMatches(pkg, (s) => s.startsWith("file:") || s.startsWith("link:") || s.startsWith("portal:")) ? Effect.fail({
+		message: "Local file:/link:/portal: dependency",
+		path: Option.none()
+	}) : Effect.void
+};
+/**
+* Default set of validation rules: license, description, repository, and
+* not-private checks.
+*
+* @public
+*/
+const defaultRules = [
+	hasLicense,
+	hasDescription,
+	hasRepository,
+	notPrivate
+];
+const runRules = (pkg, rules) => Effect.gen(function* () {
+	const failures = [];
+	for (const rule of rules) yield* rule.validate(pkg).pipe(Effect.matchEffect({
+		onSuccess: () => Effect.void,
+		onFailure: (err) => {
+			failures.push({
+				rule: rule.name,
+				message: err.message,
+				path: err.path ?? Option.none()
+			});
+			return Effect.void;
+		}
+	}));
+	if (failures.length > 0) return yield* new PackageJsonValidationError({ failures });
+	return pkg;
+});
+/**
+* Live Layer providing the PackageJsonValidator service backed by the
+* default rule set.
+*
+* @public
+*/
+const PackageJsonValidatorLive = Layer.succeed(PackageJsonValidator, PackageJsonValidator.of({ validate: (pkg) => runRules(pkg, defaultRules) }));
+/**
+* Builds a PackageJsonValidator Layer from a custom set of validation rules.
+*
+* @public
+*/
+const makePackageJsonValidatorLive = (config) => Layer.succeed(PackageJsonValidator, PackageJsonValidator.of({ validate: (pkg) => runRules(pkg, config.rules) }));
+
+//#endregion
+export { PackageJsonValidatorLive, defaultRules, makePackageJsonValidatorLive, noLocalDepsRule, noUnresolvedDepsRule };

layers/PackageJsonWriterLive.js

+import { CatalogResolver } from "../services/CatalogResolver.js";
+import { WorkspaceResolver } from "../services/WorkspaceResolver.js";
+import { Package } from "../domain/Package.js";
+import { PackageJsonWriteError } from "../errors/PackageJsonWriteError.js";
+import { PackageJsonFormatter } from "../services/PackageJsonFormatter.js";
+import { PackageJsonSchema } from "../schemas/package-json.js";
+import { PackageJsonTransformer } from "../services/PackageJsonTransformer.js";
+import { PackageJsonWriter } from "../services/PackageJsonWriter.js";
+import { Effect, Layer, Schema } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/layers/PackageJsonWriterLive.ts
+/**
+* Live Layer providing the PackageJsonWriter service, which resolves
+* catalog:/workspace: protocols, transforms, formats, and writes package.json.
+*
+* @public
+*/
+const PackageJsonWriterLive = Layer.effect(PackageJsonWriter, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const formatter = yield* PackageJsonFormatter;
+	const transformer = yield* PackageJsonTransformer;
+	const catalog = yield* CatalogResolver;
+	const workspace = yield* WorkspaceResolver;
+	return PackageJsonWriter.of({ write: (target, pkg) => Effect.gen(function* () {
+		const resolved = yield* Package.resolve(pkg).pipe(Effect.provideService(CatalogResolver, catalog), Effect.provideService(WorkspaceResolver, workspace), Effect.mapError((cause) => new PackageJsonWriteError({
+			target,
+			cause
+		})));
+		const encoded = yield* Schema.encode(PackageJsonSchema)(resolved).pipe(Effect.mapError((cause) => new PackageJsonWriteError({
+			target,
+			cause
+		})));
+		const raw = yield* transformer.transform(encoded);
+		const formatted = formatter.format(raw);
+		const json = `${JSON.stringify(formatted, null, 2)}\n`;
+		yield* fs.writeFileString(target, json).pipe(Effect.mapError((cause) => new PackageJsonWriteError({
+			target,
+			cause
+		})));
+	}) });
+}));
+
+//#endregion
+export { PackageJsonWriterLive };

layers/WorkspaceResolverLive.js

+import { WorkspaceResolver } from "../services/WorkspaceResolver.js";
+import { Effect, Layer, Option } from "effect";
+
+//#region src/layers/WorkspaceResolverLive.ts
+/**
+* Default WorkspaceResolver: resolves nothing. Provide a real implementation
+* (e.g. backed by workspaces-effect) to resolve workspace: specifiers.
+*
+* @public
+*/
+const WorkspaceResolverLive = Layer.succeed(WorkspaceResolver, WorkspaceResolver.of({ versionOf: () => Effect.succeed(Option.none()) }));
+
+//#endregion
+export { WorkspaceResolverLive };

schemas/bin.js

+import { HashMap, Schema } from "effect";
+
+//#region src/schemas/bin.ts
+const BinMapSchema = Schema.transform(Schema.Record({
+	key: Schema.String,
+	value: Schema.String
+}), Schema.typeSchema(Schema.HashMap({
+	key: Schema.String,
+	value: Schema.String
+})), {
+	strict: true,
+	decode: (record) => HashMap.fromIterable(Object.entries(record)),
+	encode: (map) => Object.fromEntries(HashMap.toEntries(map))
+});
+/**
+* Bin field: either a single string path or a map of command names to paths.
+*
+* @public
+*/
+const BinSchema = Schema.Union(Schema.String, BinMapSchema);
+
+//#endregion
+export { BinSchema };

schemas/dependency-map.js

+import { HashMap, Schema } from "effect";
+
+//#region src/schemas/dependency-map.ts
+const StringRecord = Schema.Record({
+	key: Schema.String,
+	value: Schema.String
+});
+/**
+* A dependency map: plain JSON object decoded to/from HashMap.
+*
+* @public
+*/
+const DependencyMapSchema = Schema.transform(StringRecord, Schema.typeSchema(Schema.HashMap({
+	key: Schema.String,
+	value: Schema.String
+})), {
+	strict: true,
+	decode: (record) => HashMap.fromIterable(Object.entries(record)),
+	encode: (map) => Object.fromEntries(HashMap.toEntries(map))
+});
+
+//#endregion
+export { DependencyMapSchema };

schemas/dependency-specifier.js

+import { InvalidDependencySpecifierError } from "../errors/InvalidDependencySpecifierError.js";
+import { Effect, Schema } from "effect";
+
+//#region src/schemas/dependency-specifier.ts
+/**
+* Validates a dependency version specifier.
+*
+* Accepts semver ranges, exact versions, dist-tags, URLs,
+* git refs, GitHub shorthand, file paths, and npm/catalog/workspace protocols.
+*
+* @public
+*/
+const isValidDependencySpecifier = (s) => {
+	if (s.length === 0) return false;
+	if (s.startsWith("file:")) return true;
+	if (s.startsWith("link:")) return true;
+	if (s.startsWith("portal:")) return true;
+	if (s.startsWith("git+")) return true;
+	if (s.startsWith("git://")) return true;
+	if (s.startsWith("github:")) return true;
+	if (s.startsWith("gist:")) return true;
+	if (s.startsWith("bitbucket:")) return true;
+	if (s.startsWith("gitlab:")) return true;
+	if (s.startsWith("http://") || s.startsWith("https://")) return true;
+	if (s.startsWith("npm:")) return true;
+	if (s.startsWith("catalog:")) return true;
+	if (s.startsWith("workspace:")) return true;
+	if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(#.*)?$/.test(s)) return true;
+	if (/^[\d^~>=<*|xX]/.test(s)) return true;
+	if (/^[a-zA-Z][a-zA-Z0-9._-]*$/.test(s)) return true;
+	return false;
+};
+/**
+* A valid dependency version specifier.
+*
+* @public
+*/
+const DependencySpecifier = Schema.String.pipe(Schema.filter((s) => isValidDependencySpecifier(s) || "Expected a valid dependency specifier"), Schema.brand("DependencySpecifier"));
+/**
+* Opt-in decoder: validate a string as a DependencySpecifier, failing with a
+* typed InvalidDependencySpecifierError instead of a Schema ParseError.
+*
+* @public
+*/
+const decodeSpecifier = (input) => Schema.decodeUnknown(DependencySpecifier)(input).pipe(Effect.mapError(() => new InvalidDependencySpecifierError({
+	input,
+	reason: "Not a recognized dependency specifier"
+})));
+
+//#endregion
+export { DependencySpecifier, decodeSpecifier, isValidDependencySpecifier };

schemas/dev-engines.js

+import { Schema } from "effect";
+
+//#region src/schemas/dev-engines.ts
+const OnFail = Schema.Literal("warn", "error", "ignore");
+/**
+* A single engine constraint with name, optional version, and optional onFail behavior.
+*
+* @public
+*/
+var DevEngine = class extends Schema.Class("DevEngine")({
+	name: Schema.String,
+	version: Schema.optionalWith(Schema.String, { as: "Option" }),
+	onFail: Schema.optionalWith(OnFail, { as: "Option" })
+}) {};
+const DevEngineOrArray = Schema.Union(DevEngine, Schema.Array(DevEngine));
+/**
+* Schema for the devEngines field, modeling runtime and
+* package manager constraints with optional arrays.
+*
+* @public
+*/
+const DevEnginesSchema = Schema.Struct({
+	packageManager: Schema.optionalWith(DevEngineOrArray, { as: "Option" }),
+	runtime: Schema.optionalWith(DevEngineOrArray, { as: "Option" }),
+	os: Schema.optionalWith(DevEngineOrArray, { as: "Option" }),
+	cpu: Schema.optionalWith(DevEngineOrArray, { as: "Option" }),
+	libc: Schema.optionalWith(DevEngineOrArray, { as: "Option" })
+});
+
+//#endregion
+export { DevEngine, DevEnginesSchema };

schemas/engines.js

+import { HashMap, Schema } from "effect";
+
+//#region src/schemas/engines.ts
+/**
+* Engines field: map of engine names to semver ranges.
+*
+* @public
+*/
+const EnginesSchema = Schema.transform(Schema.Record({
+	key: Schema.String,
+	value: Schema.String
+}), Schema.typeSchema(Schema.HashMap({
+	key: Schema.String,
+	value: Schema.String
+})), {
+	strict: true,
+	decode: (record) => HashMap.fromIterable(Object.entries(record)),
+	encode: (map) => Object.fromEntries(HashMap.toEntries(map))
+});
+
+//#endregion
+export { EnginesSchema };

schemas/exports-field.js

+import { Schema } from "effect";
+
+//#region src/schemas/exports-field.ts
+const ExportsObject = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+/**
+* Exports field: either a single string entry point or an object
+* mapping subpaths to file paths (or null to block).
+*
+* The object form accepts any value shape to support conditional
+* exports with nested objects (e.g. `{ "import": "./esm.js", "require": "./cjs.js" }`).
+*
+* @public
+*/
+const ExportsFieldSchema = Schema.Union(Schema.String, ExportsObject);
+
+//#endregion
+export { ExportsFieldSchema };

schemas/license.js

+import { Schema } from "effect";
+import spdxParse from "spdx-expression-parse";
+
+//#region src/schemas/license.ts
+const isValidSpdx = (s) => {
+	if (s === "UNLICENSED") return true;
+	if (s.startsWith("SEE LICENSE IN ") && s.length > 15) return true;
+	try {
+		spdxParse(s);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* A valid SPDX license identifier, expression, "UNLICENSED",
+* or "SEE LICENSE IN filename".
+*
+* @public
+*/
+const SpdxLicense = Schema.String.pipe(Schema.filter((s) => isValidSpdx(s) || "Expected a valid SPDX license identifier or expression"), Schema.brand("SpdxLicense"));
+
+//#endregion
+export { SpdxLicense };

schemas/name.js

+import { Schema } from "effect";
+
+//#region src/schemas/name.ts
+/**
+* Validates a string as a valid npm package name.
+*
+* Rules: max 214 chars, lowercase, URL-safe characters only,
+* cannot start with . or _ (unless scoped).
+*
+* @public
+*/
+const isValidPackageName = (s) => {
+	if (s.length === 0 || s.length > 214) return false;
+	if (s.startsWith("@")) {
+		const slashIndex = s.indexOf("/");
+		if (slashIndex === -1 || slashIndex === 1 || slashIndex === s.length - 1) return false;
+		if (s.indexOf("/", slashIndex + 1) !== -1) return false;
+		const scope = s.slice(1, slashIndex);
+		const name = s.slice(slashIndex + 1);
+		return isValidNameChars(scope) && isValidNameChars(name);
+	}
+	if (s.startsWith(".") || s.startsWith("_")) return false;
+	return isValidNameChars(s);
+};
+const isValidNameChars = (s) => /^[a-z0-9._-]+$/.test(s);
+/**
+* A valid npm scoped package name (starts with \@scope/).
+*
+* @public
+*/
+const ScopedPackageName = Schema.String.pipe(Schema.filter((s) => s.startsWith("@") && isValidPackageName(s) || "Expected a scoped package name (@scope/name)"), Schema.brand("ScopedPackageName"));
+/**
+* A valid npm unscoped package name (does not start with \@).
+*
+* @public
+*/
+const UnscopedPackageName = Schema.String.pipe(Schema.filter((s) => !s.startsWith("@") && isValidPackageName(s) || "Expected an unscoped package name"), Schema.brand("UnscopedPackageName"));
+/**
+* A valid npm package name, either scoped or unscoped.
+*
+* @public
+*/
+const PackageName = Schema.Union(ScopedPackageName, UnscopedPackageName);
+
+//#endregion
+export { PackageName, ScopedPackageName, UnscopedPackageName, isValidPackageName };

schemas/package-json.js

+import { Package } from "../domain/Package.js";
+import { ParseResult, Schema } from "effect";
+
+//#region src/schemas/package-json.ts
+const RawJson = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+/**
+* Build the wire schema (open JSON object ↔ Package class) for the given
+* Package class or any `.extend()`ed subclass. Reads `Class.fields` so extended
+* fields are decoded as typed members and excluded from `rest`.
+*
+* The transform sits between an open JSON record (`RawJson`) and the class. On
+* decode it partitions raw keys into known fields and a `rest` record, handing
+* Effect the class's encoded shape so the class decodes itself. On encode it
+* receives the class's encoded shape and flattens the literal `rest` key back
+* into top-level fields, so the on-disk shape never contains a `rest` key.
+*
+* @public
+*/
+const makePackageJsonSchema = (Class) => {
+	const knownKeys = new Set(Object.keys(Class.fields).filter((k) => k !== "rest"));
+	return Schema.transformOrFail(RawJson, Class, {
+		strict: false,
+		decode: (raw) => {
+			const known = {};
+			const rest = {};
+			for (const [k, v] of Object.entries(raw)) if (knownKeys.has(k)) known[k] = v;
+			else rest[k] = v;
+			return ParseResult.succeed({
+				...known,
+				rest
+			});
+		},
+		encode: (encoded) => {
+			const { rest, ...known } = encoded;
+			return ParseResult.succeed({
+				...known,
+				...rest ?? {}
+			});
+		}
+	});
+};
+/**
+* The default wire schema: decodes JSON to a Package instance and back.
+*
+* @public
+*/
+const PackageJsonSchema = makePackageJsonSchema(Package);
+
+//#endregion
+export { PackageJsonSchema, makePackageJsonSchema };

schemas/package-manager.js

+import { Option, ParseResult, Schema } from "effect";
+
+//#region src/schemas/package-manager.ts
+/**
+* Structured packageManager value with name, version, and optional integrity.
+*
+* @public
+*/
+var PackageManager = class extends Schema.Class("PackageManager")({
+	name: Schema.String,
+	version: Schema.String,
+	integrity: Schema.optionalWith(Schema.String, { as: "Option" })
+}) {
+	get hasIntegrity() {
+		return Option.isSome(this.integrity);
+	}
+};
+const PACKAGE_MANAGER_REGEX = /^([a-z]+)@(\d+\.\d+\.\d+(?:-[a-zA-Z0-9._-]+)?)(?:\+(.+))?$/;
+/**
+* Parses a packageManager string (e.g. "pnpm\@10.33.0+sha512.abc")
+* into a PackageManager class instance with name, version, and
+* optional integrity fields.
+*
+* @public
+*/
+const PackageManagerSchema = Schema.transformOrFail(Schema.String, Schema.typeSchema(PackageManager), {
+	strict: true,
+	decode: (s, _options, ast) => {
+		const match = s.match(PACKAGE_MANAGER_REGEX);
+		if (!match) return ParseResult.fail(new ParseResult.Type(ast, s, `Invalid packageManager format: "${s}"`));
+		return ParseResult.succeed(new PackageManager({
+			name: match[1],
+			version: match[2],
+			integrity: match[3] ? Option.some(match[3]) : Option.none()
+		}, true));
+	},
+	encode: (pm) => {
+		let result = `${pm.name}@${pm.version}`;
+		if (Option.isSome(pm.integrity)) result += `+${pm.integrity.value}`;
+		return ParseResult.succeed(result);
+	}
+});
+
+//#endregion
+export { PackageManager, PackageManagerSchema };

schemas/person.js

+import { Schema } from "effect";
+
+//#region src/schemas/person.ts
+/**
+* Structured person object with name, optional email and url.
+*
+* @public
+*/
+var Person = class extends Schema.Class("Person")({
+	name: Schema.String,
+	email: Schema.optional(Schema.String),
+	url: Schema.optional(Schema.String)
+}) {};
+const parsePersonString = (s) => {
+	const emailMatch = s.match(/<([^>]+)>/);
+	const urlMatch = s.match(/\(([^)]+)\)/);
+	let name = s;
+	if (emailMatch) name = name.replace(emailMatch[0], "");
+	if (urlMatch) name = name.replace(urlMatch[0], "");
+	name = name.trim();
+	const fields = { name };
+	if (emailMatch) fields.email = emailMatch[1];
+	if (urlMatch) fields.url = urlMatch[1];
+	return new Person(fields, true);
+};
+const PersonFromString = Schema.transform(Schema.String, Schema.typeSchema(Person), {
+	strict: true,
+	decode: (s) => parsePersonString(s),
+	encode: (p) => {
+		let result = p.name;
+		if (p.email) result += ` <${p.email}>`;
+		if (p.url) result += ` (${p.url})`;
+		return result;
+	}
+});
+/**
+* Person field: either a string "Name email (url)" shorthand or a
+* structured object with name, email, and url fields.
+* Always decoded to the object form.
+*
+* @public
+*/
+const PersonSchema = Schema.Union(Person, PersonFromString);
+
+//#endregion
+export { Person, PersonSchema };

schemas/publish-config.js

+import { Schema } from "effect";
+
+//#region src/schemas/publish-config.ts
+/**
+* Schema for the publishConfig field with typed known fields
+* and an open record for arbitrary extensions like targets.
+*
+* @public
+*/
+const PublishConfigSchema = Schema.Struct({
+	access: Schema.optionalWith(Schema.Literal("public", "restricted"), { as: "Option" }),
+	directory: Schema.optionalWith(Schema.String, { as: "Option" }),
+	registry: Schema.optionalWith(Schema.String, { as: "Option" }),
+	linkDirectory: Schema.optionalWith(Schema.Boolean, { as: "Option" })
+}, {
+	key: Schema.String,
+	value: Schema.Unknown
+});
+
+//#endregion
+export { PublishConfigSchema };

schemas/scripts.js

+import { DependencyMapSchema } from "./dependency-map.js";
+
+//#region src/schemas/scripts.ts
+/**
+* Scripts field: plain JSON object decoded to/from HashMap of string to string.
+* Same structure as DependencyMapSchema.
+*
+* @public
+*/
+const ScriptsSchema = DependencyMapSchema;
+
+//#endregion
+export { ScriptsSchema };

schemas/version.js

+import { Effect, ParseResult, Schema } from "effect";
+import { SemVer, parseValidSemVer } from "semver-effect";
+
+//#region src/schemas/version.ts
+/**
+* Schema that decodes a version string into a SemVer instance
+* and encodes it back to a string. Uses semver-effect for parsing.
+*
+* @public
+*/
+const VersionSchema = Schema.transformOrFail(Schema.String, Schema.typeSchema(SemVer), {
+	strict: true,
+	decode: (input, _options, ast) => parseValidSemVer(input).pipe(Effect.mapError(() => new ParseResult.Type(ast, input, `Invalid semver version: "${input}"`))),
+	encode: (semver) => ParseResult.succeed(semver.toString())
+});
+
+//#endregion
+export { VersionSchema };

services/CatalogResolver.js

+import { Context } from "effect";
+
+//#region src/services/CatalogResolver.ts
+/**
+* Resolves catalog: protocol specifiers. Given a package name and an optional
+* catalog name (None = default catalog), returns the configured range, or None
+* if it cannot be resolved (default no-op behavior).
+*
+* @public
+*/
+var CatalogResolver = class extends Context.Tag("package-json-effect/CatalogResolver")() {};
+
+//#endregion
+export { CatalogResolver };

services/PackageJsonFormatter.js

+import { Context } from "effect";
+
+//#region src/services/PackageJsonFormatter.ts
+/**
+* Service for formatting/sorting a raw package.json object before serialization.
+* Operates on the encoded JSON object (post Schema.encode), not the domain model.
+*
+* @public
+*/
+var PackageJsonFormatter = class extends Context.Tag("package-json-effect/PackageJsonFormatter")() {};
+
+//#endregion
+export { PackageJsonFormatter };

services/PackageJsonReader.js

+import { Context } from "effect";
+
+//#region src/services/PackageJsonReader.ts
+/**
+* Service for reading and parsing package.json from a source.
+*
+* @public
+*/
+var PackageJsonReader = class extends Context.Tag("package-json-effect/PackageJsonReader")() {};
+
+//#endregion
+export { PackageJsonReader };

services/PackageJsonTransformer.js

+import { Context } from "effect";
+
+//#region src/services/PackageJsonTransformer.ts
+/**
+* Service for transforming the encoded package.json object before formatting.
+* Default implementation removes empty dependency map fields.
+*
+* @public
+*/
+var PackageJsonTransformer = class extends Context.Tag("package-json-effect/PackageJsonTransformer")() {};
+
+//#endregion
+export { PackageJsonTransformer };

services/PackageJsonValidator.js

+import { Context } from "effect";
+
+//#region src/services/PackageJsonValidator.ts
+/**
+* Service for validating a Package against a set of rules.
+*
+* @public
+*/
+var PackageJsonValidator = class extends Context.Tag("package-json-effect/PackageJsonValidator")() {};
+
+//#endregion
+export { PackageJsonValidator };

services/PackageJsonWriter.js

+import { Context } from "effect";
+
+//#region src/services/PackageJsonWriter.ts
+/**
+* Service for writing package.json to a target.
+*
+* @public
+*/
+var PackageJsonWriter = class extends Context.Tag("package-json-effect/PackageJsonWriter")() {};
+
+//#endregion
+export { PackageJsonWriter };

services/WorkspaceResolver.js

+import { Context } from "effect";
+
+//#region src/services/WorkspaceResolver.ts
+/**
+* Resolves workspace: protocol specifiers. Given a workspace package name,
+* returns its concrete version (without range modifier), or None if it cannot
+* be resolved (default no-op behavior).
+*
+* @public
+*/
+var WorkspaceResolver = class extends Context.Tag("package-json-effect/WorkspaceResolver")() {};
+
+//#endregion
+export { WorkspaceResolver };

index.d.ts

@@ -0,199 +1,189 @@
+import { Context, Effect, HashMap, Layer, Option, Schema } from "effect";
+import { InvalidVersionError, Range, SemVer } from "semver-effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/domain/Dependency.d.ts
 /**
- * package-json-effect
+ * The classification of a dependency specifier's protocol.
  *
- * Effect-TS library for reading, writing, parsing, manipulating,
- * and transforming package.json data.
- *
- * @packageDocumentation
+ * @public
  */
-
-import { Brand } from 'effect/Brand';
-import { Context } from 'effect';
-import { Effect } from 'effect';
-import { FileSystem } from '@effect/platform/FileSystem';
-import { FileSystem as FileSystem_2 } from '@effect/platform';
-import { HashMap } from 'effect';
-import type { InvalidVersionError } from 'semver-effect';
-import { Layer } from 'effect';
-import { Option } from 'effect';
-import { Option as Option_2 } from 'effect/Option';
-import type { Range } from 'semver-effect';
-import { Schema } from 'effect';
-import type { SemVer } from 'semver-effect';
-import { VoidIfEmpty } from 'effect/Types';
-import { YieldableError } from 'effect/Cause';
-
+type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
 /**
- * Resolves catalog: protocol specifiers. Given a package name and an optional
- * catalog name (None = default catalog), returns the configured range, or None
- * if it cannot be resolved (default no-op behavior).
+ * The shared protocol-classification getters implemented by every Dependency variant.
+ *
+ * @public
  */
-export declare class CatalogResolver extends CatalogResolver_base {
+interface DependencyProtocolGetters {
+  readonly protocol: Option.Option<DependencyProtocol>;
+  readonly range: Option.Option<Range>;
+  readonly isLocal: boolean;
+  readonly isLink: boolean;
+  readonly isPortal: boolean;
+  readonly isCatalog: boolean;
+  readonly isWorkspace: boolean;
+  readonly isUnresolved: boolean;
+  readonly isGit: boolean;
+  readonly isRange: boolean;
+  readonly isTag: boolean;
 }
-
-declare const CatalogResolver_base: Context.TagClass<CatalogResolver, "package-json-effect/CatalogResolver", {
-    readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
-}>;
-
 /**
- * Default CatalogResolver: resolves nothing. Provide a real implementation
- * (e.g. backed by workspaces-effect) to resolve catalog: specifiers.
+ * Returns true if the specifier points to a local path (file:, link:, portal:, or a bare path).
+ *
+ * @public
  */
-export declare const CatalogResolverLive: Layer.Layer<CatalogResolver>;
-
-export declare const defaultRules: ReadonlyArray<ValidationRule>;
-
-export declare class Dependency extends Dependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
+declare const isLocalSpecifier: (s: string) => boolean;
+/**
+ * Returns true if the specifier resolves to a git source (git URLs and hosted-git shorthands).
+ *
+ * @public
+ */
+declare const isGitSpecifier: (s: string) => boolean;
+/**
+ * Returns true if the specifier is a parseable semver range.
+ *
+ * @public
+ */
+declare const isRangeSpecifier: (s: string) => boolean;
+/**
+ * Returns true if the specifier is a dist-tag (e.g. "latest", "next").
+ *
+ * @public
+ */
+declare const isTagSpecifier: (s: string) => boolean;
+/**
+ * Parse the specifier as a semver Range, returning None when it is not a range.
+ *
+ * @public
+ */
+declare const parseRangeOption: (s: string) => Option.Option<Range>;
+/**
+ * Classify a specifier string into a single protocol; "unknown" for unrecognized input.
+ *
+ * @public
+ */
+declare const protocolOf: (s: string) => DependencyProtocol;
 declare const Dependency_base: Schema.TaggedClass<Dependency, "Dependency", {
-    readonly _tag: Schema.tag<"Dependency">;
+  readonly _tag: Schema.tag<"Dependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
 }>;
-
-export declare type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
-
-/** The shared protocol-classification getters implemented by every Dependency variant. */
-export declare interface DependencyProtocolGetters {
-    readonly protocol: Option.Option<DependencyProtocol>;
-    readonly range: Option.Option<Range>;
-    readonly isLocal: boolean;
-    readonly isLink: boolean;
-    readonly isPortal: boolean;
-    readonly isCatalog: boolean;
-    readonly isWorkspace: boolean;
-    readonly isUnresolved: boolean;
-    readonly isGit: boolean;
-    readonly isRange: boolean;
-    readonly isTag: boolean;
+/**
+ * A resolved dependency entry pairing a package name with its version specifier.
+ *
+ * @public
+ */
+declare class Dependency extends Dependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
-/** Indicates that a catalog: or workspace: specifier could not be resolved. */
-export declare class DependencyResolutionError extends DependencyResolutionErrorBase<{
-    /** The name of the package whose specifier could not be resolved. */
-    readonly packageName: string;
-    /** The specifier string (e.g. `catalog:` or `workspace:*`) that failed resolution. */
-    readonly specifier: string;
-    /** A human-readable description of why resolution failed. */
-    readonly reason: string;
-}> {
-    get message(): string;
-}
-
 /**
- * Tagged error base for {@link DependencyResolutionError}.
+ * A Dependency whose specifier is an unresolved catalog: or workspace: protocol.
  *
- * @privateRemarks
- * Exported because TypeScript declaration bundling requires the base class to be
- * accessible when {@link DependencyResolutionError} appears in public type signatures.
- * Consumers should use {@link DependencyResolutionError} directly.
+ * @public
+ */
+type UnresolvedDependency = Dependency & {
+  readonly isUnresolved: true;
+};
+/**
+ * Type guard narrowing any dependency-like value to UnresolvedDependency, preserving the concrete type.
  *
- * @internal
+ * @public
  */
-export declare const DependencyResolutionErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "DependencyResolutionError";
-} & Readonly<A>;
-
-export declare class DevDependency extends DevDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
+declare const isUnresolvedDependency: <T extends {
+  readonly isUnresolved: boolean;
+}>(dep: T) => dep is T & {
+  readonly isUnresolved: true;
+};
+//#endregion
+//#region src/domain/DevDependency.d.ts
 declare const DevDependency_base: Schema.TaggedClass<DevDependency, "DevDependency", {
-    readonly _tag: Schema.tag<"DevDependency">;
+  readonly _tag: Schema.tag<"DevDependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
 }>;
-
 /**
- * A single engine constraint with name, optional version, and optional onFail behavior.
+ * A `devDependencies` entry pairing a package name with its version specifier.
+ *
+ * @public
  */
-declare class DevEngine extends DevEngine_base {
+declare class DevDependency extends DevDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
-declare const DevEngine_base: Schema.Class<DevEngine, {
-    name: typeof Schema.String;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly name: string;
+//#endregion
+//#region src/domain/OptionalDependency.d.ts
+declare const OptionalDependency_base: Schema.TaggedClass<OptionalDependency, "OptionalDependency", {
+  readonly _tag: Schema.tag<"OptionalDependency">;
 } & {
-    readonly onFail: Option_2<"error" | "ignore" | "warn">;
-} & {
-    readonly version: Option_2<string>;
-}, {}, {}>;
-
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
+}>;
 /**
- * Indicates that a string could not be parsed as a valid dependency specifier.
+ * An `optionalDependencies` entry pairing a package name with its version specifier.
+ *
+ * @public
  */
-export declare class InvalidDependencySpecifierError extends InvalidDependencySpecifierErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the specifier is invalid. */
-    readonly reason: string;
-}> {
-    get message(): string;
+declare class OptionalDependency extends OptionalDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
+//#endregion
+//#region src/errors/DependencyResolutionError.d.ts
 /**
- * Tagged error base for {@link InvalidDependencySpecifierError}.
+ * Tagged error base for {@link DependencyResolutionError}.
  *
  * @privateRemarks
  * Exported because TypeScript declaration bundling requires the base class to be
- * accessible when {@link InvalidDependencySpecifierError} appears in public type signatures.
- * Consumers should use {@link InvalidDependencySpecifierError} directly.
+ * accessible when {@link DependencyResolutionError} appears in public type signatures.
+ * Consumers should use {@link DependencyResolutionError} directly.
  *
- * @internal
+ * @public
  */
-export declare const InvalidDependencySpecifierErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidDependencySpecifierError";
+declare const DependencyResolutionErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DependencyResolutionError";
 } & Readonly<A>;
-
 /**
- * Indicates that a string could not be used as a valid npm package name.
+ * Indicates that a catalog: or workspace: specifier could not be resolved.
+ *
+ * @public
  */
-export declare class InvalidPackageNameError extends InvalidPackageNameErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the name is invalid. */
-    readonly reason: string;
+declare class DependencyResolutionError extends DependencyResolutionErrorBase<{
+  /** The name of the package whose specifier could not be resolved. */readonly packageName: string; /** The specifier string (e.g. `catalog:` or `workspace:*`) that failed resolution. */
+  readonly specifier: string; /** A human-readable description of why resolution failed. */
+  readonly reason: string;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/InvalidPackageNameError.d.ts
 /**
@@ -207,18 +197,20 @@ * Tagged error base for {@link InvalidPackageNameError}.
  *
- * @internal
+ * @public
  */
-export declare const InvalidPackageNameErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidPackageNameError";
+declare const InvalidPackageNameErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidPackageNameError";
 } & Readonly<A>;
-
-/** Indicates that a string is not a valid SPDX license identifier or expression. */
-export declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the license identifier is invalid. */
-    readonly reason: string;
+/**
+ * Indicates that a string could not be used as a valid npm package name.
+ *
+ * @public
+ */
+declare class InvalidPackageNameError extends InvalidPackageNameErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the name is invalid. */
+  readonly reason: string;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/InvalidSpdxLicenseError.d.ts
 /**
@@ -232,475 +224,502 @@ * Tagged error base for {@link InvalidSpdxLicenseError}.
  *
- * @internal
+ * @public
  */
-export declare const InvalidSpdxLicenseErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidSpdxLicenseError";
+declare const InvalidSpdxLicenseErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidSpdxLicenseError";
 } & Readonly<A>;
-
-/** Returns true if the specifier resolves to a git source (git URLs and hosted-git shorthands). */
-export declare const isGitSpecifier: (s: string) => boolean;
-
-/** Returns true if the specifier points to a local path (file:, link:, portal:, or a bare path). */
-export declare const isLocalSpecifier: (s: string) => boolean;
-
-/** Returns true if the specifier is a parseable semver range. */
-export declare const isRangeSpecifier: (s: string) => boolean;
-
-/** Returns true if the specifier is a dist-tag (e.g. "latest", "next"). */
-export declare const isTagSpecifier: (s: string) => boolean;
-
-/** Type guard narrowing any dependency-like value to UnresolvedDependency, preserving the concrete type. */
-export declare const isUnresolvedDependency: <T extends {
-    readonly isUnresolved: boolean;
-}>(dep: T) => dep is T & {
-    readonly isUnresolved: true;
-};
-
-export declare const makePackageJsonValidatorLive: (config: {
-    rules: ReadonlyArray<ValidationRule>;
-}) => Layer.Layer<PackageJsonValidator>;
-
-export declare const noLocalDepsRule: ValidationRule;
-
-export declare const noUnresolvedDepsRule: ValidationRule;
-
-export declare class OptionalDependency extends OptionalDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
+/**
+ * Indicates that a string is not a valid SPDX license identifier or expression.
+ *
+ * @public
+ */
+declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the license identifier is invalid. */
+  readonly reason: string;
+}> {
+  get message(): string;
 }
-
-declare const OptionalDependency_base: Schema.TaggedClass<OptionalDependency, "OptionalDependency", {
-    readonly _tag: Schema.tag<"OptionalDependency">;
+//#endregion
+//#region src/services/CatalogResolver.d.ts
+declare const CatalogResolver_base: Context.TagClass<CatalogResolver, "package-json-effect/CatalogResolver", {
+  readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+}>;
+/**
+ * Resolves catalog: protocol specifiers. Given a package name and an optional
+ * catalog name (None = default catalog), returns the configured range, or None
+ * if it cannot be resolved (default no-op behavior).
+ *
+ * @public
+ */
+declare class CatalogResolver extends CatalogResolver_base {}
+//#endregion
+//#region src/services/WorkspaceResolver.d.ts
+declare const WorkspaceResolver_base: Context.TagClass<WorkspaceResolver, "package-json-effect/WorkspaceResolver", {
+  readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+}>;
+/**
+ * Resolves workspace: protocol specifiers. Given a workspace package name,
+ * returns its concrete version (without range modifier), or None if it cannot
+ * be resolved (default no-op behavior).
+ *
+ * @public
+ */
+declare class WorkspaceResolver extends WorkspaceResolver_base {}
+//#endregion
+//#region src/domain/PeerDependency.d.ts
+declare const PeerDependency_base: Schema.TaggedClass<PeerDependency, "PeerDependency", {
+  readonly _tag: Schema.tag<"PeerDependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
+  isOptional: typeof Schema.Boolean;
 }>;
-
 /**
- * Domain model for a package.json document. A Schema.Class carrying typed
- * known fields plus a `rest` catch-all that preserves any unmodeled top-level
- * fields for round-trip fidelity. The literal `rest` key is flattened away by
- * the wire transform in src/schemas/package-json.ts.
+ * A `peerDependencies` entry pairing a package name, version specifier, and optionality flag.
+ *
+ * @public
  */
-export declare class Package extends Package_base {
-    get isPrivate(): boolean;
-    get isScoped(): boolean;
-    get isESM(): boolean;
-    pipe<A>(this: A): A;
-    pipe<A, B>(this: A, ab: (_: A) => B): B;
-    pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
-    pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
-    pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
-    hasDependency(name: string): boolean;
-    getDependencies(): HashMap.HashMap<string, Dependency>;
-    getDevDependencies(): HashMap.HashMap<string, DevDependency>;
-    getPeerDependencies(): HashMap.HashMap<string, PeerDependency>;
-    getOptionalDependencies(): HashMap.HashMap<string, OptionalDependency>;
-    /** Return a new Package with the given fields replaced. */
-    copyWith(patch: Partial<{
-        name: string;
-        version: SemVer;
-        license: Option.Option<string>;
-        dependencies: HashMap.HashMap<string, string>;
-        devDependencies: HashMap.HashMap<string, string>;
-        peerDependencies: HashMap.HashMap<string, string>;
-        optionalDependencies: HashMap.HashMap<string, string>;
-        scripts: HashMap.HashMap<string, string>;
-    }>): Package;
-    /** Construct a Package from an already-decoded data record. */
-    static fromData(data: ConstructorParameters<typeof Package>[0]): Package;
-    static setVersion: {
-        (version: string): (pkg: Package) => Effect.Effect<Package, InvalidVersionError>;
-        (pkg: Package, version: string): Effect.Effect<Package, InvalidVersionError>;
-    };
-    static setName: {
-        (name: string): (pkg: Package) => Effect.Effect<Package, InvalidPackageNameError>;
-        (pkg: Package, name: string): Effect.Effect<Package, InvalidPackageNameError>;
-    };
-    static addDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addDevDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeDevDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addPeerDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removePeerDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addOptionalDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeOptionalDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static setScript: {
-        (name: string, command: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, command: string): Package;
-    };
-    static removeScript: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static setLicense: {
-        (license: string): (pkg: Package) => Effect.Effect<Package, InvalidSpdxLicenseError>;
-        (pkg: Package, license: string): Effect.Effect<Package, InvalidSpdxLicenseError>;
-    };
-    /**
-     * Resolve catalog: and workspace: specifiers across all four dependency maps
-     * using the CatalogResolver and WorkspaceResolver from context. Returns a new
-     * Package. Specifiers the resolvers return None for are left unchanged.
-     */
-    static resolve(pkg: Package): Effect.Effect<Package, DependencyResolutionError, WorkspaceResolver | CatalogResolver>;
+declare class PeerDependency extends PeerDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
+//#endregion
+//#region src/domain/Package.d.ts
 declare const Package_base: Schema.Class<Package, {
-    name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-    version: Schema.Schema<SemVer, string, never>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
+  version: Schema.Schema<SemVer, string, never>;
+  description: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
+    as: "Option";
+  }>;
+  type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
+    as: "Option";
+  }>;
+  main: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  license: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    optional: Schema.optional<typeof Schema.Boolean>;
+  }>>, {
+    as: "Option";
+  }>;
+  scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
+    as: "Option";
+  }>;
+  publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
+    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+      as: "Option";
     }>;
-    private: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
+    directory: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
-        as: "Option";
+    registry: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    main: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+    linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
+      as: "Option";
     }>;
-    license: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  }, readonly [{
+    readonly key: typeof Schema.String;
+    readonly value: typeof Schema.Unknown;
+  }]>, {
+    as: "Option";
+  }>;
+  packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
+    as: "Option";
+  }>;
+  devEngines: Schema.optionalWith<Schema.Struct<{
+    packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
-        optional: Schema.optional<typeof Schema.Boolean>;
-    }>>, {
-        as: "Option";
-    }>;
-    scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
-    }>;
-    bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        as: "Option";
-    }>;
-    publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
-        access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
-            as: "Option";
-        }>;
-        directory: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        registry: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
-            as: "Option";
-        }>;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>, {
-        as: "Option";
-    }>;
-    packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
-        as: "Option";
-    }>;
-    devEngines: Schema.optionalWith<Schema.Struct<{
-        packageManager: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        runtime: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        os: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        cpu: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        libc: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-    }>, {
-        as: "Option";
-    }>;
-    rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
-        default: () => Record<string, unknown>;
-    }>;
+  }>, {
+    as: "Option";
+  }>;
+  rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
+    default: () => Record<string, unknown>;
+  }>;
 }, Schema.Struct.Encoded<{
-    name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-    version: Schema.Schema<SemVer, string, never>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
+  version: Schema.Schema<SemVer, string, never>;
+  description: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
+    as: "Option";
+  }>;
+  type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
+    as: "Option";
+  }>;
+  main: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  license: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    optional: Schema.optional<typeof Schema.Boolean>;
+  }>>, {
+    as: "Option";
+  }>;
+  scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
+    as: "Option";
+  }>;
+  publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
+    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+      as: "Option";
     }>;
-    private: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
+    directory: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
-        as: "Option";
+    registry: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    main: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+    linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
+      as: "Option";
     }>;
-    license: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  }, readonly [{
+    readonly key: typeof Schema.String;
+    readonly value: typeof Schema.Unknown;
+  }]>, {
+    as: "Option";
+  }>;
+  packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
+    as: "Option";
+  }>;
+  devEngines: Schema.optionalWith<Schema.Struct<{
+    packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
-        optional: Schema.optional<typeof Schema.Boolean>;
-    }>>, {
-        as: "Option";
-    }>;
-    scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
-    }>;
-    bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        as: "Option";
-    }>;
-    publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
-        access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
-            as: "Option";
-        }>;
-        directory: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        registry: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
-            as: "Option";
-        }>;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>, {
-        as: "Option";
-    }>;
-    packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
-        as: "Option";
-    }>;
-    devEngines: Schema.optionalWith<Schema.Struct<{
-        packageManager: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        runtime: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        os: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        cpu: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        libc: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-    }>, {
-        as: "Option";
-    }>;
-    rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
-        default: () => Record<string, unknown>;
-    }>;
+  }>, {
+    as: "Option";
+  }>;
+  rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
+    default: () => Record<string, unknown>;
+  }>;
 }>, never, {
-    readonly dependencies?: HashMap.HashMap<string, string>;
+  readonly dependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly devDependencies?: HashMap.HashMap<string, string>;
+  readonly devDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly optionalDependencies?: HashMap.HashMap<string, string>;
+  readonly optionalDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly peerDependencies?: HashMap.HashMap<string, string>;
+  readonly peerDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly rest?: {
-        readonly [x: string]: unknown;
-    };
+  readonly rest?: {
+    readonly [x: string]: unknown;
+  } | undefined;
 } & {
-    readonly scripts?: HashMap.HashMap<string, string>;
+  readonly scripts?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly bin: Option.Option<string | HashMap.HashMap<string, string>>;
+  readonly bin: Option.Option<string | HashMap.HashMap<string, string>>;
 } & {
-    readonly description: Option.Option<string>;
+  readonly description: Option.Option<string>;
 } & {
-    readonly devEngines: Option.Option<{
-        readonly packageManager: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly runtime: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly os: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly cpu: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly libc: Option.Option<DevEngine | readonly DevEngine[]>;
-    }>;
+  readonly devEngines: Option.Option<{
+    readonly packageManager: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly runtime: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly os: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly cpu: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly libc: Option.Option<DevEngine | readonly DevEngine[]>;
+  }>;
 } & {
-    readonly engines: Option.Option<HashMap.HashMap<string, string>>;
+  readonly engines: Option.Option<HashMap.HashMap<string, string>>;
 } & {
-    readonly exports: Option.Option<string | {
-        readonly [x: string]: unknown;
-    }>;
+  readonly exports: Option.Option<string | {
+    readonly [x: string]: unknown;
+  }>;
 } & {
-    readonly license: Option.Option<string>;
+  readonly license: Option.Option<string>;
 } & {
-    readonly main: Option.Option<string>;
+  readonly main: Option.Option<string>;
 } & {
-    readonly name: (string & Brand<"ScopedPackageName">) | (string & Brand<"UnscopedPackageName">);
+  readonly name: (string & import("effect/Brand").Brand<"ScopedPackageName">) | (string & import("effect/Brand").Brand<"UnscopedPackageName">);
 } & {
-    readonly packageManager: Option.Option<PackageManager>;
+  readonly packageManager: Option.Option<PackageManager>;
 } & {
-    readonly peerDependenciesMeta: Option.Option<{
-        readonly [x: string]: {
-            readonly optional?: boolean | undefined;
-        };
-    }>;
+  readonly peerDependenciesMeta: Option.Option<{
+    readonly [x: string]: {
+      readonly optional?: boolean | undefined;
+    };
+  }>;
 } & {
-    readonly private: Option.Option<boolean>;
+  readonly private: Option.Option<boolean>;
 } & {
-    readonly publishConfig: Option.Option<{
-        readonly [x: string]: unknown;
-        readonly access: Option.Option<"public" | "restricted">;
-        readonly directory: Option.Option<string>;
-        readonly registry: Option.Option<string>;
-        readonly linkDirectory: Option.Option<boolean>;
-    }>;
+  readonly publishConfig: Option.Option<{
+    readonly [x: string]: unknown;
+    readonly access: Option.Option<"public" | "restricted">;
+    readonly directory: Option.Option<string>;
+    readonly registry: Option.Option<string>;
+    readonly linkDirectory: Option.Option<boolean>;
+  }>;
 } & {
-    readonly type: Option.Option<"commonjs" | "module">;
+  readonly type: Option.Option<"commonjs" | "module">;
 } & {
-    readonly version: SemVer;
+  readonly version: SemVer;
 }, {}, {}>;
-
 /**
- * Indicates that a parsed JSON value could not be decoded into a valid PackageJson structure.
+ * Domain model for a package.json document. A Schema.Class carrying typed
+ * known fields plus a `rest` catch-all that preserves any unmodeled top-level
+ * fields for round-trip fidelity. The literal `rest` key is flattened away by
+ * the wire transform in src/schemas/package-json.ts.
+ *
+ * @public
  */
-export declare class PackageJsonDecodeError extends PackageJsonDecodeErrorBase<{
-    /** The raw value that failed to decode. */
-    readonly input: unknown;
-    /** A human-readable description of the decode failure. */
-    readonly message: string;
-}> {
+declare class Package extends Package_base {
+  get isPrivate(): boolean;
+  get isScoped(): boolean;
+  get isESM(): boolean;
+  pipe<A>(this: A): A;
+  pipe<A, B>(this: A, ab: (_: A) => B): B;
+  pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+  pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+  pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+  hasDependency(name: string): boolean;
+  getDependencies(): HashMap.HashMap<string, Dependency>;
+  getDevDependencies(): HashMap.HashMap<string, DevDependency>;
+  getPeerDependencies(): HashMap.HashMap<string, PeerDependency>;
+  getOptionalDependencies(): HashMap.HashMap<string, OptionalDependency>;
+  /** Return a new Package with the given fields replaced. */
+  copyWith(patch: Partial<{
+    name: string;
+    version: SemVer;
+    license: Option.Option<string>;
+    dependencies: HashMap.HashMap<string, string>;
+    devDependencies: HashMap.HashMap<string, string>;
+    peerDependencies: HashMap.HashMap<string, string>;
+    optionalDependencies: HashMap.HashMap<string, string>;
+    scripts: HashMap.HashMap<string, string>;
+  }>): Package;
+  /** Construct a Package from an already-decoded data record. */
+  static fromData(data: ConstructorParameters<typeof Package>[0]): Package;
+  static setVersion: {
+    (version: string): (pkg: Package) => Effect.Effect<Package, InvalidVersionError>;
+    (pkg: Package, version: string): Effect.Effect<Package, InvalidVersionError>;
+  };
+  static setName: {
+    (name: string): (pkg: Package) => Effect.Effect<Package, InvalidPackageNameError>;
+    (pkg: Package, name: string): Effect.Effect<Package, InvalidPackageNameError>;
+  };
+  static addDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addDevDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeDevDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addPeerDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removePeerDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addOptionalDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeOptionalDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static setScript: {
+    (name: string, command: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, command: string): Package;
+  };
+  static removeScript: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static setLicense: {
+    (license: string): (pkg: Package) => Effect.Effect<Package, InvalidSpdxLicenseError>;
+    (pkg: Package, license: string): Effect.Effect<Package, InvalidSpdxLicenseError>;
+  };
+  /**
+   * Resolve catalog: and workspace: specifiers across all four dependency maps
+   * using the CatalogResolver and WorkspaceResolver from context. Returns a new
+   * Package. Specifiers the resolvers return None for are left unchanged.
+   */
+  static resolve(pkg: Package): Effect.Effect<Package, DependencyResolutionError, WorkspaceResolver | CatalogResolver>;
 }
-
+//#endregion
+//#region src/domain/PackageName.d.ts
 /**
- * Tagged error base for {@link PackageJsonDecodeError}.
+ * Utility functions for working with package name strings.
  *
+ * @public
+ */
+declare const PackageNameUtil: {
+  scope: (name: string) => Option.Option<string>;
+  unscoped: (name: string) => string;
+  isScoped: (name: string) => boolean;
+};
+//#endregion
+//#region src/errors/InvalidDependencySpecifierError.d.ts
+/**
+ * Tagged error base for {@link InvalidDependencySpecifierError}.
+ *
  * @privateRemarks
  * Exported because TypeScript declaration bundling requires the base class to be
- * accessible when {@link PackageJsonDecodeError} appears in public type signatures.
- * Consumers should use {@link PackageJsonDecodeError} directly.
+ * accessible when {@link InvalidDependencySpecifierError} appears in public type signatures.
+ * Consumers should use {@link InvalidDependencySpecifierError} directly.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonDecodeErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonDecodeError";
+declare const InvalidDependencySpecifierErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidDependencySpecifierError";
 } & Readonly<A>;
-
 /**
- * Service for formatting/sorting a raw package.json object before serialization.
- * Operates on the encoded JSON object (post Schema.encode), not the domain model.
+ * Indicates that a string could not be parsed as a valid dependency specifier.
+ *
+ * @public
  */
-export declare class PackageJsonFormatter extends PackageJsonFormatter_base {
+declare class InvalidDependencySpecifierError extends InvalidDependencySpecifierErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the specifier is invalid. */
+  readonly reason: string;
+}> {
+  get message(): string;
 }
-
-declare const PackageJsonFormatter_base: Context.TagClass<PackageJsonFormatter, "package-json-effect/PackageJsonFormatter", {
-    readonly format: (raw: Record<string, unknown>) => Record<string, unknown>;
-}>;
-
-export declare const PackageJsonFormatterLive: Layer.Layer<PackageJsonFormatter>;
-
+//#endregion
+//#region src/errors/PackageJsonDecodeError.d.ts
 /**
- * Composite layer providing all package-json-effect services.
- * Requires \@effect/platform FileSystem to be provided by the consumer.
+ * Tagged error base for {@link PackageJsonDecodeError}.
+ *
+ * @privateRemarks
+ * Exported because TypeScript declaration bundling requires the base class to be
+ * accessible when {@link PackageJsonDecodeError} appears in public type signatures.
+ * Consumers should use {@link PackageJsonDecodeError} directly.
+ *
+ * @public
  */
-export declare const PackageJsonLive: Layer.Layer<CatalogResolver | PackageJsonFormatter | PackageJsonReader | PackageJsonTransformer | PackageJsonValidator | PackageJsonWriter | WorkspaceResolver, never, FileSystem>;
-
+declare const PackageJsonDecodeErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonDecodeError";
+} & Readonly<A>;
 /**
- * Indicates that a package.json file was not found at the expected location.
+ * Indicates that a parsed JSON value could not be decoded into a valid PackageJson structure.
+ *
+ * @public
  */
-export declare class PackageJsonNotFoundError extends PackageJsonNotFoundErrorBase<{
-    /** The file path or location where package.json was expected but not found. */
-    readonly source: string;
-}> {
-    get message(): string;
-}
-
+declare class PackageJsonDecodeError extends PackageJsonDecodeErrorBase<{
+  /** The raw value that failed to decode. */readonly input: unknown; /** A human-readable description of the decode failure. */
+  readonly message: string;
+}> {}
+//#endregion
+//#region src/errors/PackageJsonNotFoundError.d.ts
 /**
@@ -714,20 +733,19 @@ * Tagged error base for {@link PackageJsonNotFoundError}.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonNotFoundError";
+declare const PackageJsonNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonNotFoundError";
 } & Readonly<A>;
-
 /**
- * Indicates that a string could not be parsed as valid JSON for a package.json file.
+ * Indicates that a package.json file was not found at the expected location.
+ *
+ * @public
  */
-export declare class PackageJsonParseError extends PackageJsonParseErrorBase<{
-    /** The raw input string that failed to parse. */
-    readonly input: string;
-    /** The character position where parsing failed, if available. */
-    readonly position: Option.Option<number>;
+declare class PackageJsonNotFoundError extends PackageJsonNotFoundErrorBase<{
+  /** The file path or location where package.json was expected but not found. */readonly source: string;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/PackageJsonParseError.d.ts
 /**
@@ -741,32 +759,20 @@ * Tagged error base for {@link PackageJsonParseError}.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonParseErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonParseError";
+declare const PackageJsonParseErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonParseError";
 } & Readonly<A>;
-
 /**
- * Service for reading and parsing package.json from a source.
+ * Indicates that a string could not be parsed as valid JSON for a package.json file.
+ *
+ * @public
  */
-export declare class PackageJsonReader extends PackageJsonReader_base {
-}
-
-declare const PackageJsonReader_base: Context.TagClass<PackageJsonReader, "package-json-effect/PackageJsonReader", {
-    readonly read: (source: string) => Effect.Effect<Package, PackageJsonReadError | PackageJsonNotFoundError | PackageJsonParseError | PackageJsonDecodeError>;
-}>;
-
-export declare const PackageJsonReaderLive: Layer.Layer<PackageJsonReader, never, FileSystem_2.FileSystem>;
-
-/**
- * Indicates that a package.json file could not be read from the filesystem.
- */
-export declare class PackageJsonReadError extends PackageJsonReadErrorBase<{
-    /** The file path or source location that could not be read. */
-    readonly source: string;
-    /** The underlying error or reason for the failure. */
-    readonly cause: unknown;
+declare class PackageJsonParseError extends PackageJsonParseErrorBase<{
+  /** The raw input string that failed to parse. */readonly input: string; /** The character position where parsing failed, if available. */
+  readonly position: Option.Option<number>;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/PackageJsonReadError.d.ts
 /**
@@ -780,35 +786,33 @@ * Tagged error base for {@link PackageJsonReadError}.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonReadErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonReadError";
+declare const PackageJsonReadErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonReadError";
 } & Readonly<A>;
-
 /**
- * Service for transforming the encoded package.json object before formatting.
- * Default implementation removes empty dependency map fields.
+ * Indicates that a package.json file could not be read from the filesystem.
+ *
+ * @public
  */
-export declare class PackageJsonTransformer extends PackageJsonTransformer_base {
+declare class PackageJsonReadError extends PackageJsonReadErrorBase<{
+  /** The file path or source location that could not be read. */readonly source: string; /** The underlying error or reason for the failure. */
+  readonly cause: unknown;
+}> {
+  get message(): string;
 }
-
-declare const PackageJsonTransformer_base: Context.TagClass<PackageJsonTransformer, "package-json-effect/PackageJsonTransformer", {
-    readonly transform: (raw: Record<string, unknown>) => Effect.Effect<Record<string, unknown>>;
-}>;
-
+//#endregion
+//#region src/errors/PackageJsonValidationError.d.ts
 /**
- * Default PackageJsonTransformer: removes empty dependency map fields.
- * Replace or compose with custom transformers for additional processing.
+ * Describes a single rule failure during package.json validation.
+ *
+ * @public
  */
-export declare const PackageJsonTransformerLive: Layer.Layer<PackageJsonTransformer>;
-
-/**
- * Indicates that a package.json file failed one or more validation rules.
- */
-export declare class PackageJsonValidationError extends PackageJsonValidationErrorBase<{
-    /** The list of rule failures encountered during validation. */
-    readonly failures: ReadonlyArray<ValidationRuleFailure>;
-}> {
-    get message(): string;
+interface ValidationRuleFailure {
+  /** The identifier of the validation rule that failed. */
+  readonly rule: string;
+  /** A human-readable description of the failure. */
+  readonly message: string;
+  /** The JSON path within the package.json where the failure occurred, if applicable. */
+  readonly path: Option.Option<string>;
 }
-
 /**
@@ -822,32 +826,19 @@ * Tagged error base for {@link PackageJsonValidationError}.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonValidationErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonValidationError";
+declare const PackageJsonValidationErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonValidationError";
 } & Readonly<A>;
-
 /**
- * Service for validating a Package against a set of rules.
+ * Indicates that a package.json file failed one or more validation rules.
+ *
+ * @public
  */
-export declare class PackageJsonValidator extends PackageJsonValidator_base {
-}
-
-declare const PackageJsonValidator_base: Context.TagClass<PackageJsonValidator, "package-json-effect/PackageJsonValidator", {
-    readonly validate: (pkg: Package) => Effect.Effect<Package, PackageJsonValidationError>;
-}>;
-
-export declare const PackageJsonValidatorLive: Layer.Layer<PackageJsonValidator>;
-
-/**
- * Indicates that a package.json file could not be written to the filesystem.
- */
-export declare class PackageJsonWriteError extends PackageJsonWriteErrorBase<{
-    /** The file path or target location that could not be written. */
-    readonly target: string;
-    /** The underlying error or reason for the failure. */
-    readonly cause: unknown;
+declare class PackageJsonValidationError extends PackageJsonValidationErrorBase<{
+  /** The list of rule failures encountered during validation. */readonly failures: ReadonlyArray<ValidationRuleFailure>;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/PackageJsonWriteError.d.ts
 /**
@@ -861,153 +852,294 @@ * Tagged error base for {@link PackageJsonWriteError}.
  *
- * @internal
+ * @public
  */
-export declare const PackageJsonWriteErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "PackageJsonWriteError";
+declare const PackageJsonWriteErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonWriteError";
 } & Readonly<A>;
-
 /**
- * Service for writing package.json to a target.
+ * Indicates that a package.json file could not be written to the filesystem.
+ *
+ * @public
  */
-export declare class PackageJsonWriter extends PackageJsonWriter_base {
+declare class PackageJsonWriteError extends PackageJsonWriteErrorBase<{
+  /** The file path or target location that could not be written. */readonly target: string; /** The underlying error or reason for the failure. */
+  readonly cause: unknown;
+}> {
+  get message(): string;
 }
-
+//#endregion
+//#region src/layers/CatalogResolverLive.d.ts
+/**
+ * Default CatalogResolver: resolves nothing. Provide a real implementation
+ * (e.g. backed by workspaces-effect) to resolve catalog: specifiers.
+ *
+ * @public
+ */
+declare const CatalogResolverLive: Layer.Layer<CatalogResolver>;
+//#endregion
+//#region src/services/PackageJsonFormatter.d.ts
+declare const PackageJsonFormatter_base: Context.TagClass<PackageJsonFormatter, "package-json-effect/PackageJsonFormatter", {
+  readonly format: (raw: Record<string, unknown>) => Record<string, unknown>;
+}>;
+/**
+ * Service for formatting/sorting a raw package.json object before serialization.
+ * Operates on the encoded JSON object (post Schema.encode), not the domain model.
+ *
+ * @public
+ */
+declare class PackageJsonFormatter extends PackageJsonFormatter_base {}
+//#endregion
+//#region src/layers/PackageJsonFormatterLive.d.ts
+/**
+ * Live Layer providing the PackageJsonFormatter service, which orders top-level
+ * keys canonically and alphabetizes dependency maps.
+ *
+ * @public
+ */
+declare const PackageJsonFormatterLive: Layer.Layer<PackageJsonFormatter>;
+//#endregion
+//#region src/layers/PackageJsonLive.d.ts
+/**
+ * Composite layer providing all package-json-effect services.
+ * Requires \@effect/platform FileSystem to be provided by the consumer.
+ *
+ * @public
+ */
+declare const PackageJsonLive: Layer.Layer<CatalogResolver | PackageJsonFormatter | PackageJsonReader | PackageJsonTransformer | PackageJsonValidator | PackageJsonWriter | WorkspaceResolver, never, import("@effect/platform/FileSystem").FileSystem>;
+//#endregion
+//#region src/services/PackageJsonReader.d.ts
+declare const PackageJsonReader_base: Context.TagClass<PackageJsonReader, "package-json-effect/PackageJsonReader", {
+  readonly read: (source: string) => Effect.Effect<Package, PackageJsonReadError | PackageJsonNotFoundError | PackageJsonParseError | PackageJsonDecodeError>;
+}>;
+/**
+ * Service for reading and parsing package.json from a source.
+ *
+ * @public
+ */
+declare class PackageJsonReader extends PackageJsonReader_base {}
+//#endregion
+//#region src/layers/PackageJsonReaderLive.d.ts
+/**
+ * Live Layer providing the PackageJsonReader service backed by \@effect/platform
+ * FileSystem.
+ *
+ * @public
+ */
+declare const PackageJsonReaderLive: Layer.Layer<PackageJsonReader, never, FileSystem.FileSystem>;
+//#endregion
+//#region src/services/PackageJsonTransformer.d.ts
+declare const PackageJsonTransformer_base: Context.TagClass<PackageJsonTransformer, "package-json-effect/PackageJsonTransformer", {
+  readonly transform: (raw: Record<string, unknown>) => Effect.Effect<Record<string, unknown>>;
+}>;
+/**
+ * Service for transforming the encoded package.json object before formatting.
+ * Default implementation removes empty dependency map fields.
+ *
+ * @public
+ */
+declare class PackageJsonTransformer extends PackageJsonTransformer_base {}
+//#endregion
+//#region src/layers/PackageJsonTransformerLive.d.ts
+/**
+ * Default PackageJsonTransformer: removes empty dependency map fields.
+ * Replace or compose with custom transformers for additional processing.
+ *
+ * @public
+ */
+declare const PackageJsonTransformerLive: Layer.Layer<PackageJsonTransformer>;
+//#endregion
+//#region src/services/PackageJsonValidator.d.ts
+/**
+ * A single validation rule failure.
+ *
+ * @public
+ */
+interface RuleFailure {
+  readonly message: string;
+  readonly path?: Option.Option<string>;
+}
+/**
+ * A single validation rule.
+ *
+ * @public
+ */
+interface ValidationRule {
+  readonly name: string;
+  readonly validate: (pkg: Package) => Effect.Effect<void, RuleFailure>;
+}
+declare const PackageJsonValidator_base: Context.TagClass<PackageJsonValidator, "package-json-effect/PackageJsonValidator", {
+  readonly validate: (pkg: Package) => Effect.Effect<Package, PackageJsonValidationError>;
+}>;
+/**
+ * Service for validating a Package against a set of rules.
+ *
+ * @public
+ */
+declare class PackageJsonValidator extends PackageJsonValidator_base {}
+//#endregion
+//#region src/layers/PackageJsonValidatorLive.d.ts
+/**
+ * Validation rule that fails when any dependency uses an unresolved
+ * workspace: or catalog: specifier.
+ *
+ * @public
+ */
+declare const noUnresolvedDepsRule: ValidationRule;
+/**
+ * Validation rule that fails when any dependency uses a local
+ * file:, link:, or portal: specifier.
+ *
+ * @public
+ */
+declare const noLocalDepsRule: ValidationRule;
+/**
+ * Default set of validation rules: license, description, repository, and
+ * not-private checks.
+ *
+ * @public
+ */
+declare const defaultRules: ReadonlyArray<ValidationRule>;
+/**
+ * Live Layer providing the PackageJsonValidator service backed by the
+ * default rule set.
+ *
+ * @public
+ */
+declare const PackageJsonValidatorLive: Layer.Layer<PackageJsonValidator>;
+/**
+ * Builds a PackageJsonValidator Layer from a custom set of validation rules.
+ *
+ * @public
+ */
+declare const makePackageJsonValidatorLive: (config: {
+  rules: ReadonlyArray<ValidationRule>;
+}) => Layer.Layer<PackageJsonValidator>;
+//#endregion
+//#region src/services/PackageJsonWriter.d.ts
 declare const PackageJsonWriter_base: Context.TagClass<PackageJsonWriter, "package-json-effect/PackageJsonWriter", {
-    readonly write: (target: string, pkg: Package) => Effect.Effect<void, PackageJsonWriteError>;
+  readonly write: (target: string, pkg: Package) => Effect.Effect<void, PackageJsonWriteError>;
 }>;
-
-export declare const PackageJsonWriterLive: Layer.Layer<PackageJsonWriter, never, FileSystem_2.FileSystem | PackageJsonFormatter | CatalogResolver | WorkspaceResolver | PackageJsonTransformer>;
-
-declare class PackageManager extends PackageManager_base {
-    get hasIntegrity(): boolean;
-}
-
-declare const PackageManager_base: Schema.Class<PackageManager, {
-    name: typeof Schema.String;
-    version: typeof Schema.String;
-    integrity: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+/**
+ * Service for writing package.json to a target.
+ *
+ * @public
+ */
+declare class PackageJsonWriter extends PackageJsonWriter_base {}
+//#endregion
+//#region src/layers/PackageJsonWriterLive.d.ts
+/**
+ * Live Layer providing the PackageJsonWriter service, which resolves
+ * catalog:/workspace: protocols, transforms, formats, and writes package.json.
+ *
+ * @public
+ */
+declare const PackageJsonWriterLive: Layer.Layer<PackageJsonWriter, never, FileSystem.FileSystem | PackageJsonFormatter | CatalogResolver | WorkspaceResolver | PackageJsonTransformer>;
+//#endregion
+//#region src/layers/WorkspaceResolverLive.d.ts
+/**
+ * Default WorkspaceResolver: resolves nothing. Provide a real implementation
+ * (e.g. backed by workspaces-effect) to resolve workspace: specifiers.
+ *
+ * @public
+ */
+declare const WorkspaceResolverLive: Layer.Layer<WorkspaceResolver>;
+//#endregion
+//#region src/schemas/dev-engines.d.ts
+declare const DevEngine_base: Schema.Class<DevEngine, {
+  name: typeof Schema.String;
+  version: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
+    as: "Option";
+  }>;
 }, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    version: typeof Schema.String;
-    integrity: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+  name: typeof Schema.String;
+  version: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
+    as: "Option";
+  }>;
 }>, never, {
-    readonly integrity: Option.Option<string>;
+  readonly name: string;
 } & {
-    readonly name: string;
+  readonly onFail: import("effect/Option").Option<"error" | "ignore" | "warn">;
 } & {
-    readonly version: string;
+  readonly version: import("effect/Option").Option<string>;
 }, {}, {}>;
-
 /**
- * A valid npm package name, either scoped or unscoped.
+ * A single engine constraint with name, optional version, and optional onFail behavior.
+ *
+ * @public
  */
-export declare const PackageName: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-
-/** Branded type for any valid package name. */
-export declare type PackageName = Schema.Schema.Type<typeof PackageName>;
-
+declare class DevEngine extends DevEngine_base {}
+//#endregion
+//#region src/schemas/name.d.ts
 /**
- * Utility functions for working with package name strings.
+ * A valid npm scoped package name (starts with \@scope/).
+ *
+ * @public
  */
-export declare const PackageNameUtil: {
-    scope: (name: string) => Option.Option<string>;
-    unscoped: (name: string) => string;
-    isScoped: (name: string) => boolean;
-};
-
-/** Parse the specifier as a semver Range, returning None when it is not a range. */
-export declare const parseRangeOption: (s: string) => Option.Option<Range>;
-
-export declare class PeerDependency extends PeerDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
-declare const PeerDependency_base: Schema.TaggedClass<PeerDependency, "PeerDependency", {
-    readonly _tag: Schema.tag<"PeerDependency">;
-} & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
-    isOptional: typeof Schema.Boolean;
-}>;
-
-/** Classify a specifier string into a single protocol; "unknown" for unrecognized input. */
-export declare const protocolOf: (s: string) => DependencyProtocol;
-
-export declare interface RuleFailure {
-    readonly message: string;
-    readonly path?: Option.Option<string>;
-}
-
+declare const ScopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">;
 /**
- * A valid npm scoped package name (starts with \@scope/).
+ * Branded type for scoped package names.
+ *
+ * @public
  */
-export declare const ScopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">;
-
-/** Branded type for scoped package names. */
-export declare type ScopedPackageName = Schema.Schema.Type<typeof ScopedPackageName>;
-
-/** A Dependency whose specifier is an unresolved catalog: or workspace: protocol. */
-export declare type UnresolvedDependency = Dependency & {
-    readonly isUnresolved: true;
-};
-
+type ScopedPackageName = Schema.Schema.Type<typeof ScopedPackageName>;
 /**
  * A valid npm unscoped package name (does not start with \@).
+ *
+ * @public
  */
-export declare const UnscopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">;
-
-/** Branded type for unscoped package names. */
-export declare type UnscopedPackageName = Schema.Schema.Type<typeof UnscopedPackageName>;
-
+declare const UnscopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">;
 /**
- * A single validation rule.
+ * Branded type for unscoped package names.
+ *
+ * @public
  */
-export declare interface ValidationRule {
-    readonly name: string;
-    readonly validate: (pkg: Package) => Effect.Effect<void, RuleFailure>;
-}
-
+type UnscopedPackageName = Schema.Schema.Type<typeof UnscopedPackageName>;
 /**
- * Describes a single rule failure during package.json validation.
+ * A valid npm package name, either scoped or unscoped.
+ *
+ * @public
  */
-export declare interface ValidationRuleFailure {
-    /** The identifier of the validation rule that failed. */
-    readonly rule: string;
-    /** A human-readable description of the failure. */
-    readonly message: string;
-    /** The JSON path within the package.json where the failure occurred, if applicable. */
-    readonly path: Option.Option<string>;
-}
-
+declare const PackageName: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
 /**
- * Resolves workspace: protocol specifiers. Given a workspace package name,
- * returns its concrete version (without range modifier), or None if it cannot
- * be resolved (default no-op behavior).
+ * Branded type for any valid package name.
+ *
+ * @public
  */
-export declare class WorkspaceResolver extends WorkspaceResolver_base {
-}
-
-declare const WorkspaceResolver_base: Context.TagClass<WorkspaceResolver, "package-json-effect/WorkspaceResolver", {
-    readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
-}>;
-
+type PackageName = Schema.Schema.Type<typeof PackageName>;
+//#endregion
+//#region src/schemas/package-manager.d.ts
+declare const PackageManager_base: Schema.Class<PackageManager, {
+  name: typeof Schema.String;
+  version: typeof Schema.String;
+  integrity: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+}, Schema.Struct.Encoded<{
+  name: typeof Schema.String;
+  version: typeof Schema.String;
+  integrity: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+}>, never, {
+  readonly integrity: Option.Option<string>;
+} & {
+  readonly name: string;
+} & {
+  readonly version: string;
+}, {}, {}>;
 /**
- * Default WorkspaceResolver: resolves nothing. Provide a real implementation
- * (e.g. backed by workspaces-effect) to resolve workspace: specifiers.
+ * Structured packageManager value with name, version, and optional integrity.
+ *
+ * @public
  */
-export declare const WorkspaceResolverLive: Layer.Layer<WorkspaceResolver>;
-
-export { }
+declare class PackageManager extends PackageManager_base {
+  get hasIntegrity(): boolean;
+}
+//#endregion
+export { CatalogResolver, CatalogResolverLive, Dependency, type DependencyProtocol, type DependencyProtocolGetters, DependencyResolutionError, DependencyResolutionErrorBase, DevDependency, DevEngine, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonDecodeError, PackageJsonDecodeErrorBase, PackageJsonFormatter, PackageJsonFormatterLive, PackageJsonLive, PackageJsonNotFoundError, PackageJsonNotFoundErrorBase, PackageJsonParseError, PackageJsonParseErrorBase, PackageJsonReadError, PackageJsonReadErrorBase, PackageJsonReader, PackageJsonReaderLive, PackageJsonTransformer, PackageJsonTransformerLive, PackageJsonValidationError, PackageJsonValidationErrorBase, PackageJsonValidator, PackageJsonValidatorLive, PackageJsonWriteError, PackageJsonWriteErrorBase, PackageJsonWriter, PackageJsonWriterLive, PackageManager, type PackageName, PackageNameUtil, PeerDependency, type RuleFailure, type ScopedPackageName, type UnresolvedDependency, type UnscopedPackageName, type ValidationRule, type ValidationRuleFailure, WorkspaceResolver, WorkspaceResolverLive, defaultRules, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, makePackageJsonValidatorLive, noLocalDepsRule, noUnresolvedDepsRule, parseRangeOption, protocolOf };
+//# sourceMappingURL=index.d.ts.map

index.js

@@ -1,302 +0,35 @@
-import { Context, Data, Effect, HashMap, Layer, Option, Schema } from "effect";
-import { FileSystem } from "@effect/platform";
-import { CatalogResolver, WorkspaceResolver, Package, PackageJsonSchema } from "./471.js";
-const PackageJsonDecodeErrorBase = Data.TaggedError("PackageJsonDecodeError");
-class PackageJsonDecodeError extends PackageJsonDecodeErrorBase {
-}
-const PackageJsonNotFoundErrorBase = Data.TaggedError("PackageJsonNotFoundError");
-class PackageJsonNotFoundError extends PackageJsonNotFoundErrorBase {
-    get message() {
-        return `package.json not found at "${this.source}"`;
-    }
-}
-const PackageJsonParseErrorBase = Data.TaggedError("PackageJsonParseError");
-class PackageJsonParseError extends PackageJsonParseErrorBase {
-    get message() {
-        const base = "Failed to parse package.json";
-        return Option.match(this.position, {
-            onNone: ()=>base,
-            onSome: (pos)=>`${base} at position ${pos}`
-        });
-    }
-}
-const PackageJsonReadErrorBase = Data.TaggedError("PackageJsonReadError");
-class PackageJsonReadError extends PackageJsonReadErrorBase {
-    get message() {
-        return `Failed to read package.json from "${this.source}"`;
-    }
-}
-const PackageJsonValidationErrorBase = Data.TaggedError("PackageJsonValidationError");
-class PackageJsonValidationError extends PackageJsonValidationErrorBase {
-    get message() {
-        const lines = this.failures.map((f)=>{
-            const pathPart = Option.match(f.path, {
-                onNone: ()=>"",
-                onSome: (p)=>` (at ${p})`
-            });
-            return `  - [${f.rule}]${pathPart}: ${f.message}`;
-        });
-        return `package.json validation failed:\n${lines.join("\n")}`;
-    }
-}
-const PackageJsonWriteErrorBase = Data.TaggedError("PackageJsonWriteError");
-class PackageJsonWriteError extends PackageJsonWriteErrorBase {
-    get message() {
-        return `Failed to write package.json to "${this.target}"`;
-    }
-}
-const CatalogResolverLive = Layer.succeed(CatalogResolver, CatalogResolver.of({
-    rangeOf: ()=>Effect.succeed(Option.none())
-}));
-class PackageJsonFormatter extends Context.Tag("package-json-effect/PackageJsonFormatter")() {
-}
-const KEY_ORDER = [
-    "$schema",
-    "name",
-    "version",
-    "private",
-    "description",
-    "keywords",
-    "homepage",
-    "bugs",
-    "repository",
-    "funding",
-    "license",
-    "author",
-    "contributors",
-    "type",
-    "imports",
-    "exports",
-    "main",
-    "module",
-    "browser",
-    "bin",
-    "man",
-    "files",
-    "directories",
-    "workspaces",
-    "scripts",
-    "config",
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "peerDependenciesMeta",
-    "optionalDependencies",
-    "bundleDependencies",
-    "overrides",
-    "engines",
-    "devEngines",
-    "os",
-    "cpu",
-    "publishConfig",
-    "packageManager"
-];
-const DEPENDENCY_KEYS = new Set([
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-    "bundleDependencies"
-]);
-const sortKeys = (obj)=>{
-    const known = [];
-    const unknown = [];
-    for (const key of Object.keys(obj))if (KEY_ORDER.includes(key)) known.push([
-        key,
-        obj[key]
-    ]);
-    else unknown.push([
-        key,
-        obj[key]
-    ]);
-    known.sort((a, b)=>KEY_ORDER.indexOf(a[0]) - KEY_ORDER.indexOf(b[0]));
-    unknown.sort((a, b)=>a[0].localeCompare(b[0]));
-    const result = {};
-    for (const [key, value] of [
-        ...known,
-        ...unknown
-    ])if (DEPENDENCY_KEYS.has(key) && null !== value && "object" == typeof value && !Array.isArray(value)) {
-        const sorted = Object.keys(value).sort((a, b)=>a.localeCompare(b)).reduce((acc, k)=>{
-            acc[k] = value[k];
-            return acc;
-        }, {});
-        result[key] = sorted;
-    } else result[key] = value;
-    return result;
-};
-const PackageJsonFormatterLive = Layer.succeed(PackageJsonFormatter, PackageJsonFormatter.of({
-    format: sortKeys
-}));
-class PackageJsonReader extends Context.Tag("package-json-effect/PackageJsonReader")() {
-}
-const PackageJsonReaderLive = Layer.effect(PackageJsonReader, Effect.gen(function*() {
-    const fs = yield* FileSystem.FileSystem;
-    return PackageJsonReader.of({
-        read: (source)=>Effect.gen(function*() {
-                const exists = yield* fs.exists(source).pipe(Effect.mapError((cause)=>new PackageJsonReadError({
-                        source,
-                        cause
-                    })));
-                if (!exists) return yield* new PackageJsonNotFoundError({
-                    source
-                });
-                const content = yield* fs.readFileString(source).pipe(Effect.mapError((cause)=>new PackageJsonReadError({
-                        source,
-                        cause
-                    })));
-                const json = yield* Effect["try"]({
-                    try: ()=>JSON.parse(content),
-                    catch: (err)=>{
-                        const position = err instanceof SyntaxError && "number" == typeof err.position ? Option.some(err.position) : Option.none();
-                        return new PackageJsonParseError({
-                            input: content,
-                            position
-                        });
-                    }
-                });
-                const pkg = yield* Schema.decodeUnknown(PackageJsonSchema)(json).pipe(Effect.mapError((cause)=>new PackageJsonDecodeError({
-                        input: json,
-                        message: cause.message ?? "Failed to decode package.json"
-                    })));
-                return pkg;
-            })
-    });
-}));
-class PackageJsonTransformer extends Context.Tag("package-json-effect/PackageJsonTransformer")() {
-}
-const DEPENDENCY_MAP_KEYS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies"
-];
-const stripEmptyDependencyMaps = (raw)=>{
-    const result = {
-        ...raw
-    };
-    for (const key of DEPENDENCY_MAP_KEYS){
-        const value = result[key];
-        if (void 0 !== value && "object" == typeof value && null !== value && 0 === Object.keys(value).length) delete result[key];
-    }
-    return result;
-};
-const PackageJsonTransformerLive = Layer.succeed(PackageJsonTransformer, PackageJsonTransformer.of({
-    transform: (raw)=>Effect.succeed(stripEmptyDependencyMaps(raw))
-}));
-class PackageJsonValidator extends Context.Tag("package-json-effect/PackageJsonValidator")() {
-}
-const hasLicense = {
-    name: "has-license",
-    validate: (pkg)=>Option.isSome(pkg.license) ? Effect["void"] : Effect.fail({
-            message: "Missing license field",
-            path: Option.some("license")
-        })
-};
-const hasDescription = {
-    name: "has-description",
-    validate: (pkg)=>Option.isSome(pkg.description) ? Effect["void"] : Effect.fail({
-            message: "Missing description field",
-            path: Option.some("description")
-        })
-};
-const hasRepository = {
-    name: "has-repository",
-    validate: (pkg)=>Object.hasOwn(pkg, "repository") || Object.hasOwn(pkg.rest, "repository") ? Effect["void"] : Effect.fail({
-            message: "Missing repository field",
-            path: Option.some("repository")
-        })
-};
-const notPrivate = {
-    name: "not-private",
-    validate: (pkg)=>pkg.isPrivate ? Effect.fail({
-            message: "Package is private",
-            path: Option.some("private")
-        }) : Effect["void"]
-};
-const anyDepMatches = (pkg, pred)=>{
-    const maps = [
-        pkg.dependencies,
-        pkg.devDependencies,
-        pkg.peerDependencies,
-        pkg.optionalDependencies
-    ];
-    return maps.some((m)=>Array.from(HashMap.values(m)).some(pred));
-};
-const noUnresolvedDepsRule = {
-    name: "no-unresolved-deps",
-    validate: (pkg)=>anyDepMatches(pkg, (s)=>s.startsWith("workspace:") || s.startsWith("catalog:")) ? Effect.fail({
-            message: "Unresolved workspace:/catalog: dependency",
-            path: Option.none()
-        }) : Effect["void"]
-};
-const noLocalDepsRule = {
-    name: "no-local-deps",
-    validate: (pkg)=>anyDepMatches(pkg, (s)=>s.startsWith("file:") || s.startsWith("link:") || s.startsWith("portal:")) ? Effect.fail({
-            message: "Local file:/link:/portal: dependency",
-            path: Option.none()
-        }) : Effect["void"]
-};
-const defaultRules = [
-    hasLicense,
-    hasDescription,
-    hasRepository,
-    notPrivate
-];
-const runRules = (pkg, rules)=>Effect.gen(function*() {
-        const failures = [];
-        for (const rule of rules)yield* rule.validate(pkg).pipe(Effect.matchEffect({
-            onSuccess: ()=>Effect["void"],
-            onFailure: (err)=>{
-                failures.push({
-                    rule: rule.name,
-                    message: err.message,
-                    path: err.path ?? Option.none()
-                });
-                return Effect["void"];
-            }
-        }));
-        if (failures.length > 0) return yield* new PackageJsonValidationError({
-            failures
-        });
-        return pkg;
-    });
-const PackageJsonValidatorLive = Layer.succeed(PackageJsonValidator, PackageJsonValidator.of({
-    validate: (pkg)=>runRules(pkg, defaultRules)
-}));
-const makePackageJsonValidatorLive = (config)=>Layer.succeed(PackageJsonValidator, PackageJsonValidator.of({
-        validate: (pkg)=>runRules(pkg, config.rules)
-    }));
-class PackageJsonWriter extends Context.Tag("package-json-effect/PackageJsonWriter")() {
-}
-const PackageJsonWriterLive = Layer.effect(PackageJsonWriter, Effect.gen(function*() {
-    const fs = yield* FileSystem.FileSystem;
-    const formatter = yield* PackageJsonFormatter;
-    const transformer = yield* PackageJsonTransformer;
-    const catalog = yield* CatalogResolver;
-    const workspace = yield* WorkspaceResolver;
-    return PackageJsonWriter.of({
-        write: (target, pkg)=>Effect.gen(function*() {
-                const resolved = yield* Package.resolve(pkg).pipe(Effect.provideService(CatalogResolver, catalog), Effect.provideService(WorkspaceResolver, workspace), Effect.mapError((cause)=>new PackageJsonWriteError({
-                        target,
-                        cause
-                    })));
-                const encoded = yield* Schema.encode(PackageJsonSchema)(resolved).pipe(Effect.mapError((cause)=>new PackageJsonWriteError({
-                        target,
-                        cause
-                    })));
-                const raw = yield* transformer.transform(encoded);
-                const formatted = formatter.format(raw);
-                const json = `${JSON.stringify(formatted, null, 2)}\n`;
-                yield* fs.writeFileString(target, json).pipe(Effect.mapError((cause)=>new PackageJsonWriteError({
-                        target,
-                        cause
-                    })));
-            })
-    });
-}));
-const WorkspaceResolverLive = Layer.succeed(WorkspaceResolver, WorkspaceResolver.of({
-    versionOf: ()=>Effect.succeed(Option.none())
-}));
-const PackageJsonLive = Layer.mergeAll(PackageJsonReaderLive, PackageJsonWriterLive.pipe(Layer.provide(PackageJsonFormatterLive), Layer.provide(CatalogResolverLive), Layer.provide(WorkspaceResolverLive), Layer.provide(PackageJsonTransformerLive)), PackageJsonFormatterLive, CatalogResolverLive, WorkspaceResolverLive, PackageJsonTransformerLive, PackageJsonValidatorLive);
-export { CatalogResolver, Dependency, DependencyResolutionError, DependencyResolutionErrorBase, DevDependency, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageNameUtil, PeerDependency, WorkspaceResolver, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, parseRangeOption, protocolOf } from "./471.js";
-export { CatalogResolverLive, PackageJsonDecodeError, PackageJsonDecodeErrorBase, PackageJsonFormatter, PackageJsonFormatterLive, PackageJsonLive, PackageJsonNotFoundError, PackageJsonNotFoundErrorBase, PackageJsonParseError, PackageJsonParseErrorBase, PackageJsonReadError, PackageJsonReadErrorBase, PackageJsonReader, PackageJsonReaderLive, PackageJsonTransformer, PackageJsonTransformerLive, PackageJsonValidationError, PackageJsonValidationErrorBase, PackageJsonValidator, PackageJsonValidatorLive, PackageJsonWriteError, PackageJsonWriteErrorBase, PackageJsonWriter, PackageJsonWriterLive, WorkspaceResolverLive, defaultRules, makePackageJsonValidatorLive, noLocalDepsRule, noUnresolvedDepsRule };
+import { Dependency, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, parseRangeOption, protocolOf } from "./domain/Dependency.js";
+import { DevDependency } from "./domain/DevDependency.js";
+import { OptionalDependency } from "./domain/OptionalDependency.js";
+import { InvalidPackageNameError, InvalidPackageNameErrorBase } from "./errors/InvalidPackageNameError.js";
+import { InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase } from "./errors/InvalidSpdxLicenseError.js";
+import { DevEngine } from "./schemas/dev-engines.js";
+import { PackageManager } from "./schemas/package-manager.js";
+import { CatalogResolver } from "./services/CatalogResolver.js";
+import { WorkspaceResolver } from "./services/WorkspaceResolver.js";
+import { PackageNameUtil } from "./domain/PackageName.js";
+import { PeerDependency } from "./domain/PeerDependency.js";
+import { Package } from "./domain/Package.js";
+import { DependencyResolutionError, DependencyResolutionErrorBase } from "./errors/DependencyResolutionError.js";
+import { InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase } from "./errors/InvalidDependencySpecifierError.js";
+import { PackageJsonDecodeError, PackageJsonDecodeErrorBase } from "./errors/PackageJsonDecodeError.js";
+import { PackageJsonNotFoundError, PackageJsonNotFoundErrorBase } from "./errors/PackageJsonNotFoundError.js";
+import { PackageJsonParseError, PackageJsonParseErrorBase } from "./errors/PackageJsonParseError.js";
+import { PackageJsonReadError, PackageJsonReadErrorBase } from "./errors/PackageJsonReadError.js";
+import { PackageJsonValidationError, PackageJsonValidationErrorBase } from "./errors/PackageJsonValidationError.js";
+import { PackageJsonWriteError, PackageJsonWriteErrorBase } from "./errors/PackageJsonWriteError.js";
+import { CatalogResolverLive } from "./layers/CatalogResolverLive.js";
+import { PackageJsonFormatter } from "./services/PackageJsonFormatter.js";
+import { PackageJsonFormatterLive } from "./layers/PackageJsonFormatterLive.js";
+import { PackageJsonReader } from "./services/PackageJsonReader.js";
+import { PackageJsonReaderLive } from "./layers/PackageJsonReaderLive.js";
+import { PackageJsonTransformer } from "./services/PackageJsonTransformer.js";
+import { PackageJsonTransformerLive } from "./layers/PackageJsonTransformerLive.js";
+import { PackageJsonValidator } from "./services/PackageJsonValidator.js";
+import { PackageJsonValidatorLive, defaultRules, makePackageJsonValidatorLive, noLocalDepsRule, noUnresolvedDepsRule } from "./layers/PackageJsonValidatorLive.js";
+import { PackageJsonWriter } from "./services/PackageJsonWriter.js";
+import { PackageJsonWriterLive } from "./layers/PackageJsonWriterLive.js";
+import { WorkspaceResolverLive } from "./layers/WorkspaceResolverLive.js";
+import { PackageJsonLive } from "./layers/PackageJsonLive.js";
+
+export { CatalogResolver, CatalogResolverLive, Dependency, DependencyResolutionError, DependencyResolutionErrorBase, DevDependency, DevEngine, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonDecodeError, PackageJsonDecodeErrorBase, PackageJsonFormatter, PackageJsonFormatterLive, PackageJsonLive, PackageJsonNotFoundError, PackageJsonNotFoundErrorBase, PackageJsonParseError, PackageJsonParseErrorBase, PackageJsonReadError, PackageJsonReadErrorBase, PackageJsonReader, PackageJsonReaderLive, PackageJsonTransformer, PackageJsonTransformerLive, PackageJsonValidationError, PackageJsonValidationErrorBase, PackageJsonValidator, PackageJsonValidatorLive, PackageJsonWriteError, PackageJsonWriteErrorBase, PackageJsonWriter, PackageJsonWriterLive, PackageManager, PackageNameUtil, PeerDependency, WorkspaceResolver, WorkspaceResolverLive, defaultRules, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, makePackageJsonValidatorLive, noLocalDepsRule, noUnresolvedDepsRule, parseRangeOption, protocolOf };

package.json

 {
-  "name": "package-json-effect",
-  "version": "0.2.0",
-  "private": false,
-  "description": "Utility library for working with package.json files in Effect",
-  "homepage": "https://github.com/spencerbeggs/package-json-effect#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/spencerbeggs/package-json-effect.git"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "C. Spencer Beggs",
-    "email": "[e-mail]",
-    "url": "https://spencerbeg.gs"
-  },
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
-    },
-    "./schema": {
-      "types": "./schema.d.ts",
-      "import": "./schema.js"
-    }
-  },
-  "dependencies": {
-    "semver-effect": "^0.2.1",
-    "spdx-expression-parse": "^4.0.0"
-  },
-  "peerDependencies": {
-    "@effect/platform": ">=0.96.0",
-    "effect": ">=3.21.0"
-  },
-  "files": [
-    "!package-json-effect.api.json",
-    "!tsconfig.json",
-    "!tsdoc.json",
-    "471.js",
-    "LICENSE",
-    "README.md",
-    "index.d.ts",
-    "index.js",
-    "package.json",
-    "schema.d.ts",
-    "schema.js",
-    "tsdoc-metadata.json"
-  ]
+	"name": "package-json-effect",
+	"version": "0.3.0",
+	"private": false,
+	"description": "Utility library for working with package.json files in Effect",
+	"homepage": "https://github.com/spencerbeggs/package-json-effect#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/package-json-effect.git"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "[e-mail]",
+		"url": "https://spencerbeg.gs"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./schema": {
+			"types": "./schema.d.ts",
+			"import": "./schema.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"semver-effect": "^0.3.0",
+		"spdx-expression-parse": "^4.0.0"
+	},
+	"peerDependencies": {
+		"@effect/platform": "^0.96.0",
+		"effect": "^3.21.0"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
 }

schema.d.ts

@@ -0,261 +1,142 @@
+import { Context, Effect, HashMap, Option, Schema } from "effect";
+import { InvalidVersionError, Range, SemVer } from "semver-effect";
+
+//#region src/domain/Dependency.d.ts
 /**
- * package-json-effect/schema
+ * The classification of a dependency specifier's protocol.
  *
- * Advanced schema exports for extending and customizing PackageJsonSchema.
- *
- * @packageDocumentation
+ * @public
  */
-
-import { Brand } from 'effect/Brand';
-import { Context } from 'effect';
-import { Effect } from 'effect';
-import { HashMap } from 'effect';
-import { HashMap as HashMap_2 } from 'effect/HashMap';
-import type { InvalidVersionError } from 'semver-effect';
-import { Option } from 'effect';
-import { Option as Option_2 } from 'effect/Option';
-import type { Range } from 'semver-effect';
-import { Schema } from 'effect';
-import { Schema as Schema_2 } from 'effect/Schema';
-import { SemVer } from 'semver-effect';
-import { VoidIfEmpty } from 'effect/Types';
-import { YieldableError } from 'effect/Cause';
-
+type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
 /**
- * Bin field: either a single string path or a map of command names to paths.
+ * The shared protocol-classification getters implemented by every Dependency variant.
+ *
+ * @public
  */
-export declare const BinSchema: Schema.Schema<string | HashMap.HashMap<string, string>, string | {
-    readonly [x: string]: string;
-}>;
-
-/**
- * Resolves catalog: protocol specifiers. Given a package name and an optional
- * catalog name (None = default catalog), returns the configured range, or None
- * if it cannot be resolved (default no-op behavior).
- */
-export declare class CatalogResolver extends CatalogResolver_base {
+interface DependencyProtocolGetters {
+  readonly protocol: Option.Option<DependencyProtocol>;
+  readonly range: Option.Option<Range>;
+  readonly isLocal: boolean;
+  readonly isLink: boolean;
+  readonly isPortal: boolean;
+  readonly isCatalog: boolean;
+  readonly isWorkspace: boolean;
+  readonly isUnresolved: boolean;
+  readonly isGit: boolean;
+  readonly isRange: boolean;
+  readonly isTag: boolean;
 }
-
-declare const CatalogResolver_base: Context.TagClass<CatalogResolver, "package-json-effect/CatalogResolver", {
-    readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
-}>;
-
-/**
- * Opt-in decoder: validate a string as a DependencySpecifier, failing with a
- * typed InvalidDependencySpecifierError instead of a Schema ParseError.
- */
-export declare const decodeSpecifier: (input: string) => Effect.Effect<DependencySpecifier, InvalidDependencySpecifierError>;
-
-export declare class Dependency extends Dependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
 declare const Dependency_base: Schema.TaggedClass<Dependency, "Dependency", {
-    readonly _tag: Schema.tag<"Dependency">;
+  readonly _tag: Schema.tag<"Dependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
 }>;
-
 /**
- * A dependency map: plain JSON object decoded to/from HashMap.
+ * A resolved dependency entry pairing a package name with its version specifier.
+ *
+ * @public
  */
-export declare const DependencyMapSchema: Schema.Schema<HashMap.HashMap<string, string>, {
-    readonly [x: string]: string;
-}>;
-
-export declare type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
-
-/** The shared protocol-classification getters implemented by every Dependency variant. */
-export declare interface DependencyProtocolGetters {
-    readonly protocol: Option.Option<DependencyProtocol>;
-    readonly range: Option.Option<Range>;
-    readonly isLocal: boolean;
-    readonly isLink: boolean;
-    readonly isPortal: boolean;
-    readonly isCatalog: boolean;
-    readonly isWorkspace: boolean;
-    readonly isUnresolved: boolean;
-    readonly isGit: boolean;
-    readonly isRange: boolean;
-    readonly isTag: boolean;
+declare class Dependency extends Dependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
-/** Indicates that a catalog: or workspace: specifier could not be resolved. */
-export declare class DependencyResolutionError extends DependencyResolutionErrorBase<{
-    /** The name of the package whose specifier could not be resolved. */
-    readonly packageName: string;
-    /** The specifier string (e.g. `catalog:` or `workspace:*`) that failed resolution. */
-    readonly specifier: string;
-    /** A human-readable description of why resolution failed. */
-    readonly reason: string;
-}> {
-    get message(): string;
-}
-
 /**
- * Tagged error base for {@link DependencyResolutionError}.
+ * A Dependency whose specifier is an unresolved catalog: or workspace: protocol.
  *
- * @privateRemarks
- * Exported because TypeScript declaration bundling requires the base class to be
- * accessible when {@link DependencyResolutionError} appears in public type signatures.
- * Consumers should use {@link DependencyResolutionError} directly.
- *
- * @internal
+ * @public
  */
-export declare const DependencyResolutionErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "DependencyResolutionError";
-} & Readonly<A>;
-
-/**
- * A valid dependency version specifier.
- */
-declare const DependencySpecifier: Schema.brand<Schema.filter<typeof Schema.String>, "DependencySpecifier">;
-
-/** Branded type for dependency specifiers. */
-declare type DependencySpecifier = Schema.Schema.Type<typeof DependencySpecifier>;
-export { DependencySpecifier }
-export { DependencySpecifier as DependencySpecifierType }
-
-export declare class DevDependency extends DevDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
+type UnresolvedDependency = Dependency & {
+  readonly isUnresolved: true;
+};
+//#endregion
+//#region src/domain/DevDependency.d.ts
 declare const DevDependency_base: Schema.TaggedClass<DevDependency, "DevDependency", {
-    readonly _tag: Schema.tag<"DevDependency">;
+  readonly _tag: Schema.tag<"DevDependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
 }>;
-
 /**
- * A single engine constraint with name, optional version, and optional onFail behavior.
+ * A `devDependencies` entry pairing a package name with its version specifier.
+ *
+ * @public
  */
-export declare class DevEngine extends DevEngine_base {
+declare class DevDependency extends DevDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
-declare const DevEngine_base: Schema.Class<DevEngine, {
-    name: typeof Schema.String;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly name: string;
+//#endregion
+//#region src/domain/OptionalDependency.d.ts
+declare const OptionalDependency_base: Schema.TaggedClass<OptionalDependency, "OptionalDependency", {
+  readonly _tag: Schema.tag<"OptionalDependency">;
 } & {
-    readonly onFail: Option_2<"error" | "ignore" | "warn">;
-} & {
-    readonly version: Option_2<string>;
-}, {}, {}>;
-
-export declare type DevEngines = Schema.Schema.Type<typeof DevEnginesSchema>;
-
-/**
- * Schema for the devEngines field, modeling runtime and
- * package manager constraints with optional arrays.
- */
-export declare const DevEnginesSchema: Schema.Struct<{
-    packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
-        as: "Option";
-    }>;
-    runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
-        as: "Option";
-    }>;
-    os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
-        as: "Option";
-    }>;
-    cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
-        as: "Option";
-    }>;
-    libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
-        as: "Option";
-    }>;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
 }>;
-
 /**
- * Engines field: map of engine names to semver ranges.
- */
-export declare const EnginesSchema: Schema.Schema<HashMap.HashMap<string, string>, {
-    readonly [x: string]: string;
-}>;
-
-export declare type ExportsField = Schema.Schema.Type<typeof ExportsFieldSchema>;
-
-/**
- * Exports field: either a single string entry point or an object
- * mapping subpaths to file paths (or null to block).
+ * An `optionalDependencies` entry pairing a package name with its version specifier.
  *
- * The object form accepts any value shape to support conditional
- * exports with nested objects (e.g. `{ "import": "./esm.js", "require": "./cjs.js" }`).
+ * @public
  */
-export declare const ExportsFieldSchema: Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-
-/**
- * Indicates that a string could not be parsed as a valid dependency specifier.
- */
-export declare class InvalidDependencySpecifierError extends InvalidDependencySpecifierErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the specifier is invalid. */
-    readonly reason: string;
-}> {
-    get message(): string;
+declare class OptionalDependency extends OptionalDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
+//#endregion
+//#region src/errors/DependencyResolutionError.d.ts
 /**
- * Tagged error base for {@link InvalidDependencySpecifierError}.
+ * Tagged error base for {@link DependencyResolutionError}.
  *
  * @privateRemarks
  * Exported because TypeScript declaration bundling requires the base class to be
- * accessible when {@link InvalidDependencySpecifierError} appears in public type signatures.
- * Consumers should use {@link InvalidDependencySpecifierError} directly.
+ * accessible when {@link DependencyResolutionError} appears in public type signatures.
+ * Consumers should use {@link DependencyResolutionError} directly.
  *
- * @internal
+ * @public
  */
-export declare const InvalidDependencySpecifierErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidDependencySpecifierError";
+declare const DependencyResolutionErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DependencyResolutionError";
 } & Readonly<A>;
-
 /**
- * Indicates that a string could not be used as a valid npm package name.
+ * Indicates that a catalog: or workspace: specifier could not be resolved.
+ *
+ * @public
  */
-export declare class InvalidPackageNameError extends InvalidPackageNameErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the name is invalid. */
-    readonly reason: string;
+declare class DependencyResolutionError extends DependencyResolutionErrorBase<{
+  /** The name of the package whose specifier could not be resolved. */readonly packageName: string; /** The specifier string (e.g. `catalog:` or `workspace:*`) that failed resolution. */
+  readonly specifier: string; /** A human-readable description of why resolution failed. */
+  readonly reason: string;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/InvalidPackageNameError.d.ts
 /**
@@ -269,18 +150,20 @@ * Tagged error base for {@link InvalidPackageNameError}.
  *
- * @internal
+ * @public
  */
-export declare const InvalidPackageNameErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidPackageNameError";
+declare const InvalidPackageNameErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidPackageNameError";
 } & Readonly<A>;
-
-/** Indicates that a string is not a valid SPDX license identifier or expression. */
-export declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseErrorBase<{
-    /** The raw input string that failed validation. */
-    readonly input: string;
-    /** A human-readable description of why the license identifier is invalid. */
-    readonly reason: string;
+/**
+ * Indicates that a string could not be used as a valid npm package name.
+ *
+ * @public
+ */
+declare class InvalidPackageNameError extends InvalidPackageNameErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the name is invalid. */
+  readonly reason: string;
 }> {
-    get message(): string;
+  get message(): string;
 }
-
+//#endregion
+//#region src/errors/InvalidSpdxLicenseError.d.ts
 /**
@@ -294,618 +177,827 @@ * Tagged error base for {@link InvalidSpdxLicenseError}.
  *
- * @internal
+ * @public
  */
-export declare const InvalidSpdxLicenseErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
-    readonly _tag: "InvalidSpdxLicenseError";
+declare const InvalidSpdxLicenseErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidSpdxLicenseError";
 } & Readonly<A>;
-
 /**
- * Validates a dependency version specifier.
+ * Indicates that a string is not a valid SPDX license identifier or expression.
  *
- * Accepts semver ranges, exact versions, dist-tags, URLs,
- * git refs, GitHub shorthand, file paths, and npm/catalog/workspace protocols.
+ * @public
  */
-export declare const isValidDependencySpecifier: (s: string) => boolean;
-
+declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the license identifier is invalid. */
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/services/CatalogResolver.d.ts
+declare const CatalogResolver_base: Context.TagClass<CatalogResolver, "package-json-effect/CatalogResolver", {
+  readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+}>;
 /**
- * Validates a string as a valid npm package name.
+ * Resolves catalog: protocol specifiers. Given a package name and an optional
+ * catalog name (None = default catalog), returns the configured range, or None
+ * if it cannot be resolved (default no-op behavior).
  *
- * Rules: max 214 chars, lowercase, URL-safe characters only,
- * cannot start with . or _ (unless scoped).
+ * @public
  */
-export declare const isValidPackageName: (s: string) => boolean;
-
+declare class CatalogResolver extends CatalogResolver_base {}
+//#endregion
+//#region src/services/WorkspaceResolver.d.ts
+declare const WorkspaceResolver_base: Context.TagClass<WorkspaceResolver, "package-json-effect/WorkspaceResolver", {
+  readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+}>;
 /**
- * Build the wire schema (open JSON object ↔ Package class) for the given
- * Package class or any `.extend()`ed subclass. Reads `Class.fields` so extended
- * fields are decoded as typed members and excluded from `rest`.
+ * Resolves workspace: protocol specifiers. Given a workspace package name,
+ * returns its concrete version (without range modifier), or None if it cannot
+ * be resolved (default no-op behavior).
  *
- * The transform sits between an open JSON record (`RawJson`) and the class. On
- * decode it partitions raw keys into known fields and a `rest` record, handing
- * Effect the class's encoded shape so the class decodes itself. On encode it
- * receives the class's encoded shape and flattens the literal `rest` key back
- * into top-level fields, so the on-disk shape never contains a `rest` key.
+ * @public
  */
-export declare const makePackageJsonSchema: <Self extends Package>(Class: Schema.Schema<Self, any, never> & {
-    readonly fields: Schema.Struct.Fields;
-}) => Schema.Schema<Self, {
-    readonly [k: string]: unknown;
-}, never>;
-
-export declare class OptionalDependency extends OptionalDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
-}
-
-declare const OptionalDependency_base: Schema.TaggedClass<OptionalDependency, "OptionalDependency", {
-    readonly _tag: Schema.tag<"OptionalDependency">;
+declare class WorkspaceResolver extends WorkspaceResolver_base {}
+//#endregion
+//#region src/domain/PeerDependency.d.ts
+declare const PeerDependency_base: Schema.TaggedClass<PeerDependency, "PeerDependency", {
+  readonly _tag: Schema.tag<"PeerDependency">;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
+  name: typeof Schema.String;
+  specifier: typeof Schema.String;
+  isOptional: typeof Schema.Boolean;
 }>;
-
 /**
- * Domain model for a package.json document. A Schema.Class carrying typed
- * known fields plus a `rest` catch-all that preserves any unmodeled top-level
- * fields for round-trip fidelity. The literal `rest` key is flattened away by
- * the wire transform in src/schemas/package-json.ts.
+ * A `peerDependencies` entry pairing a package name, version specifier, and optionality flag.
+ *
+ * @public
  */
-export declare class Package extends Package_base {
-    get isPrivate(): boolean;
-    get isScoped(): boolean;
-    get isESM(): boolean;
-    pipe<A>(this: A): A;
-    pipe<A, B>(this: A, ab: (_: A) => B): B;
-    pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
-    pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
-    pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
-    hasDependency(name: string): boolean;
-    getDependencies(): HashMap.HashMap<string, Dependency>;
-    getDevDependencies(): HashMap.HashMap<string, DevDependency>;
-    getPeerDependencies(): HashMap.HashMap<string, PeerDependency>;
-    getOptionalDependencies(): HashMap.HashMap<string, OptionalDependency>;
-    /** Return a new Package with the given fields replaced. */
-    copyWith(patch: Partial<{
-        name: string;
-        version: SemVer;
-        license: Option.Option<string>;
-        dependencies: HashMap.HashMap<string, string>;
-        devDependencies: HashMap.HashMap<string, string>;
-        peerDependencies: HashMap.HashMap<string, string>;
-        optionalDependencies: HashMap.HashMap<string, string>;
-        scripts: HashMap.HashMap<string, string>;
-    }>): Package;
-    /** Construct a Package from an already-decoded data record. */
-    static fromData(data: ConstructorParameters<typeof Package>[0]): Package;
-    static setVersion: {
-        (version: string): (pkg: Package) => Effect.Effect<Package, InvalidVersionError>;
-        (pkg: Package, version: string): Effect.Effect<Package, InvalidVersionError>;
-    };
-    static setName: {
-        (name: string): (pkg: Package) => Effect.Effect<Package, InvalidPackageNameError>;
-        (pkg: Package, name: string): Effect.Effect<Package, InvalidPackageNameError>;
-    };
-    static addDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addDevDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeDevDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addPeerDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removePeerDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static addOptionalDependency: {
-        (name: string, specifier: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, specifier: string): Package;
-    };
-    static removeOptionalDependency: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static setScript: {
-        (name: string, command: string): (pkg: Package) => Package;
-        (pkg: Package, name: string, command: string): Package;
-    };
-    static removeScript: {
-        (name: string): (pkg: Package) => Package;
-        (pkg: Package, name: string): Package;
-    };
-    static setLicense: {
-        (license: string): (pkg: Package) => Effect.Effect<Package, InvalidSpdxLicenseError>;
-        (pkg: Package, license: string): Effect.Effect<Package, InvalidSpdxLicenseError>;
-    };
-    /**
-     * Resolve catalog: and workspace: specifiers across all four dependency maps
-     * using the CatalogResolver and WorkspaceResolver from context. Returns a new
-     * Package. Specifiers the resolvers return None for are left unchanged.
-     */
-    static resolve(pkg: Package): Effect.Effect<Package, DependencyResolutionError, WorkspaceResolver | CatalogResolver>;
+declare class PeerDependency extends PeerDependency_base implements DependencyProtocolGetters {
+  get protocol(): Option.Option<DependencyProtocol>;
+  get range(): Option.Option<Range>;
+  get isLocal(): boolean;
+  get isLink(): boolean;
+  get isPortal(): boolean;
+  get isCatalog(): boolean;
+  get isWorkspace(): boolean;
+  get isUnresolved(): boolean;
+  get isGit(): boolean;
+  get isRange(): boolean;
+  get isTag(): boolean;
 }
-
+//#endregion
+//#region src/domain/Package.d.ts
 declare const Package_base: Schema.Class<Package, {
-    name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-    version: Schema.Schema<SemVer, string, never>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
+  version: Schema.Schema<SemVer, string, never>;
+  description: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
+    as: "Option";
+  }>;
+  type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
+    as: "Option";
+  }>;
+  main: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  license: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    optional: Schema.optional<typeof Schema.Boolean>;
+  }>>, {
+    as: "Option";
+  }>;
+  scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
+    as: "Option";
+  }>;
+  publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
+    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+      as: "Option";
     }>;
-    private: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
+    directory: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
-        as: "Option";
+    registry: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    main: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+    linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
+      as: "Option";
     }>;
-    license: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  }, readonly [{
+    readonly key: typeof Schema.String;
+    readonly value: typeof Schema.Unknown;
+  }]>, {
+    as: "Option";
+  }>;
+  packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
+    as: "Option";
+  }>;
+  devEngines: Schema.optionalWith<Schema.Struct<{
+    packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
-        optional: Schema.optional<typeof Schema.Boolean>;
-    }>>, {
-        as: "Option";
-    }>;
-    scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
-    }>;
-    bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        as: "Option";
-    }>;
-    publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
-        access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
-            as: "Option";
-        }>;
-        directory: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        registry: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
-            as: "Option";
-        }>;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>, {
-        as: "Option";
-    }>;
-    packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
-        as: "Option";
-    }>;
-    devEngines: Schema.optionalWith<Schema.Struct<{
-        packageManager: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        runtime: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        os: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        cpu: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        libc: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-    }>, {
-        as: "Option";
-    }>;
-    rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
-        default: () => Record<string, unknown>;
-    }>;
+  }>, {
+    as: "Option";
+  }>;
+  rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
+    default: () => Record<string, unknown>;
+  }>;
 }, Schema.Struct.Encoded<{
-    name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-    version: Schema.Schema<SemVer, string, never>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  name: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
+  version: Schema.Schema<SemVer, string, never>;
+  description: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
+    as: "Option";
+  }>;
+  type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
+    as: "Option";
+  }>;
+  main: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  license: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    optional: Schema.optional<typeof Schema.Boolean>;
+  }>>, {
+    as: "Option";
+  }>;
+  scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    default: () => HashMap.HashMap<string, string>;
+  }>;
+  bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
+    readonly [x: string]: string;
+  }, never>, {
+    as: "Option";
+  }>;
+  exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
+    as: "Option";
+  }>;
+  publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
+    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+      as: "Option";
     }>;
-    private: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
+    directory: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    type: Schema.optionalWith<Schema.Literal<["module", "commonjs"]>, {
-        as: "Option";
+    registry: Schema.optionalWith<typeof Schema.String, {
+      as: "Option";
     }>;
-    main: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+    linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
+      as: "Option";
     }>;
-    license: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
+  }, readonly [{
+    readonly key: typeof Schema.String;
+    readonly value: typeof Schema.Unknown;
+  }]>, {
+    as: "Option";
+  }>;
+  packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
+    as: "Option";
+  }>;
+  devEngines: Schema.optionalWith<Schema.Struct<{
+    packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    dependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    devDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    optionalDependencies: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
+    libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+      as: "Option";
     }>;
-    peerDependenciesMeta: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
-        optional: Schema.optional<typeof Schema.Boolean>;
-    }>>, {
-        as: "Option";
-    }>;
-    scripts: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        default: () => HashMap.HashMap<string, string>;
-    }>;
-    bin: Schema.optionalWith<Schema.Schema<string | HashMap.HashMap<string, string>, string | {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    engines: Schema.optionalWith<Schema.Schema<HashMap.HashMap<string, string>, {
-        readonly [x: string]: string;
-    }, never>, {
-        as: "Option";
-    }>;
-    exports: Schema.optionalWith<Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        as: "Option";
-    }>;
-    publishConfig: Schema.optionalWith<Schema.TypeLiteral<{
-        access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
-            as: "Option";
-        }>;
-        directory: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        registry: Schema.optionalWith<typeof Schema.String, {
-            as: "Option";
-        }>;
-        linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
-            as: "Option";
-        }>;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>, {
-        as: "Option";
-    }>;
-    packageManager: Schema.optionalWith<Schema.Schema<PackageManager, string, never>, {
-        as: "Option";
-    }>;
-    devEngines: Schema.optionalWith<Schema.Struct<{
-        packageManager: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        runtime: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        os: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        cpu: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-        libc: Schema.optionalWith<Schema.Union<[DevEngine, Schema.Array$<DevEngine>]>, {
-            as: "Option";
-        }>;
-    }>, {
-        as: "Option";
-    }>;
-    rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
-        default: () => Record<string, unknown>;
-    }>;
+  }>, {
+    as: "Option";
+  }>;
+  rest: Schema.optionalWith<Schema.Data<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, {
+    default: () => Record<string, unknown>;
+  }>;
 }>, never, {
-    readonly dependencies?: HashMap.HashMap<string, string>;
+  readonly dependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly devDependencies?: HashMap.HashMap<string, string>;
+  readonly devDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly optionalDependencies?: HashMap.HashMap<string, string>;
+  readonly optionalDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly peerDependencies?: HashMap.HashMap<string, string>;
+  readonly peerDependencies?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly rest?: {
-        readonly [x: string]: unknown;
-    };
+  readonly rest?: {
+    readonly [x: string]: unknown;
+  } | undefined;
 } & {
-    readonly scripts?: HashMap.HashMap<string, string>;
+  readonly scripts?: HashMap.HashMap<string, string> | undefined;
 } & {
-    readonly bin: Option.Option<string | HashMap.HashMap<string, string>>;
+  readonly bin: Option.Option<string | HashMap.HashMap<string, string>>;
 } & {
-    readonly description: Option.Option<string>;
+  readonly description: Option.Option<string>;
 } & {
-    readonly devEngines: Option.Option<{
-        readonly packageManager: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly runtime: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly os: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly cpu: Option.Option<DevEngine | readonly DevEngine[]>;
-        readonly libc: Option.Option<DevEngine | readonly DevEngine[]>;
-    }>;
+  readonly devEngines: Option.Option<{
+    readonly packageManager: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly runtime: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly os: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly cpu: Option.Option<DevEngine | readonly DevEngine[]>;
+    readonly libc: Option.Option<DevEngine | readonly DevEngine[]>;
+  }>;
 } & {
-    readonly engines: Option.Option<HashMap.HashMap<string, string>>;
+  readonly engines: Option.Option<HashMap.HashMap<string, string>>;
 } & {
-    readonly exports: Option.Option<string | {
-        readonly [x: string]: unknown;
-    }>;
+  readonly exports: Option.Option<string | {
+    readonly [x: string]: unknown;
+  }>;
 } & {
-    readonly license: Option.Option<string>;
+  readonly license: Option.Option<string>;
 } & {
-    readonly main: Option.Option<string>;
+  readonly main: Option.Option<string>;
 } & {
-    readonly name: (string & Brand<"ScopedPackageName">) | (string & Brand<"UnscopedPackageName">);
+  readonly name: (string & import("effect/Brand").Brand<"ScopedPackageName">) | (string & import("effect/Brand").Brand<"UnscopedPackageName">);
 } & {
-    readonly packageManager: Option.Option<PackageManager>;
+  readonly packageManager: Option.Option<PackageManager>;
 } & {
-    readonly peerDependenciesMeta: Option.Option<{
-        readonly [x: string]: {
-            readonly optional?: boolean | undefined;
-        };
-    }>;
+  readonly peerDependenciesMeta: Option.Option<{
+    readonly [x: string]: {
+      readonly optional?: boolean | undefined;
+    };
+  }>;
 } & {
-    readonly private: Option.Option<boolean>;
+  readonly private: Option.Option<boolean>;
 } & {
-    readonly publishConfig: Option.Option<{
-        readonly [x: string]: unknown;
-        readonly access: Option.Option<"public" | "restricted">;
-        readonly directory: Option.Option<string>;
-        readonly registry: Option.Option<string>;
-        readonly linkDirectory: Option.Option<boolean>;
-    }>;
+  readonly publishConfig: Option.Option<{
+    readonly [x: string]: unknown;
+    readonly access: Option.Option<"public" | "restricted">;
+    readonly directory: Option.Option<string>;
+    readonly registry: Option.Option<string>;
+    readonly linkDirectory: Option.Option<boolean>;
+  }>;
 } & {
-    readonly type: Option.Option<"commonjs" | "module">;
+  readonly type: Option.Option<"commonjs" | "module">;
 } & {
-    readonly version: SemVer;
+  readonly version: SemVer;
 }, {}, {}>;
-
-/** The default wire schema: decodes JSON to a Package instance and back. */
-export declare const PackageJsonSchema: Schema.Schema<Package, {
-    readonly [k: string]: unknown;
-}, never>;
-
-/** Encoded (plain JSON) type for PackageJsonSchema. */
-export declare interface PackageJsonSchemaEncoded {
-    readonly [k: string]: unknown;
+/**
+ * Domain model for a package.json document. A Schema.Class carrying typed
+ * known fields plus a `rest` catch-all that preserves any unmodeled top-level
+ * fields for round-trip fidelity. The literal `rest` key is flattened away by
+ * the wire transform in src/schemas/package-json.ts.
+ *
+ * @public
+ */
+declare class Package extends Package_base {
+  get isPrivate(): boolean;
+  get isScoped(): boolean;
+  get isESM(): boolean;
+  pipe<A>(this: A): A;
+  pipe<A, B>(this: A, ab: (_: A) => B): B;
+  pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+  pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+  pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+  hasDependency(name: string): boolean;
+  getDependencies(): HashMap.HashMap<string, Dependency>;
+  getDevDependencies(): HashMap.HashMap<string, DevDependency>;
+  getPeerDependencies(): HashMap.HashMap<string, PeerDependency>;
+  getOptionalDependencies(): HashMap.HashMap<string, OptionalDependency>;
+  /** Return a new Package with the given fields replaced. */
+  copyWith(patch: Partial<{
+    name: string;
+    version: SemVer;
+    license: Option.Option<string>;
+    dependencies: HashMap.HashMap<string, string>;
+    devDependencies: HashMap.HashMap<string, string>;
+    peerDependencies: HashMap.HashMap<string, string>;
+    optionalDependencies: HashMap.HashMap<string, string>;
+    scripts: HashMap.HashMap<string, string>;
+  }>): Package;
+  /** Construct a Package from an already-decoded data record. */
+  static fromData(data: ConstructorParameters<typeof Package>[0]): Package;
+  static setVersion: {
+    (version: string): (pkg: Package) => Effect.Effect<Package, InvalidVersionError>;
+    (pkg: Package, version: string): Effect.Effect<Package, InvalidVersionError>;
+  };
+  static setName: {
+    (name: string): (pkg: Package) => Effect.Effect<Package, InvalidPackageNameError>;
+    (pkg: Package, name: string): Effect.Effect<Package, InvalidPackageNameError>;
+  };
+  static addDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addDevDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeDevDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addPeerDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removePeerDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static addOptionalDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  static removeOptionalDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static setScript: {
+    (name: string, command: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, command: string): Package;
+  };
+  static removeScript: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  static setLicense: {
+    (license: string): (pkg: Package) => Effect.Effect<Package, InvalidSpdxLicenseError>;
+    (pkg: Package, license: string): Effect.Effect<Package, InvalidSpdxLicenseError>;
+  };
+  /**
+   * Resolve catalog: and workspace: specifiers across all four dependency maps
+   * using the CatalogResolver and WorkspaceResolver from context. Returns a new
+   * Package. Specifiers the resolvers return None for are left unchanged.
+   */
+  static resolve(pkg: Package): Effect.Effect<Package, DependencyResolutionError, WorkspaceResolver | CatalogResolver>;
 }
-
-/** Decoded type for PackageJsonSchema. */
-export declare type PackageJsonSchemaType = Package;
-
-export declare class PackageManager extends PackageManager_base {
-    get hasIntegrity(): boolean;
+//#endregion
+//#region src/errors/InvalidDependencySpecifierError.d.ts
+/**
+ * Tagged error base for {@link InvalidDependencySpecifierError}.
+ *
+ * @privateRemarks
+ * Exported because TypeScript declaration bundling requires the base class to be
+ * accessible when {@link InvalidDependencySpecifierError} appears in public type signatures.
+ * Consumers should use {@link InvalidDependencySpecifierError} directly.
+ *
+ * @public
+ */
+declare const InvalidDependencySpecifierErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidDependencySpecifierError";
+} & Readonly<A>;
+/**
+ * Indicates that a string could not be parsed as a valid dependency specifier.
+ *
+ * @public
+ */
+declare class InvalidDependencySpecifierError extends InvalidDependencySpecifierErrorBase<{
+  /** The raw input string that failed validation. */readonly input: string; /** A human-readable description of why the specifier is invalid. */
+  readonly reason: string;
+}> {
+  get message(): string;
 }
-
-declare const PackageManager_base: Schema.Class<PackageManager, {
-    name: typeof Schema.String;
-    version: typeof Schema.String;
-    integrity: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+//#endregion
+//#region src/schemas/bin.d.ts
+/**
+ * Bin field: either a single string path or a map of command names to paths.
+ *
+ * @public
+ */
+declare const BinSchema: Schema.Schema<string | HashMap.HashMap<string, string>, string | {
+  readonly [x: string]: string;
+}>;
+//#endregion
+//#region src/schemas/dependency-map.d.ts
+/**
+ * A dependency map: plain JSON object decoded to/from HashMap.
+ *
+ * @public
+ */
+declare const DependencyMapSchema: Schema.Schema<HashMap.HashMap<string, string>, {
+  readonly [x: string]: string;
+}>;
+//#endregion
+//#region src/schemas/dependency-specifier.d.ts
+/**
+ * Validates a dependency version specifier.
+ *
+ * Accepts semver ranges, exact versions, dist-tags, URLs,
+ * git refs, GitHub shorthand, file paths, and npm/catalog/workspace protocols.
+ *
+ * @public
+ */
+declare const isValidDependencySpecifier: (s: string) => boolean;
+/**
+ * A valid dependency version specifier.
+ *
+ * @public
+ */
+declare const DependencySpecifier: Schema.brand<Schema.filter<typeof Schema.String>, "DependencySpecifier">;
+/**
+ * Branded type for dependency specifiers.
+ *
+ * @public
+ */
+type DependencySpecifier = Schema.Schema.Type<typeof DependencySpecifier>;
+/**
+ * Opt-in decoder: validate a string as a DependencySpecifier, failing with a
+ * typed InvalidDependencySpecifierError instead of a Schema ParseError.
+ *
+ * @public
+ */
+declare const decodeSpecifier: (input: string) => Effect.Effect<DependencySpecifier, InvalidDependencySpecifierError>;
+//#endregion
+//#region src/schemas/dev-engines.d.ts
+declare const DevEngine_base: Schema.Class<DevEngine, {
+  name: typeof Schema.String;
+  version: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
+    as: "Option";
+  }>;
 }, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    version: typeof Schema.String;
-    integrity: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+  name: typeof Schema.String;
+  version: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  onFail: Schema.optionalWith<Schema.Literal<["warn", "error", "ignore"]>, {
+    as: "Option";
+  }>;
 }>, never, {
-    readonly integrity: Option.Option<string>;
+  readonly name: string;
 } & {
-    readonly name: string;
+  readonly onFail: import("effect/Option").Option<"error" | "ignore" | "warn">;
 } & {
-    readonly version: string;
+  readonly version: import("effect/Option").Option<string>;
 }, {}, {}>;
-
 /**
- * Parses a packageManager string (e.g. "pnpm\@10.33.0+sha512.abc")
- * into a PackageManager class instance with name, version, and
- * optional integrity fields.
+ * A single engine constraint with name, optional version, and optional onFail behavior.
+ *
+ * @public
  */
-export declare const PackageManagerSchema: Schema.Schema<PackageManager, string>;
-
+declare class DevEngine extends DevEngine_base {}
 /**
+ * Schema for the devEngines field, modeling runtime and
+ * package manager constraints with optional arrays.
+ *
+ * @public
+ */
+declare const DevEnginesSchema: Schema.Struct<{
+  packageManager: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+    as: "Option";
+  }>;
+  runtime: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+    as: "Option";
+  }>;
+  os: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+    as: "Option";
+  }>;
+  cpu: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+    as: "Option";
+  }>;
+  libc: Schema.optionalWith<Schema.Union<[typeof DevEngine, Schema.Array$<typeof DevEngine>]>, {
+    as: "Option";
+  }>;
+}>;
+/**
+ * Decoded type for the devEngines field.
+ *
+ * @public
+ */
+type DevEngines = Schema.Schema.Type<typeof DevEnginesSchema>;
+//#endregion
+//#region src/schemas/engines.d.ts
+/**
+ * Engines field: map of engine names to semver ranges.
+ *
+ * @public
+ */
+declare const EnginesSchema: Schema.Schema<HashMap.HashMap<string, string>, {
+  readonly [x: string]: string;
+}>;
+//#endregion
+//#region src/schemas/exports-field.d.ts
+/**
+ * Exports field: either a single string entry point or an object
+ * mapping subpaths to file paths (or null to block).
+ *
+ * The object form accepts any value shape to support conditional
+ * exports with nested objects (e.g. `{ "import": "./esm.js", "require": "./cjs.js" }`).
+ *
+ * @public
+ */
+declare const ExportsFieldSchema: Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
+/**
+ * Decoded type for the exports field.
+ *
+ * @public
+ */
+type ExportsField = Schema.Schema.Type<typeof ExportsFieldSchema>;
+//#endregion
+//#region src/schemas/license.d.ts
+/**
+ * A valid SPDX license identifier, expression, "UNLICENSED",
+ * or "SEE LICENSE IN filename".
+ *
+ * @public
+ */
+declare const SpdxLicense: Schema.brand<Schema.filter<typeof Schema.String>, "SpdxLicense">;
+/**
+ * Branded type for SPDX license strings.
+ *
+ * @public
+ */
+type SpdxLicense = Schema.Schema.Type<typeof SpdxLicense>;
+//#endregion
+//#region src/schemas/name.d.ts
+/**
+ * Validates a string as a valid npm package name.
+ *
+ * Rules: max 214 chars, lowercase, URL-safe characters only,
+ * cannot start with . or _ (unless scoped).
+ *
+ * @public
+ */
+declare const isValidPackageName: (s: string) => boolean;
+/**
+ * A valid npm scoped package name (starts with \@scope/).
+ *
+ * @public
+ */
+declare const ScopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">;
+/**
+ * Branded type for scoped package names.
+ *
+ * @public
+ */
+type ScopedPackageName = Schema.Schema.Type<typeof ScopedPackageName>;
+/**
+ * A valid npm unscoped package name (does not start with \@).
+ *
+ * @public
+ */
+declare const UnscopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">;
+/**
+ * Branded type for unscoped package names.
+ *
+ * @public
+ */
+type UnscopedPackageName = Schema.Schema.Type<typeof UnscopedPackageName>;
+/**
  * A valid npm package name, either scoped or unscoped.
+ *
+ * @public
  */
 declare const PackageName: Schema.Union<[Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">, Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">]>;
-
-/** Branded type for any valid package name. */
-declare type PackageName = Schema.Schema.Type<typeof PackageName>;
-export { PackageName }
-export { PackageName as PackageNameType }
-
-export declare class PeerDependency extends PeerDependency_base implements DependencyProtocolGetters {
-    get protocol(): Option.Option<DependencyProtocol>;
-    get range(): Option.Option<Range>;
-    get isLocal(): boolean;
-    get isLink(): boolean;
-    get isPortal(): boolean;
-    get isCatalog(): boolean;
-    get isWorkspace(): boolean;
-    get isUnresolved(): boolean;
-    get isGit(): boolean;
-    get isRange(): boolean;
-    get isTag(): boolean;
+/**
+ * Branded type for any valid package name.
+ *
+ * @public
+ */
+type PackageName = Schema.Schema.Type<typeof PackageName>;
+//#endregion
+//#region src/schemas/package-json.d.ts
+/**
+ * Build the wire schema (open JSON object ↔ Package class) for the given
+ * Package class or any `.extend()`ed subclass. Reads `Class.fields` so extended
+ * fields are decoded as typed members and excluded from `rest`.
+ *
+ * The transform sits between an open JSON record (`RawJson`) and the class. On
+ * decode it partitions raw keys into known fields and a `rest` record, handing
+ * Effect the class's encoded shape so the class decodes itself. On encode it
+ * receives the class's encoded shape and flattens the literal `rest` key back
+ * into top-level fields, so the on-disk shape never contains a `rest` key.
+ *
+ * @public
+ */
+declare const makePackageJsonSchema: <Self extends Package>(Class: Schema.Schema<Self, any, never> & {
+  readonly fields: Schema.Struct.Fields;
+}) => Schema.Schema<Self, {
+  readonly [k: string]: unknown;
+}, never>;
+/**
+ * The default wire schema: decodes JSON to a Package instance and back.
+ *
+ * @public
+ */
+declare const PackageJsonSchema: Schema.Schema<Package, {
+  readonly [k: string]: unknown;
+}, never>;
+/**
+ * Decoded type for PackageJsonSchema.
+ *
+ * @public
+ */
+type PackageJsonSchemaType = Package;
+/**
+ * Encoded (plain JSON) type for PackageJsonSchema.
+ *
+ * @public
+ */
+interface PackageJsonSchemaEncoded {
+  readonly [k: string]: unknown;
 }
-
-declare const PeerDependency_base: Schema.TaggedClass<PeerDependency, "PeerDependency", {
-    readonly _tag: Schema.tag<"PeerDependency">;
+//#endregion
+//#region src/schemas/package-manager.d.ts
+declare const PackageManager_base: Schema.Class<PackageManager, {
+  name: typeof Schema.String;
+  version: typeof Schema.String;
+  integrity: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+}, Schema.Struct.Encoded<{
+  name: typeof Schema.String;
+  version: typeof Schema.String;
+  integrity: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+}>, never, {
+  readonly integrity: Option.Option<string>;
 } & {
-    name: typeof Schema.String;
-    specifier: typeof Schema.String;
-    isOptional: typeof Schema.Boolean;
-}>;
-
+  readonly name: string;
+} & {
+  readonly version: string;
+}, {}, {}>;
 /**
- * Structured person object with name, optional email and url.
+ * Structured packageManager value with name, version, and optional integrity.
+ *
+ * @public
  */
-export declare class Person extends Person_base {
+declare class PackageManager extends PackageManager_base {
+  get hasIntegrity(): boolean;
 }
-
+/**
+ * Parses a packageManager string (e.g. "pnpm\@10.33.0+sha512.abc")
+ * into a PackageManager class instance with name, version, and
+ * optional integrity fields.
+ *
+ * @public
+ */
+declare const PackageManagerSchema: Schema.Schema<PackageManager, string>;
+//#endregion
+//#region src/schemas/person.d.ts
 declare const Person_base: Schema.Class<Person, {
-    name: typeof Schema.String;
-    email: Schema.optional<typeof Schema.String>;
-    url: Schema.optional<typeof Schema.String>;
+  name: typeof Schema.String;
+  email: Schema.optional<typeof Schema.String>;
+  url: Schema.optional<typeof Schema.String>;
 }, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    email: Schema.optional<typeof Schema.String>;
-    url: Schema.optional<typeof Schema.String>;
+  name: typeof Schema.String;
+  email: Schema.optional<typeof Schema.String>;
+  url: Schema.optional<typeof Schema.String>;
 }>, never, {
-    readonly email?: string | undefined;
+  readonly email?: string | undefined;
 } & {
-    readonly url?: string | undefined;
+  readonly url?: string | undefined;
 } & {
-    readonly name: string;
+  readonly name: string;
 }, {}, {}>;
-
 /**
+ * Structured person object with name, optional email and url.
+ *
+ * @public
+ */
+declare class Person extends Person_base {}
+/**
  * Person field: either a string "Name email (url)" shorthand or a
  * structured object with name, email, and url fields.
  * Always decoded to the object form.
+ *
+ * @public
  */
-export declare const PersonSchema: Schema.Union<[typeof Person, Schema.transform<typeof Schema.String, Schema.SchemaClass<Person, Person, never>>]>;
-
-export declare type PublishConfig = Schema.Schema.Type<typeof PublishConfigSchema>;
-
+declare const PersonSchema: Schema.Union<[typeof Person, Schema.transform<typeof Schema.String, Schema.SchemaClass<Person, Person, never>>]>;
+//#endregion
+//#region src/schemas/publish-config.d.ts
 /**
  * Schema for the publishConfig field with typed known fields
  * and an open record for arbitrary extensions like targets.
+ *
+ * @public
  */
-export declare const PublishConfigSchema: Schema.TypeLiteral<{
-    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
-        as: "Option";
-    }>;
-    directory: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    registry: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
-    }>;
+declare const PublishConfigSchema: Schema.TypeLiteral<{
+  access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+    as: "Option";
+  }>;
+  directory: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  registry: Schema.optionalWith<typeof Schema.String, {
+    as: "Option";
+  }>;
+  linkDirectory: Schema.optionalWith<typeof Schema.Boolean, {
+    as: "Option";
+  }>;
 }, readonly [{
-    readonly key: typeof Schema.String;
-    readonly value: typeof Schema.Unknown;
+  readonly key: typeof Schema.String;
+  readonly value: typeof Schema.Unknown;
 }]>;
-
 /**
- * A valid npm scoped package name (starts with \@scope/).
+ * Decoded type for the publishConfig field.
+ *
+ * @public
  */
-declare const ScopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "ScopedPackageName">;
-
-/** Branded type for scoped package names. */
-declare type ScopedPackageName = Schema.Schema.Type<typeof ScopedPackageName>;
-export { ScopedPackageName }
-export { ScopedPackageName as ScopedPackageNameType }
-
+type PublishConfig = Schema.Schema.Type<typeof PublishConfigSchema>;
+//#endregion
+//#region src/schemas/scripts.d.ts
 /**
  * Scripts field: plain JSON object decoded to/from HashMap of string to string.
  * Same structure as DependencyMapSchema.
+ *
+ * @public
  */
-export declare const ScriptsSchema: Schema_2<HashMap_2<string, string>, {
-readonly [x: string]: string;
+declare const ScriptsSchema: import("effect/Schema").Schema<import("effect/HashMap").HashMap<string, string>, {
+  readonly [x: string]: string;
 }, never>;
-
+//#endregion
+//#region src/schemas/version.d.ts
 /**
- * A valid SPDX license identifier, expression, "UNLICENSED",
- * or "SEE LICENSE IN filename".
- */
-declare const SpdxLicense: Schema.brand<Schema.filter<typeof Schema.String>, "SpdxLicense">;
-
-/** Branded type for SPDX license strings. */
-declare type SpdxLicense = Schema.Schema.Type<typeof SpdxLicense>;
-export { SpdxLicense }
-export { SpdxLicense as SpdxLicenseType }
-
-/** A Dependency whose specifier is an unresolved catalog: or workspace: protocol. */
-export declare type UnresolvedDependency = Dependency & {
-    readonly isUnresolved: true;
-};
-
-/**
- * A valid npm unscoped package name (does not start with \@).
- */
-declare const UnscopedPackageName: Schema.brand<Schema.filter<typeof Schema.String>, "UnscopedPackageName">;
-
-/** Branded type for unscoped package names. */
-declare type UnscopedPackageName = Schema.Schema.Type<typeof UnscopedPackageName>;
-export { UnscopedPackageName }
-export { UnscopedPackageName as UnscopedPackageNameType }
-
-/**
  * Schema that decodes a version string into a SemVer instance
  * and encodes it back to a string. Uses semver-effect for parsing.
+ *
+ * @public
  */
-export declare const VersionSchema: Schema.Schema<SemVer, string>;
-
-/**
- * Resolves workspace: protocol specifiers. Given a workspace package name,
- * returns its concrete version (without range modifier), or None if it cannot
- * be resolved (default no-op behavior).
- */
-export declare class WorkspaceResolver extends WorkspaceResolver_base {
-}
-
-declare const WorkspaceResolver_base: Context.TagClass<WorkspaceResolver, "package-json-effect/WorkspaceResolver", {
-    readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
-}>;
-
-export { }
+declare const VersionSchema: Schema.Schema<SemVer, string>;
+//#endregion
+export { BinSchema, CatalogResolver, Dependency, DependencyMapSchema, type DependencyProtocol, type DependencyProtocolGetters, DependencyResolutionError, DependencyResolutionErrorBase, DependencySpecifier, type DependencySpecifier as DependencySpecifierType, DevDependency, DevEngine, type DevEngines, DevEnginesSchema, EnginesSchema, type ExportsField, ExportsFieldSchema, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonSchema, type PackageJsonSchemaEncoded, type PackageJsonSchemaType, PackageManager, PackageManagerSchema, PackageName, type PackageName as PackageNameType, PeerDependency, Person, PersonSchema, type PublishConfig, PublishConfigSchema, ScopedPackageName, type ScopedPackageName as ScopedPackageNameType, ScriptsSchema, SpdxLicense, type SpdxLicense as SpdxLicenseType, type UnresolvedDependency, UnscopedPackageName, type UnscopedPackageName as UnscopedPackageNameType, VersionSchema, WorkspaceResolver, decodeSpecifier, isValidDependencySpecifier, isValidPackageName, makePackageJsonSchema };
+//# sourceMappingURL=schema.d.ts.map

schema.js

@@ -1,60 +0,27 @@
-import { Effect, Schema } from "effect";
-import { InvalidDependencySpecifierError } from "./471.js";
-const isValidDependencySpecifier = (s)=>{
-    if (0 === s.length) return false;
-    if (s.startsWith("file:")) return true;
-    if (s.startsWith("link:")) return true;
-    if (s.startsWith("portal:")) return true;
-    if (s.startsWith("git+")) return true;
-    if (s.startsWith("git://")) return true;
-    if (s.startsWith("github:")) return true;
-    if (s.startsWith("gist:")) return true;
-    if (s.startsWith("bitbucket:")) return true;
-    if (s.startsWith("gitlab:")) return true;
-    if (s.startsWith("http://") || s.startsWith("https://")) return true;
-    if (s.startsWith("npm:")) return true;
-    if (s.startsWith("catalog:")) return true;
-    if (s.startsWith("workspace:")) return true;
-    if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(#.*)?$/.test(s)) return true;
-    if (/^[\d^~>=<*|xX]/.test(s)) return true;
-    if (/^[a-zA-Z][a-zA-Z0-9._-]*$/.test(s)) return true;
-    return false;
-};
-const DependencySpecifier = Schema.String.pipe(Schema.filter((s)=>isValidDependencySpecifier(s) || "Expected a valid dependency specifier"), Schema.brand("DependencySpecifier"));
-const decodeSpecifier = (input)=>Schema.decodeUnknown(DependencySpecifier)(input).pipe(Effect.mapError(()=>new InvalidDependencySpecifierError({
-            input,
-            reason: "Not a recognized dependency specifier"
-        })));
-class Person extends Schema.Class("Person")({
-    name: Schema.String,
-    email: Schema.optional(Schema.String),
-    url: Schema.optional(Schema.String)
-}) {
-}
-const parsePersonString = (s)=>{
-    const emailMatch = s.match(/<([^>]+)>/);
-    const urlMatch = s.match(/\(([^)]+)\)/);
-    let name = s;
-    if (emailMatch) name = name.replace(emailMatch[0], "");
-    if (urlMatch) name = name.replace(urlMatch[0], "");
-    name = name.trim();
-    const fields = {
-        name
-    };
-    if (emailMatch) fields.email = emailMatch[1];
-    if (urlMatch) fields.url = urlMatch[1];
-    return new Person(fields, true);
-};
-const PersonFromString = Schema.transform(Schema.String, Schema.typeSchema(Person), {
-    strict: true,
-    decode: (s)=>parsePersonString(s),
-    encode: (p)=>{
-        let result = p.name;
-        if (p.email) result += ` <${p.email}>`;
-        if (p.url) result += ` (${p.url})`;
-        return result;
-    }
-});
-const PersonSchema = Schema.Union(Person, PersonFromString);
-export { BinSchema, CatalogResolver, Dependency, DependencyMapSchema, DependencyResolutionError, DependencyResolutionErrorBase, DevDependency, DevEngine, DevEnginesSchema, EnginesSchema, ExportsFieldSchema, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonSchema, PackageManager, PackageManagerSchema, PackageName, PeerDependency, PublishConfigSchema, ScopedPackageName, ScriptsSchema, SpdxLicense, UnscopedPackageName, VersionSchema, WorkspaceResolver, isValidPackageName, makePackageJsonSchema } from "./471.js";
-export { DependencySpecifier, Person, PersonSchema, decodeSpecifier, isValidDependencySpecifier };
+import { Dependency } from "./domain/Dependency.js";
+import { DevDependency } from "./domain/DevDependency.js";
+import { OptionalDependency } from "./domain/OptionalDependency.js";
+import { InvalidPackageNameError, InvalidPackageNameErrorBase } from "./errors/InvalidPackageNameError.js";
+import { InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase } from "./errors/InvalidSpdxLicenseError.js";
+import { BinSchema } from "./schemas/bin.js";
+import { DependencyMapSchema } from "./schemas/dependency-map.js";
+import { DevEngine, DevEnginesSchema } from "./schemas/dev-engines.js";
+import { EnginesSchema } from "./schemas/engines.js";
+import { ExportsFieldSchema } from "./schemas/exports-field.js";
+import { SpdxLicense } from "./schemas/license.js";
+import { PackageName, ScopedPackageName, UnscopedPackageName, isValidPackageName } from "./schemas/name.js";
+import { PackageManager, PackageManagerSchema } from "./schemas/package-manager.js";
+import { PublishConfigSchema } from "./schemas/publish-config.js";
+import { ScriptsSchema } from "./schemas/scripts.js";
+import { VersionSchema } from "./schemas/version.js";
+import { CatalogResolver } from "./services/CatalogResolver.js";
+import { WorkspaceResolver } from "./services/WorkspaceResolver.js";
+import { PeerDependency } from "./domain/PeerDependency.js";
+import { Package } from "./domain/Package.js";
+import { DependencyResolutionError, DependencyResolutionErrorBase } from "./errors/DependencyResolutionError.js";
+import { InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase } from "./errors/InvalidDependencySpecifierError.js";
+import { PackageJsonSchema, makePackageJsonSchema } from "./schemas/package-json.js";
+import { DependencySpecifier, decodeSpecifier, isValidDependencySpecifier } from "./schemas/dependency-specifier.js";
+import { Person, PersonSchema } from "./schemas/person.js";
+
+export { BinSchema, CatalogResolver, Dependency, DependencyMapSchema, DependencyResolutionError, DependencyResolutionErrorBase, DependencySpecifier, DevDependency, DevEngine, DevEnginesSchema, EnginesSchema, ExportsFieldSchema, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonSchema, PackageManager, PackageManagerSchema, PackageName, PeerDependency, Person, PersonSchema, PublishConfigSchema, ScopedPackageName, ScriptsSchema, SpdxLicense, UnscopedPackageName, VersionSchema, WorkspaceResolver, decodeSpecifier, isValidDependencySpecifier, isValidPackageName, makePackageJsonSchema };

tsdoc-metadata.json

@@ -8,5 +8,5 @@ // This file is read by tools that parse documentation comments conforming to the TSDoc standard.
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.7"
+      "packageVersion": "7.58.9"
     }
   ]
 }

471.js

-import { Context, Data, Effect, HashMap, Option, ParseResult, Pipeable, Schema } from "effect";
-import { SemVer, parseRange, parseValidSemVer } from "semver-effect";
-import { dual } from "effect/Function";
-import spdx_expression_parse from "spdx-expression-parse";
-const isBarePath = (s)=>s.startsWith("./") || s.startsWith("../") || s.startsWith("~/") || s.startsWith("/");
-const isLocalSpecifier = (s)=>s.startsWith("file:") || s.startsWith("link:") || s.startsWith("portal:") || isBarePath(s);
-const isGitHubShorthand = (s)=>!s.startsWith(".") && !s.startsWith("~") && !s.startsWith("/") && /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(#.*)?$/.test(s);
-const isGitSpecifier = (s)=>s.startsWith("git+") || s.startsWith("git://") || s.startsWith("github:") || s.startsWith("gist:") || s.startsWith("bitbucket:") || s.startsWith("gitlab:") || isGitHubShorthand(s);
-const isRangeSpecifier = (s)=>Option.isSome(parseRangeOption(s));
-const isTagSpecifier = (s)=>"tag" === protocolOf(s);
-const parseRangeOption = (s)=>Effect.runSync(Effect.option(parseRange(s)));
-const protocolOf = (s)=>{
-    if (s.startsWith("catalog:")) return "catalog";
-    if (s.startsWith("workspace:")) return "workspace";
-    if (s.startsWith("link:")) return "link";
-    if (s.startsWith("portal:")) return "portal";
-    if (s.startsWith("file:") || isBarePath(s)) return "file";
-    if (s.startsWith("npm:")) return "npm";
-    if (isGitSpecifier(s)) return "git";
-    if (s.startsWith("http://") || s.startsWith("https://")) return "url";
-    if (Option.isSome(parseRangeOption(s))) return "range";
-    if (/^[a-zA-Z][a-zA-Z0-9._-]*$/.test(s)) return "tag";
-    return "unknown";
-};
-class Dependency extends Schema.TaggedClass()("Dependency", {
-    name: Schema.String,
-    specifier: Schema.String
-}) {
-    get protocol() {
-        return 0 === this.specifier.length ? Option.none() : Option.some(protocolOf(this.specifier));
-    }
-    get range() {
-        return parseRangeOption(this.specifier);
-    }
-    get isLocal() {
-        return isLocalSpecifier(this.specifier);
-    }
-    get isLink() {
-        return this.specifier.startsWith("link:");
-    }
-    get isPortal() {
-        return this.specifier.startsWith("portal:");
-    }
-    get isCatalog() {
-        return this.specifier.startsWith("catalog:");
-    }
-    get isWorkspace() {
-        return this.specifier.startsWith("workspace:");
-    }
-    get isUnresolved() {
-        return this.isCatalog || this.isWorkspace;
-    }
-    get isGit() {
-        return isGitSpecifier(this.specifier);
-    }
-    get isRange() {
-        return isRangeSpecifier(this.specifier);
-    }
-    get isTag() {
-        return isTagSpecifier(this.specifier);
-    }
-}
-const isUnresolvedDependency = (dep)=>true === dep.isUnresolved;
-class DevDependency extends Schema.TaggedClass()("DevDependency", {
-    name: Schema.String,
-    specifier: Schema.String
-}) {
-    get protocol() {
-        return 0 === this.specifier.length ? Option.none() : Option.some(protocolOf(this.specifier));
-    }
-    get range() {
-        return parseRangeOption(this.specifier);
-    }
-    get isLocal() {
-        return isLocalSpecifier(this.specifier);
-    }
-    get isLink() {
-        return this.specifier.startsWith("link:");
-    }
-    get isPortal() {
-        return this.specifier.startsWith("portal:");
-    }
-    get isCatalog() {
-        return this.specifier.startsWith("catalog:");
-    }
-    get isWorkspace() {
-        return this.specifier.startsWith("workspace:");
-    }
-    get isUnresolved() {
-        return this.isCatalog || this.isWorkspace;
-    }
-    get isGit() {
-        return isGitSpecifier(this.specifier);
-    }
-    get isRange() {
-        return isRangeSpecifier(this.specifier);
-    }
-    get isTag() {
-        return isTagSpecifier(this.specifier);
-    }
-}
-class OptionalDependency extends Schema.TaggedClass()("OptionalDependency", {
-    name: Schema.String,
-    specifier: Schema.String
-}) {
-    get protocol() {
-        return 0 === this.specifier.length ? Option.none() : Option.some(protocolOf(this.specifier));
-    }
-    get range() {
-        return parseRangeOption(this.specifier);
-    }
-    get isLocal() {
-        return isLocalSpecifier(this.specifier);
-    }
-    get isLink() {
-        return this.specifier.startsWith("link:");
-    }
-    get isPortal() {
-        return this.specifier.startsWith("portal:");
-    }
-    get isCatalog() {
-        return this.specifier.startsWith("catalog:");
-    }
-    get isWorkspace() {
-        return this.specifier.startsWith("workspace:");
-    }
-    get isUnresolved() {
-        return this.isCatalog || this.isWorkspace;
-    }
-    get isGit() {
-        return isGitSpecifier(this.specifier);
-    }
-    get isRange() {
-        return isRangeSpecifier(this.specifier);
-    }
-    get isTag() {
-        return isTagSpecifier(this.specifier);
-    }
-}
-const InvalidPackageNameErrorBase = Data.TaggedError("InvalidPackageNameError");
-class InvalidPackageNameError extends InvalidPackageNameErrorBase {
-    get message() {
-        return `Invalid package name "${this.input}": ${this.reason}`;
-    }
-}
-const InvalidSpdxLicenseErrorBase = Data.TaggedError("InvalidSpdxLicenseError");
-class InvalidSpdxLicenseError extends InvalidSpdxLicenseErrorBase {
-    get message() {
-        return `Invalid SPDX license "${this.input}": ${this.reason}`;
-    }
-}
-const BinMapSchema = Schema.transform(Schema.Record({
-    key: Schema.String,
-    value: Schema.String
-}), Schema.typeSchema(Schema.HashMap({
-    key: Schema.String,
-    value: Schema.String
-})), {
-    strict: true,
-    decode: (record)=>HashMap.fromIterable(Object.entries(record)),
-    encode: (map)=>Object.fromEntries(HashMap.toEntries(map))
-});
-const BinSchema = Schema.Union(Schema.String, BinMapSchema);
-const StringRecord = Schema.Record({
-    key: Schema.String,
-    value: Schema.String
-});
-const DependencyMapSchema = Schema.transform(StringRecord, Schema.typeSchema(Schema.HashMap({
-    key: Schema.String,
-    value: Schema.String
-})), {
-    strict: true,
-    decode: (record)=>HashMap.fromIterable(Object.entries(record)),
-    encode: (map)=>Object.fromEntries(HashMap.toEntries(map))
-});
-const OnFail = Schema.Literal("warn", "error", "ignore");
-class DevEngine extends Schema.Class("DevEngine")({
-    name: Schema.String,
-    version: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    onFail: Schema.optionalWith(OnFail, {
-        as: "Option"
-    })
-}) {
-}
-const DevEngineOrArray = Schema.Union(DevEngine, Schema.Array(DevEngine));
-const DevEnginesSchema = Schema.Struct({
-    packageManager: Schema.optionalWith(DevEngineOrArray, {
-        as: "Option"
-    }),
-    runtime: Schema.optionalWith(DevEngineOrArray, {
-        as: "Option"
-    }),
-    os: Schema.optionalWith(DevEngineOrArray, {
-        as: "Option"
-    }),
-    cpu: Schema.optionalWith(DevEngineOrArray, {
-        as: "Option"
-    }),
-    libc: Schema.optionalWith(DevEngineOrArray, {
-        as: "Option"
-    })
-});
-const EnginesSchema = Schema.transform(Schema.Record({
-    key: Schema.String,
-    value: Schema.String
-}), Schema.typeSchema(Schema.HashMap({
-    key: Schema.String,
-    value: Schema.String
-})), {
-    strict: true,
-    decode: (record)=>HashMap.fromIterable(Object.entries(record)),
-    encode: (map)=>Object.fromEntries(HashMap.toEntries(map))
-});
-const ExportsObject = Schema.Record({
-    key: Schema.String,
-    value: Schema.Unknown
-});
-const ExportsFieldSchema = Schema.Union(Schema.String, ExportsObject);
-const isValidSpdx = (s)=>{
-    if ("UNLICENSED" === s) return true;
-    if (s.startsWith("SEE LICENSE IN ") && s.length > 15) return true;
-    try {
-        spdx_expression_parse(s);
-        return true;
-    } catch  {
-        return false;
-    }
-};
-const SpdxLicense = Schema.String.pipe(Schema.filter((s)=>isValidSpdx(s) || "Expected a valid SPDX license identifier or expression"), Schema.brand("SpdxLicense"));
-const isValidPackageName = (s)=>{
-    if (0 === s.length || s.length > 214) return false;
-    if (s.startsWith("@")) {
-        const slashIndex = s.indexOf("/");
-        if (-1 === slashIndex || 1 === slashIndex || slashIndex === s.length - 1) return false;
-        if (-1 !== s.indexOf("/", slashIndex + 1)) return false;
-        const scope = s.slice(1, slashIndex);
-        const name = s.slice(slashIndex + 1);
-        return isValidNameChars(scope) && isValidNameChars(name);
-    }
-    if (s.startsWith(".") || s.startsWith("_")) return false;
-    return isValidNameChars(s);
-};
-const isValidNameChars = (s)=>/^[a-z0-9._-]+$/.test(s);
-const ScopedPackageName = Schema.String.pipe(Schema.filter((s)=>s.startsWith("@") && isValidPackageName(s) || "Expected a scoped package name (@scope/name)"), Schema.brand("ScopedPackageName"));
-const UnscopedPackageName = Schema.String.pipe(Schema.filter((s)=>!s.startsWith("@") && isValidPackageName(s) || "Expected an unscoped package name"), Schema.brand("UnscopedPackageName"));
-const PackageName = Schema.Union(ScopedPackageName, UnscopedPackageName);
-class PackageManager extends Schema.Class("PackageManager")({
-    name: Schema.String,
-    version: Schema.String,
-    integrity: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    })
-}) {
-    get hasIntegrity() {
-        return Option.isSome(this.integrity);
-    }
-}
-const PACKAGE_MANAGER_REGEX = /^([a-z]+)@(\d+\.\d+\.\d+(?:-[a-zA-Z0-9._-]+)?)(?:\+(.+))?$/;
-const PackageManagerSchema = Schema.transformOrFail(Schema.String, Schema.typeSchema(PackageManager), {
-    strict: true,
-    decode: (s, _options, ast)=>{
-        const match = s.match(PACKAGE_MANAGER_REGEX);
-        if (!match) return ParseResult.fail(new ParseResult.Type(ast, s, `Invalid packageManager format: "${s}"`));
-        return ParseResult.succeed(new PackageManager({
-            name: match[1],
-            version: match[2],
-            integrity: match[3] ? Option.some(match[3]) : Option.none()
-        }, true));
-    },
-    encode: (pm)=>{
-        let result = `${pm.name}@${pm.version}`;
-        if (Option.isSome(pm.integrity)) result += `+${pm.integrity.value}`;
-        return ParseResult.succeed(result);
-    }
-});
-const PublishConfigSchema = Schema.Struct({
-    access: Schema.optionalWith(Schema.Literal("public", "restricted"), {
-        as: "Option"
-    }),
-    directory: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    registry: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    linkDirectory: Schema.optionalWith(Schema.Boolean, {
-        as: "Option"
-    })
-}, {
-    key: Schema.String,
-    value: Schema.Unknown
-});
-const ScriptsSchema = DependencyMapSchema;
-const VersionSchema = Schema.transformOrFail(Schema.String, Schema.typeSchema(SemVer), {
-    strict: true,
-    decode: (input, _options, ast)=>parseValidSemVer(input).pipe(Effect.mapError(()=>new ParseResult.Type(ast, input, `Invalid semver version: "${input}"`))),
-    encode: (semver)=>ParseResult.succeed(semver.toString())
-});
-class CatalogResolver extends Context.Tag("package-json-effect/CatalogResolver")() {
-}
-class WorkspaceResolver extends Context.Tag("package-json-effect/WorkspaceResolver")() {
-}
-const PackageNameUtil = {
-    scope: (name)=>{
-        if (!name.startsWith("@")) return Option.none();
-        const slashIndex = name.indexOf("/");
-        if (-1 === slashIndex) return Option.none();
-        return Option.some(name.slice(1, slashIndex));
-    },
-    unscoped: (name)=>{
-        if (!name.startsWith("@")) return name;
-        const slashIndex = name.indexOf("/");
-        return -1 === slashIndex ? name : name.slice(slashIndex + 1);
-    },
-    isScoped: (name)=>name.startsWith("@")
-};
-class PeerDependency extends Schema.TaggedClass()("PeerDependency", {
-    name: Schema.String,
-    specifier: Schema.String,
-    isOptional: Schema.Boolean
-}) {
-    get protocol() {
-        return 0 === this.specifier.length ? Option.none() : Option.some(protocolOf(this.specifier));
-    }
-    get range() {
-        return parseRangeOption(this.specifier);
-    }
-    get isLocal() {
-        return isLocalSpecifier(this.specifier);
-    }
-    get isLink() {
-        return this.specifier.startsWith("link:");
-    }
-    get isPortal() {
-        return this.specifier.startsWith("portal:");
-    }
-    get isCatalog() {
-        return this.specifier.startsWith("catalog:");
-    }
-    get isWorkspace() {
-        return this.specifier.startsWith("workspace:");
-    }
-    get isUnresolved() {
-        return this.isCatalog || this.isWorkspace;
-    }
-    get isGit() {
-        return isGitSpecifier(this.specifier);
-    }
-    get isRange() {
-        return isRangeSpecifier(this.specifier);
-    }
-    get isTag() {
-        return isTagSpecifier(this.specifier);
-    }
-}
-const applyWorkspaceModifier = (specifier, version)=>{
-    const mod = specifier.slice(10);
-    if ("*" === mod || "" === mod) return version;
-    if ("^" === mod) return `^${version}`;
-    if ("~" === mod) return `~${version}`;
-    return mod;
-};
-const catalogName = (specifier)=>{
-    const name = specifier.slice(8);
-    return 0 === name.length ? Option.none() : Option.some(name);
-};
-class Package extends Schema.Class("Package")({
-    name: PackageName,
-    version: VersionSchema,
-    description: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    private: Schema.optionalWith(Schema.Boolean, {
-        as: "Option"
-    }),
-    type: Schema.optionalWith(Schema.Literal("module", "commonjs"), {
-        as: "Option"
-    }),
-    main: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    license: Schema.optionalWith(Schema.String, {
-        as: "Option"
-    }),
-    dependencies: Schema.optionalWith(DependencyMapSchema, {
-        default: ()=>HashMap.empty()
-    }),
-    devDependencies: Schema.optionalWith(DependencyMapSchema, {
-        default: ()=>HashMap.empty()
-    }),
-    peerDependencies: Schema.optionalWith(DependencyMapSchema, {
-        default: ()=>HashMap.empty()
-    }),
-    optionalDependencies: Schema.optionalWith(DependencyMapSchema, {
-        default: ()=>HashMap.empty()
-    }),
-    peerDependenciesMeta: Schema.optionalWith(Schema.Record({
-        key: Schema.String,
-        value: Schema.Struct({
-            optional: Schema.optional(Schema.Boolean)
-        })
-    }), {
-        as: "Option"
-    }),
-    scripts: Schema.optionalWith(ScriptsSchema, {
-        default: ()=>HashMap.empty()
-    }),
-    bin: Schema.optionalWith(BinSchema, {
-        as: "Option"
-    }),
-    engines: Schema.optionalWith(EnginesSchema, {
-        as: "Option"
-    }),
-    exports: Schema.optionalWith(ExportsFieldSchema, {
-        as: "Option"
-    }),
-    publishConfig: Schema.optionalWith(PublishConfigSchema, {
-        as: "Option"
-    }),
-    packageManager: Schema.optionalWith(PackageManagerSchema, {
-        as: "Option"
-    }),
-    devEngines: Schema.optionalWith(DevEnginesSchema, {
-        as: "Option"
-    }),
-    rest: Schema.optionalWith(Schema.Data(Schema.Record({
-        key: Schema.String,
-        value: Schema.Unknown
-    })), {
-        default: ()=>Data.struct({})
-    })
-}) {
-    get isPrivate() {
-        return Option.getOrElse(this.private, ()=>false);
-    }
-    get isScoped() {
-        return PackageNameUtil.isScoped(this.name);
-    }
-    get isESM() {
-        return Option.match(this.type, {
-            onNone: ()=>false,
-            onSome: (t)=>"module" === t
-        });
-    }
-    pipe() {
-        return Pipeable.pipeArguments(this, arguments);
-    }
-    hasDependency(name) {
-        return HashMap.has(this.dependencies, name) || HashMap.has(this.devDependencies, name) || HashMap.has(this.peerDependencies, name) || HashMap.has(this.optionalDependencies, name);
-    }
-    getDependencies() {
-        return HashMap.map(this.dependencies, (specifier, name)=>new Dependency({
-                name,
-                specifier
-            }));
-    }
-    getDevDependencies() {
-        return HashMap.map(this.devDependencies, (specifier, name)=>new DevDependency({
-                name,
-                specifier
-            }));
-    }
-    getPeerDependencies() {
-        const meta = Option.getOrElse(this.peerDependenciesMeta, ()=>({}));
-        return HashMap.map(this.peerDependencies, (specifier, name)=>new PeerDependency({
-                name,
-                specifier,
-                isOptional: meta[name]?.optional ?? false
-            }));
-    }
-    getOptionalDependencies() {
-        return HashMap.map(this.optionalDependencies, (specifier, name)=>new OptionalDependency({
-                name,
-                specifier
-            }));
-    }
-    copyWith(patch) {
-        return new Package({
-            ...this,
-            ...patch
-        }, {
-            disableValidation: true
-        });
-    }
-    static fromData(data) {
-        return new Package(data, {
-            disableValidation: true
-        });
-    }
-    static setVersion = dual(2, (pkg, version)=>parseValidSemVer(version).pipe(Effect.map((semver)=>pkg.copyWith({
-                version: semver
-            }))));
-    static setName = dual(2, (pkg, name)=>isValidPackageName(name) ? Effect.succeed(pkg.copyWith({
-            name
-        })) : Effect.fail(new InvalidPackageNameError({
-            input: name,
-            reason: "Does not satisfy npm naming rules"
-        })));
-    static addDependency = dual(3, (pkg, name, specifier)=>pkg.copyWith({
-            dependencies: HashMap.set(pkg.dependencies, name, specifier)
-        }));
-    static removeDependency = dual(2, (pkg, name)=>pkg.copyWith({
-            dependencies: HashMap.remove(pkg.dependencies, name)
-        }));
-    static addDevDependency = dual(3, (pkg, name, specifier)=>pkg.copyWith({
-            devDependencies: HashMap.set(pkg.devDependencies, name, specifier)
-        }));
-    static removeDevDependency = dual(2, (pkg, name)=>pkg.copyWith({
-            devDependencies: HashMap.remove(pkg.devDependencies, name)
-        }));
-    static addPeerDependency = dual(3, (pkg, name, specifier)=>pkg.copyWith({
-            peerDependencies: HashMap.set(pkg.peerDependencies, name, specifier)
-        }));
-    static removePeerDependency = dual(2, (pkg, name)=>pkg.copyWith({
-            peerDependencies: HashMap.remove(pkg.peerDependencies, name)
-        }));
-    static addOptionalDependency = dual(3, (pkg, name, specifier)=>pkg.copyWith({
-            optionalDependencies: HashMap.set(pkg.optionalDependencies, name, specifier)
-        }));
-    static removeOptionalDependency = dual(2, (pkg, name)=>pkg.copyWith({
-            optionalDependencies: HashMap.remove(pkg.optionalDependencies, name)
-        }));
-    static setScript = dual(3, (pkg, name, command)=>pkg.copyWith({
-            scripts: HashMap.set(pkg.scripts, name, command)
-        }));
-    static removeScript = dual(2, (pkg, name)=>pkg.copyWith({
-            scripts: HashMap.remove(pkg.scripts, name)
-        }));
-    static setLicense = dual(2, (pkg, license)=>Schema.decodeUnknown(SpdxLicense)(license).pipe(Effect.mapError(()=>new InvalidSpdxLicenseError({
-                input: license,
-                reason: "Not a recognized SPDX identifier or expression"
-            })), Effect.map(()=>pkg.copyWith({
-                license: Option.some(license)
-            }))));
-    static resolve(pkg) {
-        return Effect.gen(function*() {
-            const ws = yield* WorkspaceResolver;
-            const cat = yield* CatalogResolver;
-            const resolveMap = (map)=>Effect.gen(function*() {
-                    let next = map;
-                    for (const [name, specifier] of HashMap.entries(map))if (specifier.startsWith("workspace:")) {
-                        const version = yield* ws.versionOf(name);
-                        if (Option.isSome(version)) next = HashMap.set(next, name, applyWorkspaceModifier(specifier, version.value));
-                    } else if (specifier.startsWith("catalog:")) {
-                        const range = yield* cat.rangeOf(name, catalogName(specifier));
-                        if (Option.isSome(range)) next = HashMap.set(next, name, range.value);
-                    }
-                    return next;
-                });
-            return pkg.copyWith({
-                dependencies: yield* resolveMap(pkg.dependencies),
-                devDependencies: yield* resolveMap(pkg.devDependencies),
-                peerDependencies: yield* resolveMap(pkg.peerDependencies),
-                optionalDependencies: yield* resolveMap(pkg.optionalDependencies)
-            });
-        });
-    }
-}
-const DependencyResolutionErrorBase = Data.TaggedError("DependencyResolutionError");
-class DependencyResolutionError extends DependencyResolutionErrorBase {
-    get message() {
-        return `Failed to resolve "${this.specifier}" for "${this.packageName}": ${this.reason}`;
-    }
-}
-const InvalidDependencySpecifierErrorBase = Data.TaggedError("InvalidDependencySpecifierError");
-class InvalidDependencySpecifierError extends InvalidDependencySpecifierErrorBase {
-    get message() {
-        return `Invalid dependency specifier "${this.input}": ${this.reason}`;
-    }
-}
-const RawJson = Schema.Record({
-    key: Schema.String,
-    value: Schema.Unknown
-});
-const makePackageJsonSchema = (Class)=>{
-    const knownKeys = new Set(Object.keys(Class.fields).filter((k)=>"rest" !== k));
-    const wire = Schema.transformOrFail(RawJson, Class, {
-        strict: false,
-        decode: (raw)=>{
-            const known = {};
-            const rest = {};
-            for (const [k, v] of Object.entries(raw))if (knownKeys.has(k)) known[k] = v;
-            else rest[k] = v;
-            return ParseResult.succeed({
-                ...known,
-                rest
-            });
-        },
-        encode: (encoded)=>{
-            const record = encoded;
-            const { rest, ...known } = record;
-            return ParseResult.succeed({
-                ...known,
-                ...rest ?? {}
-            });
-        }
-    });
-    return wire;
-};
-const PackageJsonSchema = makePackageJsonSchema(Package);
-export { BinSchema, CatalogResolver, Dependency, DependencyMapSchema, DependencyResolutionError, DependencyResolutionErrorBase, DevDependency, DevEngine, DevEnginesSchema, EnginesSchema, ExportsFieldSchema, InvalidDependencySpecifierError, InvalidDependencySpecifierErrorBase, InvalidPackageNameError, InvalidPackageNameErrorBase, InvalidSpdxLicenseError, InvalidSpdxLicenseErrorBase, OptionalDependency, Package, PackageJsonSchema, PackageManager, PackageManagerSchema, PackageName, PackageNameUtil, PeerDependency, PublishConfigSchema, ScopedPackageName, ScriptsSchema, SpdxLicense, UnscopedPackageName, VersionSchema, WorkspaceResolver, isGitSpecifier, isLocalSpecifier, isRangeSpecifier, isTagSpecifier, isUnresolvedDependency, isValidPackageName, makePackageJsonSchema, parseRangeOption, protocolOf };

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Improved metrics

Total package byte prevSize

145823

20.66%

Number of package files

53

488.89%

Lines of code

3696

34.3%

Dependency changes

• + Added

  semver-effect@0.3.1
  (transitive)

• - Removed

  semver-effect@0.2.1
  (transitive)

• Updated

  semver-effect@^0.3.0