@effected/package-json 0.1.0

package/index.d.ts

@@ -0,0 +1,747 @@
+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";
+//#region src/Dependency.d.ts
+declare const Dependency_base: Schema.Class<Dependency, Schema.Struct<{
+  /** The package name. */
+  readonly name: Schema.String;
+  /** The raw version specifier. */
+  readonly specifier: Schema.String;
+  /** Which dependency map this entry came from. */
+  readonly kind: Schema.Literals<readonly ["prod", "dev", "peer", "optional"]>;
+  /** For `peer` dependencies, whether the peer is optional (from `peerDependenciesMeta`). */
+  readonly isOptional: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+/**
+ * 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
+ */
+declare class Dependency extends Dependency_base {
+  /** The classified protocol, or `None` for an empty specifier. */
+  get protocol(): Option.Option<DependencyProtocol$1>;
+  /** Parse the specifier as a semver `Range`, `None` when it is not a range. */
+  get range(): Option.Option<Range>;
+  /** Whether the specifier points to a local path. */
+  get isLocal(): boolean;
+  /** Whether the specifier uses the `link:` protocol. */
+  get isLink(): boolean;
+  /** Whether the specifier uses the `portal:` protocol. */
+  get isPortal(): boolean;
+  /** Whether the specifier uses the `catalog:` protocol. */
+  get isCatalog(): boolean;
+  /** Whether the specifier uses the `workspace:` protocol. */
+  get isWorkspace(): boolean;
+  /** Whether the specifier is an unresolved `catalog:` or `workspace:` protocol. */
+  get isUnresolved(): boolean;
+  /** Whether the specifier resolves to a git source. */
+  get isGit(): boolean;
+  /** Whether the specifier is a parseable semver range. */
+  get isRange(): boolean;
+  /** Whether the specifier is a dist-tag. */
+  get isTag(): boolean;
+}
+/**
+ * A {@link Dependency} whose specifier is an unresolved `catalog:` or
+ * `workspace:` protocol.
+ *
+ * @public
+ */
+type UnresolvedDependency = Dependency & {
+  readonly isUnresolved: true;
+};
+/**
+ * Type guard narrowing any dependency-like value to
+ * {@link UnresolvedDependency}, preserving the concrete type.
+ *
+ * @public
+ */
+declare const isUnresolvedDependency: <T extends {
+  readonly isUnresolved: boolean;
+}>(dependency: T) => dependency is T & {
+  readonly isUnresolved: true;
+};
+//#endregion
+//#region src/DevEngines.d.ts
+declare const DevEngine_base: Schema.Class<DevEngine, Schema.Struct<{
+  /** The engine name (e.g. `node`, `pnpm`). */
+  readonly name: Schema.String;
+  /** The optional version constraint. */
+  readonly version: Schema.optionalKey<Schema.String>;
+  /** The optional behavior when the constraint is unmet. */
+  readonly onFail: Schema.optionalKey<Schema.Literals<readonly ["warn", "error", "ignore"]>>;
+}>, {}>;
+/**
+ * A single `devEngines` constraint with a name and optional `version` / `onFail`.
+ *
+ * @public
+ */
+declare class DevEngine extends DevEngine_base {}
+/**
+ * A `devEngines` constraint slot: a single {@link DevEngine} or an array of them.
+ *
+ * @public
+ */
+declare const DevEngineOrArray: Schema.Union<[typeof DevEngine, Schema.$Array<typeof DevEngine>]>;
+/**
+ * The `devEngines` field schema, modeling runtime and package-manager
+ * constraints as optional {@link DevEngine} slots.
+ *
+ * @public
+ */
+declare const DevEnginesSchema: Schema.Struct<{
+  readonly packageManager: Schema.optionalKey<typeof DevEngineOrArray>;
+  readonly runtime: Schema.optionalKey<typeof DevEngineOrArray>;
+  readonly os: Schema.optionalKey<typeof DevEngineOrArray>;
+  readonly cpu: Schema.optionalKey<typeof DevEngineOrArray>;
+  readonly libc: Schema.optionalKey<typeof DevEngineOrArray>;
+}>;
+/**
+ * The decoded `devEngines` field type.
+ *
+ * @public
+ */
+type DevEngines = typeof DevEnginesSchema.Type;
+//#endregion
+//#region src/License.d.ts
+declare const InvalidSpdxLicenseError_base: Schema.Class<InvalidSpdxLicenseError, Schema.TaggedStruct<"InvalidSpdxLicenseError", {
+  /** The raw input string that failed validation. */
+  readonly input: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseError_base {
+  get message(): string;
+}
+/**
+ * Whether a string is a valid SPDX license identifier or expression, or one of
+ * the npm special cases `UNLICENSED` / `SEE LICENSE IN <file>`.
+ *
+ * @public
+ */
+declare const isValidSpdx: (value: string) => boolean;
+/**
+ * A valid SPDX license identifier, expression, `UNLICENSED`, or
+ * `SEE LICENSE IN <file>`.
+ *
+ * @public
+ */
+declare const SpdxLicense: Schema.brand<Schema.String, "SpdxLicense">;
+/**
+ * A branded SPDX license string.
+ *
+ * @public
+ */
+type SpdxLicense = string & Brand.Brand<"SpdxLicense">;
+//#endregion
+//#region src/PackageManager.d.ts
+declare const PackageManager_base: Schema.Class<PackageManager, Schema.Struct<{
+  /** The package-manager name (e.g. `pnpm`). */
+  readonly name: Schema.String;
+  /** The version (e.g. `10.33.0`). */
+  readonly version: Schema.String;
+  /** The optional integrity hash (e.g. `sha512.abc`), an `@effected/npm` `IntegrityHash` restricted to the corepack `<algo>.<hex>` form. */
+  readonly integrity: Schema.Option<Schema.brand<Schema.String, "IntegrityHash">>;
+}>, {}>;
+/**
+ * A structured `packageManager` value with `name`, `version` and an optional
+ * `integrity` hash.
+ *
+ * @public
+ */
+declare class PackageManager extends PackageManager_base {
+  /**
+   * Schema transformation between the `"name@version+integrity"` string and a
+   * {@link PackageManager}.
+   */
+  static readonly FromString: Schema.Codec<PackageManager, string>;
+  /** Whether an integrity hash is present. */
+  get hasIntegrity(): boolean;
+}
+//#endregion
+//#region src/PackageName.d.ts
+declare const InvalidPackageNameError_base: Schema.Class<InvalidPackageNameError, Schema.TaggedStruct<"InvalidPackageNameError", {
+  /** The raw input string that failed validation. */
+  readonly input: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a string could not be used as a valid npm package name.
+ *
+ * Raised by {@link Package.setName} and the decode direction of
+ * `PackageName`. The offending string is preserved on `input`.
+ *
+ * @public
+ */
+declare class InvalidPackageNameError extends InvalidPackageNameError_base {
+  get message(): string;
+}
+/**
+ * A valid npm scoped package name (`@scope/name`).
+ *
+ * @public
+ */
+declare const ScopedPackageName: Schema.brand<Schema.String, "ScopedPackageName">;
+/**
+ * A valid npm scoped package name.
+ *
+ * @public
+ */
+type ScopedPackageName = string & Brand.Brand<"ScopedPackageName">;
+/**
+ * A valid npm unscoped package name (no `@scope/` prefix).
+ *
+ * @public
+ */
+declare const UnscopedPackageName: Schema.brand<Schema.String, "UnscopedPackageName">;
+/**
+ * A valid npm unscoped package name.
+ *
+ * @public
+ */
+type UnscopedPackageName = string & Brand.Brand<"UnscopedPackageName">;
+/**
+ * A valid npm package name, scoped or unscoped.
+ *
+ * @public
+ */
+type PackageName = ScopedPackageName | UnscopedPackageName;
+/**
+ * The union of `ScopedPackageName` and `UnscopedPackageName`,
+ * carrying the classification statics (`PackageName.isValid` and friends)
+ * that absorb the v3 floating `PackageNameUtil` object. Use it as the schema
+ * for a package-name field and reach for the statics to inspect a raw string.
+ *
+ * @public
+ */
+declare const PackageName: Schema.Union<readonly [Schema.brand<Schema.String, "ScopedPackageName">, Schema.brand<Schema.String, "UnscopedPackageName">]> & {
+  isValid: (name: string) => boolean;
+  scope: (name: string) => Option.Option<string>;
+  unscoped: (name: string) => string;
+  isScoped: (name: string) => boolean;
+};
+//#endregion
+//#region src/Person.d.ts
+declare const Person_base: Schema.Class<Person, Schema.Struct<{
+  /** The person's name. */
+  readonly name: Schema.String;
+  /** The optional email address. */
+  readonly email: Schema.optionalKey<Schema.String>;
+  /** The optional homepage URL. */
+  readonly url: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/**
+ * A structured person object with `name` and optional `email` / `url`.
+ *
+ * @public
+ */
+declare class Person extends Person_base {
+  /**
+   * Schema transformation between the `"Name <email> (url)"` shorthand string
+   * and a {@link Person}.
+   */
+  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}.
+   */
+  static readonly FromValue: Schema.Union<[typeof Person, Schema.Codec<Person, string>]>;
+}
+//#endregion
+//#region src/Package.d.ts
+/**
+ * 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
+ */
+declare const DependencyMapField: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
+/**
+ * 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
+ */
+declare const StringMapField: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.String>, never, never>;
+/**
+ * The `bin` field: a single string path or a name→path map. Not meant to be
+ * referenced directly.
+ *
+ * @public
+ */
+declare const BinField: Schema.Union<readonly [Schema.String, Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.String>, never, never>]>;
+/**
+ * The `exports` field: a single string entry point or an open object of
+ * conditional exports. Not meant to be referenced directly.
+ *
+ * @public
+ */
+declare const ExportsField: Schema.Union<readonly [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
+ */
+declare 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
+ */
+declare const PeerDependenciesMetaField: Schema.$Record<Schema.String, Schema.Struct<{
+  readonly 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
+ */
+declare const RepositoryField: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>;
+declare const PackageDecodeError_base: Schema.Class<PackageDecodeError, Schema.TaggedStruct<"PackageDecodeError", {
+  /** The underlying `SchemaError`, preserved structurally rather than stringified. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+declare class PackageDecodeError extends PackageDecodeError_base {
+  get message(): string;
+}
+/**
+ * Options for {@link Package.toJsonString} and `PackageJsonFile.write`.
+ *
+ * @public
+ */
+interface PackageFormatOptions {
+  /** Indentation width in spaces (default `2`). */
+  readonly indent?: number;
+  /** Order top-level keys canonically and alphabetize dependency maps (default `true`). */
+  readonly sort?: boolean;
+  /** Strip empty dependency-map keys (default `true`). */
+  readonly stripEmpty?: boolean;
+  /** Append a trailing newline (default `true`). */
+  readonly newline?: boolean;
+}
+/**
+ * A patch over {@link Package}'s modeled fields — every field optional,
+ * derived from the schema so it never drifts from the model.
+ *
+ * @public
+ */
+type PackagePatch = Partial<{ readonly [K in keyof (typeof Package)["fields"]]: (typeof Package)["fields"][K]["Type"]; }>;
+declare const Package_base: Schema.Class<Package, Schema.Struct<{
+  readonly name: Schema.Union<readonly [Schema.brand<Schema.String, "ScopedPackageName">, Schema.brand<Schema.String, "UnscopedPackageName">]> & {
+    isValid: (name: string) => boolean;
+    scope: (name: string) => Option.Option<string>;
+    unscoped: (name: string) => string;
+    isScoped: (name: string) => boolean;
+  };
+  readonly version: Schema.Codec<SemVer, string, never, never>;
+  readonly description: Schema.optionalKey<Schema.String>;
+  readonly private: Schema.optionalKey<Schema.Boolean>;
+  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 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>;
+  readonly peerDependencies: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
+  readonly optionalDependencies: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
+  readonly peerDependenciesMeta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+    readonly optional: Schema.optionalKey<Schema.Boolean>;
+  }>>>;
+  readonly scripts: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
+  readonly bin: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.String>, never, never>]>>;
+  readonly engines: Schema.optionalKey<Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.String>, never, never>>;
+  readonly exports: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>>;
+  readonly publishConfig: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly packageManager: Schema.optionalKey<Schema.Codec<PackageManager, string, never, never>>;
+  readonly devEngines: Schema.optionalKey<Schema.Struct<{
+    readonly packageManager: Schema.optionalKey<typeof DevEngineOrArray>;
+    readonly runtime: Schema.optionalKey<typeof DevEngineOrArray>;
+    readonly os: Schema.optionalKey<typeof DevEngineOrArray>;
+    readonly cpu: Schema.optionalKey<typeof DevEngineOrArray>;
+    readonly libc: Schema.optionalKey<typeof DevEngineOrArray>;
+  }>>;
+  readonly rest: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+/**
+ * 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
+ */
+declare class Package extends Package_base {
+  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;
+  /**
+   * The default wire codec: an open JSON object ↔ a {@link Package} instance,
+   * partitioning unknown keys into `rest` and flattening them back on encode.
+   */
+  static readonly schema: Schema.Codec<Package, {
+    readonly [k: string]: unknown;
+  }>;
+  /**
+   * 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<Self extends Package>(Class: Schema.Codec<Self, any, any, any> & {
+    readonly fields: Record<string, unknown>;
+  }): Schema.Codec<Self, {
+    readonly [k: string]: unknown;
+  }>;
+  /**
+   * 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 readonly decode: (input: unknown) => Effect.Effect<Package, PackageDecodeError, never>;
+  /** Whether the package is marked private. */
+  get isPrivate(): boolean;
+  /** Whether the package name is scoped (`@scope/name`). */
+  get isScoped(): boolean;
+  /** Whether the package is ESM (`"type": "module"`). */
+  get isESM(): boolean;
+  /** Whether any dependency map contains `name`. */
+  hasDependency(name: string): boolean;
+  /** The `dependencies` map as {@link Dependency} instances (`kind: "prod"`). */
+  getDependencies(): HashMap.HashMap<string, Dependency>;
+  /** The `devDependencies` map as {@link Dependency} instances (`kind: "dev"`). */
+  getDevDependencies(): HashMap.HashMap<string, Dependency>;
+  /** The `peerDependencies` map as {@link Dependency} instances (`kind: "peer"`), carrying `isOptional` from `peerDependenciesMeta`. */
+  getPeerDependencies(): HashMap.HashMap<string, Dependency>;
+  /** The `optionalDependencies` map as {@link Dependency} instances (`kind: "optional"`). */
+  getOptionalDependencies(): HashMap.HashMap<string, Dependency>;
+  /** Return a new {@link Package} with the given fields replaced. */
+  copyWith(patch: PackagePatch): Package;
+  /** Set the version from a string. Fails with `InvalidVersionError`. Dual API. */
+  static readonly setVersion: {
+    (version: string): (pkg: Package) => Effect.Effect<Package, InvalidVersionError>;
+    (pkg: Package, version: string): Effect.Effect<Package, InvalidVersionError>;
+  };
+  /** Set the package name. Fails with `InvalidPackageNameError`. Dual API. */
+  static readonly setName: {
+    (name: string): (pkg: Package) => Effect.Effect<Package, InvalidPackageNameError>;
+    (pkg: Package, name: string): Effect.Effect<Package, InvalidPackageNameError>;
+  };
+  /** Set the license from an SPDX string. Fails with `InvalidSpdxLicenseError`. Dual API. */
+  static readonly setLicense: {
+    (license: string): (pkg: Package) => Effect.Effect<Package, InvalidSpdxLicenseError>;
+    (pkg: Package, license: string): Effect.Effect<Package, InvalidSpdxLicenseError>;
+  };
+  /** Add or replace a `dependencies` entry. Dual API. */
+  static readonly addDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  /** Remove a `dependencies` entry. Dual API. */
+  static readonly removeDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  /** Add or replace a `devDependencies` entry. Dual API. */
+  static readonly addDevDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  /** Remove a `devDependencies` entry. Dual API. */
+  static readonly removeDevDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  /** Add or replace a `peerDependencies` entry. Dual API. */
+  static readonly addPeerDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  /** Remove a `peerDependencies` entry. Dual API. */
+  static readonly removePeerDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  /** Add or replace an `optionalDependencies` entry. Dual API. */
+  static readonly addOptionalDependency: {
+    (name: string, specifier: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, specifier: string): Package;
+  };
+  /** Remove an `optionalDependencies` entry. Dual API. */
+  static readonly removeOptionalDependency: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  /** Add or replace a `scripts` entry. Dual API. */
+  static readonly setScript: {
+    (name: string, command: string): (pkg: Package) => Package;
+    (pkg: Package, name: string, command: string): Package;
+  };
+  /** Remove a `scripts` entry. Dual API. */
+  static readonly removeScript: {
+    (name: string): (pkg: Package) => Package;
+    (pkg: Package, name: string): Package;
+  };
+  /**
+   * 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 readonly resolve: (pkg: Package) => Effect.Effect<Package, import("@effected/npm").DependencyResolutionError, CatalogResolver | WorkspaceResolver>;
+  /**
+   * 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?: PackageFormatOptions): string;
+}
+//#endregion
+//#region src/PackageJsonFile.d.ts
+declare const PackageJsonReadError_base: Schema.Class<PackageJsonReadError, Schema.TaggedStruct<"PackageJsonReadError", {
+  /** The path that could not be read. */
+  readonly path: Schema.String;
+  /** The underlying failure, preserved structurally. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a package.json file could not be read from the filesystem
+ * (a filesystem error other than not-found).
+ *
+ * @public
+ */
+declare class PackageJsonReadError extends PackageJsonReadError_base {
+  get message(): string;
+}
+declare const PackageJsonNotFoundError_base: Schema.Class<PackageJsonNotFoundError, Schema.TaggedStruct<"PackageJsonNotFoundError", {
+  /** The path where package.json was expected. */
+  readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that no package.json file exists at the expected path. Carries its
+ * own tag for `catchTag` routing.
+ *
+ * @public
+ */
+declare class PackageJsonNotFoundError extends PackageJsonNotFoundError_base {
+  get message(): string;
+}
+declare const PackageJsonParseError_base: Schema.Class<PackageJsonParseError, Schema.TaggedStruct<"PackageJsonParseError", {
+  /** The path whose contents failed to parse as JSON. */
+  readonly path: Schema.String;
+  /** The underlying `SyntaxError`, preserved structurally. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a package.json file's contents are not valid JSON.
+ *
+ * @public
+ */
+declare class PackageJsonParseError extends PackageJsonParseError_base {
+  get message(): string;
+}
+declare const PackageJsonWriteError_base: Schema.Class<PackageJsonWriteError, Schema.TaggedStruct<"PackageJsonWriteError", {
+  /** The path that could not be written. */
+  readonly path: Schema.String;
+  /** The underlying filesystem failure, preserved structurally. Narrowed to the write failure only. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+declare class PackageJsonWriteError extends PackageJsonWriteError_base {
+  get message(): string;
+}
+/**
+ * The shape of the {@link PackageJsonFile} service — the value produced by
+ * {@link PackageJsonFile.make} and carried by its layer.
+ *
+ * @public
+ */
+interface PackageJsonFileShape {
+  /**
+   * Read and decode a package.json file. Fails with `PackageJsonNotFoundError`
+   * (ENOENT), `PackageJsonReadError` (other fs errors), `PackageJsonParseError`
+   * (invalid JSON) or `PackageDecodeError` (schema decode).
+   */
+  readonly read: (path: string) => Effect.Effect<Package, PackageJsonReadError | PackageJsonNotFoundError | PackageJsonParseError | PackageDecodeError>;
+  /** Serialize and write a package.json file. Fails with `PackageJsonWriteError`. */
+  readonly write: (path: string, pkg: Package, options?: PackageFormatOptions) => Effect.Effect<void, PackageJsonWriteError>;
+}
+declare const PackageJsonFile_base: Context.ServiceClass<PackageJsonFile, "@effected/package-json/PackageJsonFile", PackageJsonFileShape>;
+/**
+ * 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
+ */
+declare class PackageJsonFile extends PackageJsonFile_base {
+  /** Build the service implementation from `FileSystem` / `Path` in context; use {@link PackageJsonFile.layer} to provide it. */
+  static readonly make: Effect.Effect<PackageJsonFileShape, never, FileSystem.FileSystem | Path.Path>;
+  /**
+   * The live layer. Requires core `FileSystem` / `Path`, provided by the
+   * consumer's platform implementation at the edge.
+   */
+  static readonly layer: Layer.Layer<PackageJsonFile, never, FileSystem.FileSystem | Path.Path>;
+}
+//#endregion
+//#region src/PackageValidator.d.ts
+/**
+ * A single validation-rule failure.
+ *
+ * @public
+ */
+interface RuleFailure {
+  /** A human-readable description of the failure. */
+  readonly message: string;
+  /** The JSON path where the failure occurred; `Option.none()` when not applicable. */
+  readonly path: Option.Option<string>;
+}
+/**
+ * A single validation rule: a name and a check that fails with a
+ * {@link RuleFailure}.
+ *
+ * @public
+ */
+interface ValidationRule {
+  /** The rule identifier (e.g. `has-license`). */
+  readonly name: string;
+  /** The check — succeeds or fails with a {@link RuleFailure}. */
+  readonly validate: (pkg: Package) => Effect.Effect<void, RuleFailure>;
+}
+declare const PackageValidationError_base: Schema.Class<PackageValidationError, Schema.TaggedStruct<"PackageValidationError", {
+  /** The aggregated rule failures. */
+  readonly failures: Schema.$Array<Schema.Struct<{
+    readonly rule: Schema.String;
+    readonly message: Schema.String;
+    readonly path: Schema.Option<Schema.String>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a {@link Package} failed one or more validation rules.
+ *
+ * Raised by {@link PackageValidator}. Every rule failure is aggregated on
+ * `failures`; the `message` getter renders a multi-line report.
+ *
+ * @public
+ */
+declare class PackageValidationError extends PackageValidationError_base {
+  get message(): string;
+}
+/**
+ * A rule that fails when any dependency uses an unresolved `workspace:` or
+ * `catalog:` specifier.
+ *
+ * @public
+ */
+declare const noUnresolvedDepsRule: ValidationRule;
+/**
+ * A rule that fails when any dependency uses a local `file:`, `link:` or
+ * `portal:` specifier.
+ *
+ * @public
+ */
+declare const noLocalDepsRule: ValidationRule;
+/**
+ * The default validation rules: license, description, repository and
+ * not-private.
+ *
+ * @public
+ */
+declare const defaultRules: ReadonlyArray<ValidationRule>;
+declare const PackageValidator_base: Context.ServiceClass<PackageValidator, "@effected/package-json/PackageValidator", {
+  readonly validate: (pkg: Package) => Effect.Effect<void, PackageValidationError>;
+}>;
+/**
+ * Validates a {@link Package} against a set of {@link ValidationRule}s,
+ * aggregating every failure into one {@link PackageValidationError}.
+ *
+ * @example
+ * ```ts
+ * import { Package, PackageValidator } 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 validator = yield* PackageValidator;
+ *   yield* validator.validate(pkg);
+ * }).pipe(Effect.provide(PackageValidator.layer));
+ * ```
+ *
+ * @public
+ */
+declare class PackageValidator extends PackageValidator_base {
+  /** The default layer, backed by {@link defaultRules}. */
+  static readonly layer: Layer.Layer<PackageValidator>;
+  /**
+   * Build a layer from a custom set of rules (a genuinely-parameterized factory).
+   *
+   * @param config - the rule set to validate against, replacing {@link defaultRules}
+   * @returns a layer providing `PackageValidator` backed by `config.rules`
+   */
+  static layerRules(config: {
+    readonly rules: ReadonlyArray<ValidationRule>;
+  }): 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, 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 };
+//# sourceMappingURL=index.d.ts.map