@effected/package-json 0.3.0 → 0.4.0

package/PackageJsonFormat.js

@@ -0,0 +1,138 @@
+import { renderJson, resolveIndent, sortKeys } from "./internal/format.js";
+import { Result, Schema } from "effect";
+
+//#region src/PackageJsonFormat.ts
+/**
+* Indicates that a text input could not be treated as a package.json document:
+* either it is not valid JSON (`"invalid-json"`, carrying the underlying
+* `SyntaxError` on `cause`) or it parsed to something other than a JSON object
+* (`"not-an-object"` — an array, a scalar or `null`).
+*
+* Raised by {@link PackageJsonFormat.formatToString}. This is a *syntactic*
+* failure only; it says nothing about whether the document is a valid package
+* manifest, which the decode-free path deliberately does not check.
+*
+* @public
+*/
+var PackageJsonSyntaxError = class extends Schema.TaggedErrorClass()("PackageJsonSyntaxError", {
+	/** Which syntactic precondition failed. */
+	reason: Schema.Literals(["invalid-json", "not-an-object"]),
+	/** The underlying `SyntaxError` for `"invalid-json"`, preserved structurally. */
+	cause: Schema.optionalKey(Schema.Defect())
+}) {
+	get message() {
+		return this.reason === "invalid-json" ? "package.json text is not valid JSON" : "package.json text is not a JSON object";
+	}
+};
+const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Decode-free canonical sort and format statics. Not instantiable.
+*
+* @remarks
+* The guarantee both statics make is that they are **source-preserving**:
+* neither decodes into a `Package`, so neither can normalize a field encoding.
+* String-form `author` shorthand, unknown fields, unusual value shapes and
+* empty maps all survive untouched, because they are never looked at. Key
+* order, indentation and the trailing newline are the only things that change.
+*
+* That is what makes this usable as a lint-hook handler where the strict path
+* is not: any syntactically valid JSON object formats, including the
+* version-less workspace roots and `{"private": true}` manifests that
+* `Package.decode` rejects. Reach for `Package.decode` +
+* `Package.toJsonString` instead when the job needs the validated model and an
+* invalid manifest should fail loudly.
+*
+* @public
+*/
+var PackageJsonFormat = class {
+	constructor() {}
+	/**
+	* Order a package.json object's keys canonically **without decoding it into
+	* a `Package`**: known top-level keys in `sort-package-json`'s order, then
+	* unknown public keys alphabetically, then `_`-prefixed keys, with the
+	* dependency maps and `scripts` / `engines` / `bin` alphabetized.
+	*
+	* Value in, value out — for hosts that already hold parsed JSON and never
+	* want a string. {@link PackageJsonFormat.formatToString} is the same
+	* ordering for hosts holding file text. Pure and total.
+	*
+	* Returns a new object; nested values are shared by reference rather than
+	* cloned, except the maps whose own keys are reordered. A value that is not
+	* a JSON object (an array, a scalar, `null`) is returned unchanged rather
+	* than mangled, so a mistyped `Json` union cannot silently lose data.
+	*
+	* Reordering keys is the whole of it — **no key is ever added or removed**,
+	* which is what lets the return type be the input type `T` and makes this a
+	* drop-in. Use {@link PackageJsonFormat.formatToString} with `stripEmpty`
+	* when removing empty maps is wanted; it returns a string and so carries no
+	* such obligation.
+	*
+	* @param value - the parsed package.json object
+	* @returns a new object with canonically ordered keys
+	*
+	* @example
+	* ```ts
+	* import { PackageJsonFormat } from "@effected/package-json";
+	*
+	* const sorted = PackageJsonFormat.sortValue({ version: "1.0.0", name: "p" });
+	* // => { name: "p", version: "1.0.0" }
+	* ```
+	*/
+	static sortValue(value) {
+		if (!isJsonObject(value)) return value;
+		return sortKeys(value);
+	}
+	/**
+	* Sort and format package.json text **without decoding it into a
+	* `Package`**. Text in, text out — for hosts that hold file contents and
+	* cannot afford a decode. {@link PackageJsonFormat.sortValue} is the same
+	* ordering for hosts that already hold parsed JSON.
+	*
+	* Any syntactically valid JSON object formats, whatever it contains: a
+	* version-less root, `{"private": true}`, a malformed `packageManager`
+	* integrity. Nothing is decoded, so nothing is normalized — string-form
+	* `author` shorthand, unknown fields, unusual value shapes and empty maps
+	* all survive byte-for-byte. Only key order, indentation and the trailing
+	* newline change.
+	*
+	* Pure and synchronous: it returns a `Result` rather than an `Effect`, so
+	* synchronous hosts can call it directly. Lift it with `Effect.fromResult`.
+	*
+	* @param source - the package.json file contents
+	* @param options - formatting options; see {@link PackageFormatTextOptions}
+	* @returns the formatted text, or a {@link PackageJsonSyntaxError}
+	*
+	* @example
+	* ```ts
+	* import { PackageJsonFormat } from "@effected/package-json";
+	* import { Effect, Result } from "effect";
+	*
+	* const formatted = PackageJsonFormat.formatToString('{"private": true}');
+	* if (Result.isSuccess(formatted)) console.log(formatted.success);
+	*
+	* // In an Effect program:
+	* const program = Effect.fromResult(PackageJsonFormat.formatToString('{"private": true}'));
+	* ```
+	*/
+	static formatToString(source, options) {
+		let parsed;
+		try {
+			parsed = JSON.parse(source);
+		} catch (cause) {
+			return Result.fail(new PackageJsonSyntaxError({
+				reason: "invalid-json",
+				cause
+			}));
+		}
+		if (!isJsonObject(parsed)) return Result.fail(new PackageJsonSyntaxError({ reason: "not-an-object" }));
+		return Result.succeed(renderJson(parsed, {
+			indent: resolveIndent(options?.indent ?? "preserve", source),
+			sort: options?.sort ?? true,
+			stripEmpty: options?.stripEmpty ?? false,
+			newline: options?.newline ?? true
+		}));
+	}
+};
+
+//#endregion
+export { PackageJsonFormat, PackageJsonSyntaxError };

