@effected/package-json 0.1.0

package/Dependency.js

@@ -0,0 +1,76 @@
+import { DependencyKind, DependencySpecifier } from "@effected/npm";
+import { Option, Schema } from "effect";
+
+//#region src/Dependency.ts
+/**
+* A resolved dependency entry pairing a package name with its version
+* specifier and the `kind` of map it came from (`@effected/npm`'s
+* `DependencyKind`). The protocol predicates delegate to `DependencySpecifier`.
+*
+* @public
+*/
+var Dependency = class extends Schema.Class("Dependency")({
+	/** The package name. */
+	name: Schema.String,
+	/** The raw version specifier. */
+	specifier: Schema.String,
+	/** Which dependency map this entry came from. */
+	kind: DependencyKind,
+	/** For `peer` dependencies, whether the peer is optional (from `peerDependenciesMeta`). */
+	isOptional: Schema.optionalKey(Schema.Boolean)
+}) {
+	/** The classified protocol, or `None` for an empty specifier. */
+	get protocol() {
+		return this.specifier.length === 0 ? Option.none() : Option.some(DependencySpecifier.protocolOf(this.specifier));
+	}
+	/** Parse the specifier as a semver `Range`, `None` when it is not a range. */
+	get range() {
+		return DependencySpecifier.parseRange(this.specifier);
+	}
+	/** Whether the specifier points to a local path. */
+	get isLocal() {
+		return DependencySpecifier.isLocal(this.specifier);
+	}
+	/** Whether the specifier uses the `link:` protocol. */
+	get isLink() {
+		return DependencySpecifier.isLink(this.specifier);
+	}
+	/** Whether the specifier uses the `portal:` protocol. */
+	get isPortal() {
+		return DependencySpecifier.isPortal(this.specifier);
+	}
+	/** Whether the specifier uses the `catalog:` protocol. */
+	get isCatalog() {
+		return DependencySpecifier.isCatalog(this.specifier);
+	}
+	/** Whether the specifier uses the `workspace:` protocol. */
+	get isWorkspace() {
+		return DependencySpecifier.isWorkspace(this.specifier);
+	}
+	/** Whether the specifier is an unresolved `catalog:` or `workspace:` protocol. */
+	get isUnresolved() {
+		return this.isCatalog || this.isWorkspace;
+	}
+	/** Whether the specifier resolves to a git source. */
+	get isGit() {
+		return DependencySpecifier.isGit(this.specifier);
+	}
+	/** Whether the specifier is a parseable semver range. */
+	get isRange() {
+		return DependencySpecifier.isRange(this.specifier);
+	}
+	/** Whether the specifier is a dist-tag. */
+	get isTag() {
+		return DependencySpecifier.isTag(this.specifier);
+	}
+};
+/**
+* Type guard narrowing any dependency-like value to
+* {@link UnresolvedDependency}, preserving the concrete type.
+*
+* @public
+*/
+const isUnresolvedDependency = (dependency) => dependency.isUnresolved === true;
+
+//#endregion
+export { Dependency, isUnresolvedDependency };

package/DevEngines.js