package/Person.js

@@ -1,4 +1,4 @@
-import { Schema, SchemaTransformation } from "effect";
+import { Effect, Option, Schema, SchemaTransformation } from "effect";
 
 //#region src/Person.ts
 const parsePersonString = (input) => {
@@ -14,8 +14,56 @@ const parsePersonString = (input) => {
 		...urlMatch !== null ? { url: urlMatch[1] } : {}
 	});
 };
+const serializePerson = (person) => {
+	let result = person.name;
+	if (person.email !== void 0) result += ` <${person.email}>`;
+	if (person.url !== void 0) result += ` (${person.url})`;
+	return result;
+};
+const wireForms = /* @__PURE__ */ new WeakMap();
+const rememberWire = (person, wire) => {
+	wireForms.set(person, wire);
+	return person;
+};
+const KNOWN_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"email",
+	"url"
+]);
+const sameRest = (a, b) => JSON.stringify(a ?? {}) === JSON.stringify(b ?? {});
+const isFaithful = (wire, person) => {
+	if (typeof wire === "string") {
+		const parsed = parsePersonString(wire);
+		return parsed.name === person.name && parsed.email === person.email && parsed.url === person.url;
+	}
+	const rest = restOf(wire);
+	return wire.name === person.name && wire.email === person.email && wire.url === person.url && sameRest(rest, person.rest);
+};
+const PersonFields = Schema.Struct({
+	name: Schema.String,
+	email: Schema.optionalKey(Schema.String),
+	url: Schema.optionalKey(Schema.String)
+});
+const decodePersonFields = Schema.decodeUnknownEffect(PersonFields);
+const restOf = (raw) => {
+	const rest = {};
+	for (const [key, value] of Object.entries(raw)) if (!KNOWN_KEYS.has(key)) rest[key] = value;
+	return rest;
+};
+const encodePersonObject = (person) => {
+	const wire = wireForms.get(person);
+	if (wire !== void 0 && typeof wire !== "string" && isFaithful(wire, person)) return wire;
+	const known = { name: person.name };
+	if (person.email !== void 0) known.email = person.email;
+	if (person.url !== void 0) known.url = person.url;
+	return {
+		...person.rest ?? {},
+		...known
+	};
+};
 /**
-* A structured person object with `name` and optional `email` / `url`.
+* A structured person object with `name`, optional `email` / `url`, and a
+* `rest` catch-all preserving any additional keys across a read/write cycle.
 *
 * @public
 */
@@ -25,26 +73,74 @@ var Person = class Person extends Schema.Class("Person")({
 	/** The optional email address. */
 	email: Schema.optionalKey(Schema.String),
 	/** The optional homepage URL. */
-	url: Schema.optionalKey(Schema.String)
+	url: Schema.optionalKey(Schema.String),
+	/** Any additional keys, preserved verbatim and flattened back on encode. */
+	rest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown))
 }) {
+	/**
+	* The object wire codec: an open JSON object ↔ a {@link Person}, partitioning
+	* unknown keys into `rest` and flattening them back on encode so the on-disk
+	* shape never carries a literal `rest` key.
+	*/
+	static schema = Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.decodeTo(Schema.instanceOf(Person), SchemaTransformation.transformOrFail({
+		decode: (raw) => decodePersonFields(raw).pipe(Effect.mapError((error) => error.issue), Effect.map((fields) => {
+			const rest = restOf(raw);
+			return rememberWire(Person.make({
+				...fields,
+				...Object.keys(rest).length > 0 ? { rest } : {}
+			}), raw);
+		})),
+		encode: (person) => Effect.succeed(encodePersonObject(person))
+	})));
 	/**
 	* Schema transformation between the `"Name <email> (url)"` shorthand string
-	* and a {@link Person}.
+	* and a {@link Person}. Decoding remembers the input text so that encoding
+	* reproduces it verbatim; see {@link Person.wireStringOf}.
 	*/
 	static FromString = Schema.String.pipe(Schema.decodeTo(Schema.instanceOf(Person), SchemaTransformation.transform({
-		decode: (input) => parsePersonString(input),
+		decode: (input) => rememberWire(parsePersonString(input), input),
 		encode: (person) => {
-			let result = person.name;
-			if (person.email !== void 0) result += ` <${person.email}>`;
-			if (person.url !== void 0) result += ` (${person.url})`;
-			return result;
+			const wire = wireForms.get(person);
+			return typeof wire === "string" && isFaithful(wire, person) ? wire : serializePerson(person);
 		}
 	})));
 	/**
 	* The `author` / `contributors` value: either the shorthand string or the
 	* structured object, always decoded to a {@link Person}.
+	*
+	* The wire form is preserved across a round trip — a person read from the
+	* shorthand string encodes back to that string, byte for byte, and one read
+	* from an object encodes back to an object with its unknown keys intact.
+	* Formatting a manifest therefore never rewrites one legal encoding into the
+	* other.
+	*
+	* Provenance belongs to the instance, so a person that is *rebuilt* (rather
+	* than carried through unchanged) has none and encodes in the canonical
+	* object form. Editing an unrelated field of the surrounding `Package`
+	* carries the same person instance through and preserves its encoding.
+	*/
+	static FromValue = Schema.Union([Person.schema, Schema.String]).pipe(Schema.decodeTo(Schema.instanceOf(Person), SchemaTransformation.transform({
+		decode: (input) => typeof input === "string" ? rememberWire(parsePersonString(input), input) : input,
+		encode: (person) => {
+			const wire = wireForms.get(person);
+			return typeof wire === "string" && isFaithful(wire, person) ? wire : person;
+		}
+	})));
+	/**
+	* The shorthand text this person was decoded from, when it was decoded from
+	* the string form and still matches its fields; `None` for a person built
+	* from an object or by hand.
+	*
+	* Exposed so callers can tell which encoding a manifest used without
+	* re-reading the file.
+	*
+	* @param person - the person to inspect
+	* @returns the original shorthand text, or `None`
 	*/
-	static FromValue = Schema.Union([Person, Person.FromString]);
+	static wireStringOf(person) {
+		const wire = wireForms.get(person);
+		return typeof wire === "string" && isFaithful(wire, person) ? Option.some(wire) : Option.none();
+	}
 };
 
 //#endregion

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/v/@effected%2Fpackage-json?label=npm&color=cb3837)](https://www.npmjs.com/package/@effected/package-json)
 [![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
-[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+[![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
 package.json parsing, editing, validation and file IO as Effect schemas. `Package` is a `Schema.Class` with the manifest's known fields typed — `name` is a branded npm name, `version` is a real `SemVer`, `packageManager` decodes into `{ name, version, integrity }` — and a `rest` catch-all that carries every unknown top-level key through a read, edit and write cycle without losing it. Editing is immutable and dual-signature, validation is a rule set you can replace, and `catalog:` / `workspace:` specifiers expand through the `@effected/npm` resolver contracts as an explicit step you opt into.
 

package/index.d.ts

@@ -1,6 +1,6 @@
 import { CatalogResolver, DependencyKind, DependencyProtocol, DependencyProtocol as DependencyProtocol$1, DependencySpecifier, DependencySpecifierBrand, InvalidDependencySpecifierError, WorkspaceResolver, isValidDependencySpecifier } from "@effected/npm";
 import { InvalidVersionError, Range, SemVer } from "@effected/semver";
-import { Brand, Context, Effect, FileSystem, HashMap, Layer, Option, Path, Schema } from "effect";
+import { Brand, Context, Effect, FileSystem, HashMap, Layer, Option, Path, Result, Schema } from "effect";
 //#region src/Dependency.d.ts
 declare const Dependency_base: Schema.Class<Dependency, Schema.Struct<{
   /** The package name. */
@@ -236,23 +236,60 @@ declare const Person_base: Schema.Class<Person, Schema.Struct<{
   readonly email: Schema.optionalKey<Schema.String>;
   /** The optional homepage URL. */
   readonly url: Schema.optionalKey<Schema.String>;
+  /** Any additional keys, preserved verbatim and flattened back on encode. */
+  readonly rest: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, {}>;
 /**
- * A structured person object with `name` and optional `email` / `url`.
+ * A structured person object with `name`, optional `email` / `url`, and a
+ * `rest` catch-all preserving any additional keys across a read/write cycle.
  *
  * @public
  */
 declare class Person extends Person_base {
+  /**
+   * The object wire codec: an open JSON object ↔ a {@link Person}, partitioning
+   * unknown keys into `rest` and flattening them back on encode so the on-disk
+   * shape never carries a literal `rest` key.
+   */
+  static readonly schema: Schema.Codec<Person, {
+    readonly [k: string]: unknown;
+  }>;
   /**
    * Schema transformation between the `"Name <email> (url)"` shorthand string
-   * and a {@link Person}.
+   * and a {@link Person}. Decoding remembers the input text so that encoding
+   * reproduces it verbatim; see {@link Person.wireStringOf}.
    */
   static readonly FromString: Schema.Codec<Person, string>;
   /**
    * The `author` / `contributors` value: either the shorthand string or the
    * structured object, always decoded to a {@link Person}.
+   *
+   * The wire form is preserved across a round trip — a person read from the
+   * shorthand string encodes back to that string, byte for byte, and one read
+   * from an object encodes back to an object with its unknown keys intact.
+   * Formatting a manifest therefore never rewrites one legal encoding into the
+   * other.
+   *
+   * Provenance belongs to the instance, so a person that is *rebuilt* (rather
+   * than carried through unchanged) has none and encodes in the canonical
+   * object form. Editing an unrelated field of the surrounding `Package`
+   * carries the same person instance through and preserves its encoding.
+   */
+  static readonly FromValue: Schema.Codec<Person, string | {
+    readonly [k: string]: unknown;
+  }>;
+  /**
+   * The shorthand text this person was decoded from, when it was decoded from
+   * the string form and still matches its fields; `None` for a person built
+   * from an object or by hand.
+   *
+   * Exposed so callers can tell which encoding a manifest used without
+   * re-reading the file.
+   *
+   * @param person - the person to inspect
+   * @returns the original shorthand text, or `None`
    */
-  static readonly FromValue: Schema.Union<[typeof Person, Schema.Codec<Person, string>]>;
+  static wireStringOf(person: Person): Option.Option<string>;
 }
 //#endregion
 //#region src/Package.d.ts
@@ -379,8 +416,12 @@ declare const Package_base: Schema.Class<Package, Schema.Struct<{
   readonly type: Schema.optionalKey<Schema.Literals<readonly ["module", "commonjs"]>>;
   readonly main: Schema.optionalKey<Schema.String>;
   readonly license: Schema.optionalKey<Schema.brand<Schema.String, "SpdxLicense">>;
-  readonly author: Schema.optionalKey<Schema.Union<[typeof Person, Schema.Codec<Person, string, never, never>]>>;
-  readonly contributors: Schema.optionalKey<Schema.$Array<Schema.Union<[typeof Person, Schema.Codec<Person, string, never, never>]>>>;
+  readonly author: Schema.optionalKey<Schema.Codec<Person, string | {
+    readonly [k: string]: unknown;
+  }, never, never>>;
+  readonly contributors: Schema.optionalKey<Schema.$Array<Schema.Codec<Person, string | {
+    readonly [k: string]: unknown;
+  }, never, never>>>;
   readonly repository: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>>;
   readonly dependencies: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
   readonly devDependencies: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
@@ -678,6 +719,148 @@ declare class PackageJsonFile extends PackageJsonFile_base {
   static readonly layer: Layer.Layer<PackageJsonFile, never, FileSystem.FileSystem | Path.Path>;
 }
 //#endregion
+//#region src/PackageJsonFormat.d.ts
+declare const PackageJsonSyntaxError_base: Schema.Class<PackageJsonSyntaxError, Schema.TaggedStruct<"PackageJsonSyntaxError", {
+  /** Which syntactic precondition failed. */
+  readonly reason: Schema.Literals<readonly ["invalid-json", "not-an-object"]>;
+  /** The underlying `SyntaxError` for `"invalid-json"`, preserved structurally. */
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a text input could not be treated as a package.json document:
+ * either it is not valid JSON (`"invalid-json"`, carrying the underlying
+ * `SyntaxError` on `cause`) or it parsed to something other than a JSON object
+ * (`"not-an-object"` — an array, a scalar or `null`).
+ *
+ * Raised by {@link PackageJsonFormat.formatToString}. This is a *syntactic*
+ * failure only; it says nothing about whether the document is a valid package
+ * manifest, which the decode-free path deliberately does not check.
+ *
+ * @public
+ */
+declare class PackageJsonSyntaxError extends PackageJsonSyntaxError_base {
+  get message(): string;
+}
+/**
+ * Options for {@link PackageJsonFormat.formatToString}.
+ *
+ * Deliberately not `PackageFormatOptions`: there is no `sourceText` member,
+ * because the text being formatted *is* the source text, and the defaults for
+ * `indent` and `stripEmpty` differ — see each member.
+ *
+ * @public
+ */
+interface PackageFormatTextOptions {
+  /**
+   * Indentation: a spaces count, `"tab"`, or `"preserve"`. Defaults to
+   * `"preserve"` — unlike `Package.toJsonString`, this path always has the
+   * original text in hand, and reformatting a file in place should not
+   * silently restyle its indentation.
+   */
+  readonly indent?: number | "tab" | "preserve";
+  /** Order top-level keys canonically and alphabetize dependency maps (default `true`). */
+  readonly sort?: boolean;
+  /**
+   * Strip dependency-map keys whose value is an empty object (default
+   * `false`). The strict path defaults this on because the model materializes
+   * absent maps as empty ones; here an empty map is a key the author actually
+   * wrote, and removing it would be a silent edit rather than a format.
+   */
+  readonly stripEmpty?: boolean;
+  /** Append a trailing newline (default `true`). */
+  readonly newline?: boolean;
+}
+/**
+ * Decode-free canonical sort and format statics. Not instantiable.
+ *
+ * @remarks
+ * The guarantee both statics make is that they are **source-preserving**:
+ * neither decodes into a `Package`, so neither can normalize a field encoding.
+ * String-form `author` shorthand, unknown fields, unusual value shapes and
+ * empty maps all survive untouched, because they are never looked at. Key
+ * order, indentation and the trailing newline are the only things that change.
+ *
+ * That is what makes this usable as a lint-hook handler where the strict path
+ * is not: any syntactically valid JSON object formats, including the
+ * version-less workspace roots and `{"private": true}` manifests that
+ * `Package.decode` rejects. Reach for `Package.decode` +
+ * `Package.toJsonString` instead when the job needs the validated model and an
+ * invalid manifest should fail loudly.
+ *
+ * @public
+ */
+declare class PackageJsonFormat {
+  private constructor();
+  /**
+   * Order a package.json object's keys canonically **without decoding it into
+   * a `Package`**: known top-level keys in `sort-package-json`'s order, then
+   * unknown public keys alphabetically, then `_`-prefixed keys, with the
+   * dependency maps and `scripts` / `engines` / `bin` alphabetized.
+   *
+   * Value in, value out — for hosts that already hold parsed JSON and never
+   * want a string. {@link PackageJsonFormat.formatToString} is the same
+   * ordering for hosts holding file text. Pure and total.
+   *
+   * Returns a new object; nested values are shared by reference rather than
+   * cloned, except the maps whose own keys are reordered. A value that is not
+   * a JSON object (an array, a scalar, `null`) is returned unchanged rather
+   * than mangled, so a mistyped `Json` union cannot silently lose data.
+   *
+   * Reordering keys is the whole of it — **no key is ever added or removed**,
+   * which is what lets the return type be the input type `T` and makes this a
+   * drop-in. Use {@link PackageJsonFormat.formatToString} with `stripEmpty`
+   * when removing empty maps is wanted; it returns a string and so carries no
+   * such obligation.
+   *
+   * @param value - the parsed package.json object
+   * @returns a new object with canonically ordered keys
+   *
+   * @example
+   * ```ts
+   * import { PackageJsonFormat } from "@effected/package-json";
+   *
+   * const sorted = PackageJsonFormat.sortValue({ version: "1.0.0", name: "p" });
+   * // => { name: "p", version: "1.0.0" }
+   * ```
+   */
+  static sortValue<T extends {
+    readonly [k: string]: unknown;
+  }>(value: T): T;
+  /**
+   * Sort and format package.json text **without decoding it into a
+   * `Package`**. Text in, text out — for hosts that hold file contents and
+   * cannot afford a decode. {@link PackageJsonFormat.sortValue} is the same
+   * ordering for hosts that already hold parsed JSON.
+   *
+   * Any syntactically valid JSON object formats, whatever it contains: a
+   * version-less root, `{"private": true}`, a malformed `packageManager`
+   * integrity. Nothing is decoded, so nothing is normalized — string-form
+   * `author` shorthand, unknown fields, unusual value shapes and empty maps
+   * all survive byte-for-byte. Only key order, indentation and the trailing
+   * newline change.
+   *
+   * Pure and synchronous: it returns a `Result` rather than an `Effect`, so
+   * synchronous hosts can call it directly. Lift it with `Effect.fromResult`.
+   *
+   * @param source - the package.json file contents
+   * @param options - formatting options; see {@link PackageFormatTextOptions}
+   * @returns the formatted text, or a {@link PackageJsonSyntaxError}
+   *
+   * @example
+   * ```ts
+   * import { PackageJsonFormat } from "@effected/package-json";
+   * import { Effect, Result } from "effect";
+   *
+   * const formatted = PackageJsonFormat.formatToString('{"private": true}');
+   * if (Result.isSuccess(formatted)) console.log(formatted.success);
+   *
+   * // In an Effect program:
+   * const program = Effect.fromResult(PackageJsonFormat.formatToString('{"private": true}'));
+   * ```
+   */
+  static formatToString(source: string, options?: PackageFormatTextOptions): Result.Result<string, PackageJsonSyntaxError>;
+}
+//#endregion
 //#region src/PackageValidator.d.ts
 /**
  * A single validation-rule failure.
@@ -777,5 +960,5 @@ declare class PackageValidator extends PackageValidator_base {
   }): Layer.Layer<PackageValidator>;
 }
 //#endregion
-export { BinField, Dependency, type DependencyKind, DependencyMapField, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, DevEngine, DevEngineOrArray, type DevEngines, DevEnginesSchema, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, Package, PackageDecodeError, type PackageFormatOptions, type PackageIndent, PackageJsonFile, type PackageJsonFileShape, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonWriteError, PackageManager, PackageName, type PackagePatch, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, RepositoryField, type RuleFailure, ScopedPackageName, SpdxLicense, StringMapField, type UnresolvedDependency, UnscopedPackageName, type ValidationRule, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule };
+export { BinField, Dependency, type DependencyKind, DependencyMapField, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, DevEngine, DevEngineOrArray, type DevEngines, DevEnginesSchema, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, Package, PackageDecodeError, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, PackageJsonFile, type PackageJsonFileShape, PackageJsonFormat, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageName, type PackagePatch, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, RepositoryField, type RuleFailure, ScopedPackageName, SpdxLicense, StringMapField, type UnresolvedDependency, UnscopedPackageName, type ValidationRule, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -6,7 +6,8 @@ import { InvalidPackageNameError, PackageName, ScopedPackageName, UnscopedPackag
 import { Person } from "./Person.js";
 import { BinField, DependencyMapField, ExportsField, Package, PackageDecodeError, PeerDependenciesMetaField, PublishConfigField, RepositoryField, StringMapField } from "./Package.js";
 import { PackageJsonFile, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonWriteError } from "./PackageJsonFile.js";
+import { PackageJsonFormat, PackageJsonSyntaxError } from "./PackageJsonFormat.js";
 import { PackageValidationError, PackageValidator, defaultRules, noLocalDepsRule, noUnresolvedDepsRule } from "./PackageValidator.js";
 import { DependencySpecifier, InvalidDependencySpecifierError, isValidDependencySpecifier } from "@effected/npm";
 
-export { BinField, Dependency, DependencyMapField, DependencySpecifier, DevEngine, DevEngineOrArray, DevEnginesSchema, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, Package, PackageDecodeError, PackageJsonFile, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonWriteError, PackageManager, PackageName, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, RepositoryField, ScopedPackageName, SpdxLicense, StringMapField, UnscopedPackageName, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule };
+export { BinField, Dependency, DependencyMapField, DependencySpecifier, DevEngine, DevEngineOrArray, DevEnginesSchema, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, Package, PackageDecodeError, PackageJsonFile, PackageJsonFormat, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageName, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, RepositoryField, ScopedPackageName, SpdxLicense, StringMapField, UnscopedPackageName, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/package-json",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"private": false,
 	"description": "package.json parsing, editing, validation and file IO as Effect schemas.",
 	"keywords": [
@@ -32,17 +32,18 @@
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
+			"import": "./index.js",
+			"default": "./index.js"
 		},
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/npm": "0.2.0",
-		"@effected/semver": "0.1.0",
+		"@effected/npm": "0.2.2",
+		"@effected/semver": "0.2.0",
 		"spdx-expression-parse": "^4.0.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-beta.98"
+		"effect": "4.0.0-beta.99"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.10"
+      "packageVersion": "7.58.11"
     }
   ]
 }