@@ -0,0 +1,42 @@
+import { Schema } from "effect";
+
+//#region src/DevEngines.ts
+/**
+* A single `devEngines` constraint with a name and optional `version` / `onFail`.
+*
+* @public
+*/
+var DevEngine = class extends Schema.Class("DevEngine")({
+	/** The engine name (e.g. `node`, `pnpm`). */
+	name: Schema.String,
+	/** The optional version constraint. */
+	version: Schema.optionalKey(Schema.String),
+	/** The optional behavior when the constraint is unmet. */
+	onFail: Schema.optionalKey(Schema.Literals([
+		"warn",
+		"error",
+		"ignore"
+	]))
+}) {};
+/**
+* A `devEngines` constraint slot: a single {@link DevEngine} or an array of them.
+*
+* @public
+*/
+const DevEngineOrArray = Schema.Union([DevEngine, Schema.Array(DevEngine)]);
+/**
+* The `devEngines` field schema, modeling runtime and package-manager
+* constraints as optional {@link DevEngine} slots.
+*
+* @public
+*/
+const DevEnginesSchema = Schema.Struct({
+	packageManager: Schema.optionalKey(DevEngineOrArray),
+	runtime: Schema.optionalKey(DevEngineOrArray),
+	os: Schema.optionalKey(DevEngineOrArray),
+	cpu: Schema.optionalKey(DevEngineOrArray),
+	libc: Schema.optionalKey(DevEngineOrArray)
+});
+
+//#endregion
+export { DevEngine, DevEngineOrArray, DevEnginesSchema };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/License.js

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+import spdxParse from "spdx-expression-parse";
+
+//#region src/License.ts
+/**
+* Indicates that a string is not a valid SPDX license identifier or expression.
+*
+* Raised by {@link Package.setLicense} and the decode direction of
+* `SpdxLicense`. The offending string is preserved on `input`.
+*
+* @public
+*/
+var InvalidSpdxLicenseError = class extends Schema.TaggedErrorClass()("InvalidSpdxLicenseError", { 
+/** The raw input string that failed validation. */
+input: Schema.String }) {
+	get message() {
+		return `Invalid SPDX license "${this.input}": not a recognized identifier or expression`;
+	}
+};
+/**
+* Whether a string is a valid SPDX license identifier or expression, or one of
+* the npm special cases `UNLICENSED` / `SEE LICENSE IN <file>`.
+*
+* @public
+*/
+const isValidSpdx = (value) => {
+	if (value === "UNLICENSED") return true;
+	if (value.startsWith("SEE LICENSE IN ") && value.length > 15) return true;
+	try {
+		spdxParse(value);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* A valid SPDX license identifier, expression, `UNLICENSED`, or
+* `SEE LICENSE IN <file>`.
+*
+* @public
+*/
+const SpdxLicense = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => isValidSpdx(value) ? void 0 : "Expected a valid SPDX license expression")), Schema.brand("SpdxLicense"));
+
+//#endregion
+export { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx };

package/Package.js

@@ -0,0 +1,329 @@
+import { Dependency } from "./Dependency.js";
+import { DevEnginesSchema } from "./DevEngines.js";
+import { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx } from "./License.js";
+import { renderJson } from "./internal/format.js";
+import { PackageManager } from "./PackageManager.js";
+import { InvalidPackageNameError, PackageName } from "./PackageName.js";
+import { Person } from "./Person.js";
+import { CatalogResolver, WorkspaceResolver } from "@effected/npm";
+import { Effect, Function, HashMap, Option, Pipeable, Schema, SchemaTransformation } from "effect";
+import { SemVer } from "@effected/semver";
+
+//#region src/Package.ts
+const toHashMap = SchemaTransformation.transform({
+	decode: (record) => HashMap.fromIterable(Object.entries(record)),
+	encode: (map) => Object.fromEntries(HashMap.toEntries(map))
+});
+/**
+* A string→string map field decoding a plain JSON object to a `HashMap`,
+* defaulting to an empty map when the key is absent. Backs the four dependency
+* maps and `scripts`. Not meant to be referenced directly.
+*
+* @public
+*/
+const DependencyMapField = Schema.Record(Schema.String, Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed({})), Schema.decodeTo(Schema.HashMap(Schema.String, Schema.String), toHashMap));
+/**
+* A string→string map field decoding a plain JSON object to a `HashMap`,
+* with no default (an absent key stays absent). Backs `engines`. Not meant to
+* be referenced directly.
+*
+* @public
+*/
+const StringMapField = Schema.Record(Schema.String, Schema.String).pipe(Schema.decodeTo(Schema.HashMap(Schema.String, Schema.String), toHashMap));
+/**
+* The `bin` field: a single string path or a name→path map. Not meant to be
+* referenced directly.
+*
+* @public
+*/
+const BinField = Schema.Union([Schema.String, StringMapField]);
+/**
+* The `exports` field: a single string entry point or an open object of
+* conditional exports. Not meant to be referenced directly.
+*
+* @public
+*/
+const ExportsField = Schema.Union([Schema.String, Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* The `publishConfig` field: an open record preserving known npm keys
+* (`access`, `directory`, ...) plus extensions like `targets`. Not meant to be
+* referenced directly.
+*
+* @public
+*/
+const PublishConfigField = Schema.Record(Schema.String, Schema.Unknown);
+/**
+* The `peerDependenciesMeta` field: a map of package name to `{ optional? }`.
+* Not meant to be referenced directly.
+*
+* @public
+*/
+const PeerDependenciesMetaField = Schema.Record(Schema.String, Schema.Struct({ optional: Schema.optionalKey(Schema.Boolean) }));
+/**
+* The `repository` field: a shorthand string or an object (with `type` / `url` /
+* `directory` and any extensions preserved). Not meant to be referenced
+* directly.
+*
+* @public
+*/
+const RepositoryField = Schema.Union([Schema.String, Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* Indicates that a JSON value could not be decoded into a valid {@link Package}.
+*
+* Raised by {@link Package.decode}. The underlying `SchemaError` is preserved on
+* the structured `cause` field (never stringified), so callers keep the issue
+* tree for diagnostics.
+*
+* @public
+*/
+var PackageDecodeError = class extends Schema.TaggedErrorClass()("PackageDecodeError", { 
+/** The underlying `SchemaError`, preserved structurally rather than stringified. */
+cause: Schema.Defect() }) {
+	get message() {
+		return "Failed to decode package.json";
+	}
+};
+const resolveFormatOptions = (options) => ({
+	indent: options?.indent ?? 2,
+	sort: options?.sort ?? true,
+	stripEmpty: options?.stripEmpty ?? true,
+	newline: options?.newline ?? true
+});
+const RawJson = Schema.Record(Schema.String, Schema.Unknown);
+const makeWire = (Class) => {
+	const knownKeys = new Set(Object.keys(Class.fields).filter((k) => k !== "rest"));
+	return RawJson.pipe(Schema.decodeTo(Class, SchemaTransformation.transform({
+		decode: (raw) => {
+			const known = {};
+			const rest = {};
+			for (const [key, value] of Object.entries(raw)) if (knownKeys.has(key)) known[key] = value;
+			else rest[key] = value;
+			return {
+				...known,
+				rest
+			};
+		},
+		encode: (encoded) => {
+			const { rest, ...known } = encoded;
+			return {
+				...known,
+				...rest ?? {}
+			};
+		}
+	})));
+};
+const applyWorkspaceModifier = (specifier, version) => {
+	const modifier = specifier.slice(10);
+	if (modifier === "*" || modifier === "") return version;
+	if (modifier === "^") return `^${version}`;
+	if (modifier === "~") return `~${version}`;
+	return modifier;
+};
+const catalogName = (specifier) => {
+	const name = specifier.slice(8);
+	return name.length === 0 ? Option.none() : Option.some(name);
+};
+/**
+* A package.json document as a rich `Schema.Class`: typed known fields, a
+* `rest` catch-all preserving unknown top-level fields across a read/edit/write
+* cycle, computed getters, and immutable mutation statics.
+*
+* @example
+* ```ts
+* import { Package } from "@effected/package-json";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const pkg = yield* Package.decode({ name: "my-pkg", version: "1.0.0" });
+*   const next = yield* Package.setVersion(pkg, "1.1.0");
+*   console.log(next.toJsonString());
+* });
+* ```
+*
+* @public
+*/
+var Package = class Package extends Schema.Class("Package")({
+	name: PackageName,
+	version: SemVer.FromString,
+	description: Schema.optionalKey(Schema.String),
+	private: Schema.optionalKey(Schema.Boolean),
+	type: Schema.optionalKey(Schema.Literals(["module", "commonjs"])),
+	main: Schema.optionalKey(Schema.String),
+	license: Schema.optionalKey(SpdxLicense),
+	author: Schema.optionalKey(Person.FromValue),
+	contributors: Schema.optionalKey(Schema.Array(Person.FromValue)),
+	repository: Schema.optionalKey(RepositoryField),
+	dependencies: DependencyMapField,
+	devDependencies: DependencyMapField,
+	peerDependencies: DependencyMapField,
+	optionalDependencies: DependencyMapField,
+	peerDependenciesMeta: Schema.optionalKey(PeerDependenciesMetaField),
+	scripts: DependencyMapField,
+	bin: Schema.optionalKey(BinField),
+	engines: Schema.optionalKey(StringMapField),
+	exports: Schema.optionalKey(ExportsField),
+	publishConfig: Schema.optionalKey(PublishConfigField),
+	packageManager: Schema.optionalKey(PackageManager.FromString),
+	devEngines: Schema.optionalKey(DevEnginesSchema),
+	rest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown))
+}) {
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+	/**
+	* The default wire codec: an open JSON object ↔ a {@link Package} instance,
+	* partitioning unknown keys into `rest` and flattening them back on encode.
+	*/
+	static schema = makeWire(Package);
+	/**
+	* Build the wire codec for a `.extend()`ed subclass, so its custom fields
+	* decode as typed members and are excluded from `rest`.
+	*
+	* @param Class - the extended `Schema.Class`, carrying its own `fields`
+	* @returns a codec between an open JSON object and `Class` instances
+	*/
+	static wireFor(Class) {
+		return makeWire(Class);
+	}
+	/**
+	* Decode an unknown JSON value into a {@link Package}, normalizing any
+	* `SchemaError` to a typed {@link PackageDecodeError} at the boundary.
+	*
+	* @param input - the parsed package.json JSON value (e.g. from `JSON.parse`)
+	* @returns an Effect resolving to the decoded `Package`
+	* @throws (typed) `PackageDecodeError` when `input` does not satisfy the schema
+	*/
+	static decode = Effect.fn("Package.decode")(function* (input) {
+		return yield* Schema.decodeUnknownEffect(Package.schema)(input).pipe(Effect.catchTag("SchemaError", (cause) => new PackageDecodeError({ cause })));
+	});
+	/** Whether the package is marked private. */
+	get isPrivate() {
+		return this.private ?? false;
+	}
+	/** Whether the package name is scoped (`@scope/name`). */
+	get isScoped() {
+		return PackageName.isScoped(this.name);
+	}
+	/** Whether the package is ESM (`"type": "module"`). */
+	get isESM() {
+		return this.type === "module";
+	}
+	/** Whether any dependency map contains `name`. */
+	hasDependency(name) {
+		return HashMap.has(this.dependencies, name) || HashMap.has(this.devDependencies, name) || HashMap.has(this.peerDependencies, name) || HashMap.has(this.optionalDependencies, name);
+	}
+	/** The `dependencies` map as {@link Dependency} instances (`kind: "prod"`). */
+	getDependencies() {
+		return HashMap.map(this.dependencies, (specifier, name) => Dependency.make({
+			name,
+			specifier,
+			kind: "prod"
+		}));
+	}
+	/** The `devDependencies` map as {@link Dependency} instances (`kind: "dev"`). */
+	getDevDependencies() {
+		return HashMap.map(this.devDependencies, (specifier, name) => Dependency.make({
+			name,
+			specifier,
+			kind: "dev"
+		}));
+	}
+	/** The `peerDependencies` map as {@link Dependency} instances (`kind: "peer"`), carrying `isOptional` from `peerDependenciesMeta`. */
+	getPeerDependencies() {
+		const meta = this.peerDependenciesMeta;
+		return HashMap.map(this.peerDependencies, (specifier, name) => Dependency.make({
+			name,
+			specifier,
+			kind: "peer",
+			isOptional: meta?.[name]?.optional ?? false
+		}));
+	}
+	/** The `optionalDependencies` map as {@link Dependency} instances (`kind: "optional"`). */
+	getOptionalDependencies() {
+		return HashMap.map(this.optionalDependencies, (specifier, name) => Dependency.make({
+			name,
+			specifier,
+			kind: "optional"
+		}));
+	}
+	/** Return a new {@link Package} with the given fields replaced. */
+	copyWith(patch) {
+		return Package.make({
+			...this,
+			...patch
+		});
+	}
+	/** Set the version from a string. Fails with `InvalidVersionError`. Dual API. */
+	static setVersion = Function.dual(2, Effect.fn("Package.setVersion")(function* (pkg, version) {
+		const semver = yield* SemVer.parse(version);
+		return pkg.copyWith({ version: semver });
+	}));
+	/** Set the package name. Fails with `InvalidPackageNameError`. Dual API. */
+	static setName = Function.dual(2, Effect.fn("Package.setName")(function* (pkg, name) {
+		if (!PackageName.isValid(name)) return yield* new InvalidPackageNameError({ input: name });
+		return pkg.copyWith({ name });
+	}));
+	/** Set the license from an SPDX string. Fails with `InvalidSpdxLicenseError`. Dual API. */
+	static setLicense = Function.dual(2, Effect.fn("Package.setLicense")(function* (pkg, license) {
+		if (!isValidSpdx(license)) return yield* new InvalidSpdxLicenseError({ input: license });
+		return pkg.copyWith({ license });
+	}));
+	/** Add or replace a `dependencies` entry. Dual API. */
+	static addDependency = Function.dual(3, (pkg, name, specifier) => pkg.copyWith({ dependencies: HashMap.set(pkg.dependencies, name, specifier) }));
+	/** Remove a `dependencies` entry. Dual API. */
+	static removeDependency = Function.dual(2, (pkg, name) => pkg.copyWith({ dependencies: HashMap.remove(pkg.dependencies, name) }));
+	/** Add or replace a `devDependencies` entry. Dual API. */
+	static addDevDependency = Function.dual(3, (pkg, name, specifier) => pkg.copyWith({ devDependencies: HashMap.set(pkg.devDependencies, name, specifier) }));
+	/** Remove a `devDependencies` entry. Dual API. */
+	static removeDevDependency = Function.dual(2, (pkg, name) => pkg.copyWith({ devDependencies: HashMap.remove(pkg.devDependencies, name) }));
+	/** Add or replace a `peerDependencies` entry. Dual API. */
+	static addPeerDependency = Function.dual(3, (pkg, name, specifier) => pkg.copyWith({ peerDependencies: HashMap.set(pkg.peerDependencies, name, specifier) }));
+	/** Remove a `peerDependencies` entry. Dual API. */
+	static removePeerDependency = Function.dual(2, (pkg, name) => pkg.copyWith({ peerDependencies: HashMap.remove(pkg.peerDependencies, name) }));
+	/** Add or replace an `optionalDependencies` entry. Dual API. */
+	static addOptionalDependency = Function.dual(3, (pkg, name, specifier) => pkg.copyWith({ optionalDependencies: HashMap.set(pkg.optionalDependencies, name, specifier) }));
+	/** Remove an `optionalDependencies` entry. Dual API. */
+	static removeOptionalDependency = Function.dual(2, (pkg, name) => pkg.copyWith({ optionalDependencies: HashMap.remove(pkg.optionalDependencies, name) }));
+	/** Add or replace a `scripts` entry. Dual API. */
+	static setScript = Function.dual(3, (pkg, name, command) => pkg.copyWith({ scripts: HashMap.set(pkg.scripts, name, command) }));
+	/** Remove a `scripts` entry. Dual API. */
+	static removeScript = Function.dual(2, (pkg, name) => pkg.copyWith({ scripts: HashMap.remove(pkg.scripts, name) }));
+	/**
+	* Resolve `catalog:` and `workspace:` specifiers across all four dependency
+	* maps using the `CatalogResolver` and `WorkspaceResolver` from context.
+	* Specifiers the resolvers return `None` for are left unchanged. This is the
+	* explicit resolution step — `PackageJsonFile.write` never resolves.
+	*/
+	static resolve = Effect.fn("Package.resolve")(function* (pkg) {
+		const workspace = yield* WorkspaceResolver;
+		const catalog = yield* CatalogResolver;
+		const resolveMap = Effect.fn("Package.resolve.map")(function* (map) {
+			let next = map;
+			for (const [name, specifier] of HashMap.entries(map)) if (specifier.startsWith("workspace:")) {
+				const version = yield* workspace.versionOf(name);
+				if (Option.isSome(version)) next = HashMap.set(next, name, applyWorkspaceModifier(specifier, version.value));
+			} else if (specifier.startsWith("catalog:")) {
+				const range = yield* catalog.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)
+		});
+	});
+	/**
+	* Serialize to a formatted package.json string: encode through the wire
+	* codec (flattening `rest`), then apply the canonical key order, dependency
+	* sorting and empty-map stripping unless the options opt out. Pure.
+	*/
+	toJsonString(options) {
+		return renderJson(Schema.encodeUnknownSync(Package.schema)(this), resolveFormatOptions(options));
+	}
+};
+
+//#endregion
+export { BinField, DependencyMapField, ExportsField, Package, PackageDecodeError, PeerDependenciesMetaField, PublishConfigField, RepositoryField, StringMapField };

package/PackageJsonFile.js

@@ -0,0 +1,128 @@
+import { Package } from "./Package.js";
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+
+//#region src/PackageJsonFile.ts
+/**
+* Indicates that a package.json file could not be read from the filesystem
+* (a filesystem error other than not-found).
+*
+* @public
+*/
+var PackageJsonReadError = class extends Schema.TaggedErrorClass()("PackageJsonReadError", {
+	/** The path that could not be read. */
+	path: Schema.String,
+	/** The underlying failure, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to read package.json from "${this.path}"`;
+	}
+};
+/**
+* Indicates that no package.json file exists at the expected path. Carries its
+* own tag for `catchTag` routing.
+*
+* @public
+*/
+var PackageJsonNotFoundError = class extends Schema.TaggedErrorClass()("PackageJsonNotFoundError", { 
+/** The path where package.json was expected. */
+path: Schema.String }) {
+	get message() {
+		return `package.json not found at "${this.path}"`;
+	}
+};
+/**
+* Indicates that a package.json file's contents are not valid JSON.
+*
+* @public
+*/
+var PackageJsonParseError = class extends Schema.TaggedErrorClass()("PackageJsonParseError", {
+	/** The path whose contents failed to parse as JSON. */
+	path: Schema.String,
+	/** The underlying `SyntaxError`, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to parse package.json at "${this.path}"`;
+	}
+};
+/**
+* Indicates that a package.json file could not be written to the filesystem.
+* Narrowed to the filesystem-write failure only — never a resolution or encode
+* error.
+*
+* @public
+*/
+var PackageJsonWriteError = class extends Schema.TaggedErrorClass()("PackageJsonWriteError", {
+	/** The path that could not be written. */
+	path: Schema.String,
+	/** The underlying filesystem failure, preserved structurally. Narrowed to the write failure only. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to write package.json to "${this.path}"`;
+	}
+};
+/**
+* Reads and writes package.json over core `FileSystem` / `Path`. The layer
+* requires those services; provide `@effect/platform-node`'s `NodeFileSystem` /
+* `NodePath` (or a bun equivalent) at the application boundary.
+*
+* @example
+* ```ts
+* import { PackageJsonFile } from "@effected/package-json";
+* import { NodeFileSystem, NodePath } from "@effect/platform-node";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const files = yield* PackageJsonFile;
+*   const pkg = yield* files.read("./package.json");
+*   console.log(pkg.name);
+* }).pipe(Effect.provide(PackageJsonFile.layer), Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer));
+* ```
+*
+* @public
+*/
+var PackageJsonFile = class PackageJsonFile extends Context.Service()("@effected/package-json/PackageJsonFile") {
+	/** Build the service implementation from `FileSystem` / `Path` in context; use {@link PackageJsonFile.layer} to provide it. */
+	static make = Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		return {
+			read: Effect.fn("PackageJsonFile.read")(function* (target) {
+				const content = yield* fs.readFileString(target).pipe(Effect.mapError((cause) => cause.reason._tag === "NotFound" ? new PackageJsonNotFoundError({ path: target }) : new PackageJsonReadError({
+					path: target,
+					cause
+				})));
+				const json = yield* Effect.try({
+					try: () => JSON.parse(content),
+					catch: (cause) => new PackageJsonParseError({
+						path: target,
+						cause
+					})
+				});
+				return yield* Package.decode(json);
+			}),
+			write: Effect.fn("PackageJsonFile.write")(function* (target, pkg, options) {
+				const json = pkg.toJsonString(options);
+				const directory = path.dirname(target);
+				yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.mapError((cause) => new PackageJsonWriteError({
+					path: target,
+					cause
+				})));
+				yield* fs.writeFileString(target, json).pipe(Effect.mapError((cause) => new PackageJsonWriteError({
+					path: target,
+					cause
+				})));
+			})
+		};
+	});
+	/**
+	* The live layer. Requires core `FileSystem` / `Path`, provided by the
+	* consumer's platform implementation at the edge.
+	*/
+	static layer = Layer.effect(PackageJsonFile, PackageJsonFile.make);
+};
+
+//#endregion
+export { PackageJsonFile, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonWriteError };