@effected/package-json 0.10.1 → 0.11.0

package/EntryPoint.js

@@ -0,0 +1,156 @@
+import { Result, Schema } from "effect";
+
+//#region src/EntryPoint.ts
+/**
+* Raised when a manifest resolves no root entry point.
+*
+* @remarks
+* The reason is discriminated rather than a bare "not found" because the three
+* shapes call for different responses, and a caller staring at a consumer's
+* plugin at 3am needs to know which one it hit. Collapsing them into one
+* sentinel is the same class of quiet wrong answer as an untyped error channel.
+*
+* @public
+*/
+var UnresolvedEntryPointError = class extends Schema.TaggedError()("UnresolvedEntryPointError", {
+	/**
+	* `noRootExport` — `exports` is a subpath map with no `"."` entry, so the
+	* package exports subpaths but no root. `noConditionMatched` — a root
+	* entry exists but none of the requested conditions are present, e.g. a
+	* `require`-only package read with `["import"]`.
+	* `unsupportedExportsForm` — an array fallback list, or another shape this
+	* resolver does not implement.
+	*/
+	reason: Schema.Literals([
+		"noRootExport",
+		"noConditionMatched",
+		"unsupportedExportsForm"
+	]),
+	/** The conditions that were tried, for `noConditionMatched`. */
+	conditions: Schema.optionalKey(Schema.Array(Schema.String))
+}) {
+	get message() {
+		switch (this.reason) {
+			case "noRootExport": return "The manifest's \"exports\" declares subpaths but no \".\" entry, so it has no root entry point";
+			case "noConditionMatched": return `The manifest's "exports" matched none of the conditions ${JSON.stringify(this.conditions ?? [])}`;
+			default: return "The manifest's \"exports\" uses a form this resolver does not implement";
+		}
+	}
+};
+const DEFAULT_CONDITIONS = ["import", "default"];
+/** A plain object — not an array, not `null`. */
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Is this `exports` object a conditions map rather than a subpath map?
+*
+* @remarks
+* Node's rule: the two forms cannot be mixed, and a subpath map is identified
+* by keys starting with `"."`. So an object with no `"."`-prefixed key is
+* conditions-only sugar for the `"."` subpath. An empty object is neither — it
+* exports nothing.
+*/
+const isRootConditions = (exportsObject) => {
+	const keys = Object.keys(exportsObject);
+	return keys.length > 0 && !keys.some((key) => key.startsWith("."));
+};
+/**
+* Resolve a conditions object to a file, honouring `conditions` in order.
+*
+* @remarks
+* Recurses, because conditions nest: `{ "import": { "node": "./n.js" } }` is
+* legal and a non-recursive reader answers an object where a path belongs.
+*/
+const resolveConditions = (conditionsObject, conditions) => {
+	for (const condition of conditions) {
+		const matched = conditionsObject[condition];
+		if (typeof matched === "string") return matched;
+		if (isPlainObject(matched)) {
+			const nested = resolveConditions(matched, conditions);
+			if (nested !== void 0) return nested;
+		}
+	}
+};
+/**
+* Resolve a package's root entry point from its manifest.
+*
+* @remarks
+* The half of "read something out of a published package" that has no home
+* anywhere else: given a manifest, which file is the package's `"."` entry?
+* It is pure and IO-free by design — nothing here touches a filesystem, so it
+* is testable against plain manifest objects with no package on disk, and it
+* composes with a directory that arrived by any route.
+*
+* All three legal `exports` spellings are honoured, because all three appear in
+* real published packages:
+*
+* - **String shorthand** — `"exports": "./index.js"`, sugar for `{ ".": … }`.
+* - **Subpath map** — `{ ".": "./index.js" }`, or `{ ".": { import, … } }`.
+* - **Root conditions** — `{ "import": "./index.js", "default": "./index.cjs" }`,
+*   conditions at the root with no `"."` key.
+*
+* **`exports` encapsulates the package.** When it is present but nothing
+* matches, the answer is a typed failure and `main` is **not** consulted — that
+* is Node's rule, and the lenient reading (falling through to `main`, then to
+* `index.js`) is the subtly wrong one: it answers a file the package
+* deliberately does not export, which loads and behaves plausibly instead of
+* failing. Only when `exports` is **absent** does `main`, and then the legacy
+* `index.js` default, apply.
+*
+* A failure is also the answer for an `exports` form this resolver does not
+* implement — an array fallback list, or a subpath map with no `"."` entry.
+* Both are honest "this resolver cannot tell you", never a guess, and each
+* carries its own {@link UnresolvedEntryPointError} reason so a caller can log
+* which shape a package actually had rather than a flat "could not resolve".
+*
+* @example
+* ```ts
+* import { resolveEntryPoint } from "@effected/package-json";
+* import { Result, Schema } from "effect";
+*
+* resolveEntryPoint({ exports: { import: "./esm.js", require: "./cjs.js" } });
+* // Result.succeed("./esm.js")
+*
+* resolveEntryPoint({ exports: { require: "./cjs.js" } }, { conditions: ["require"] });
+* // Result.succeed("./cjs.js")
+*
+* resolveEntryPoint({ exports: { require: "./cjs.js" }, main: "./legacy.js" });
+* // Result.fail(UnresolvedEntryPointError { reason: "noConditionMatched" })
+* ```
+*
+* @param manifest - A package manifest, or any object carrying `exports`/`main`.
+* @param options - Which conditions to honour, in priority order.
+* @returns The entry path as written in the manifest, relative to the package
+*   root, or a typed {@link UnresolvedEntryPointError} naming which shape
+*   blocked resolution.
+*
+* @public
+*/
+const resolveEntryPoint = (manifest, options) => {
+	const conditions = options?.conditions ?? DEFAULT_CONDITIONS;
+	const exportsField = manifest.exports;
+	if (typeof exportsField === "string") return Result.succeed(exportsField);
+	if (isPlainObject(exportsField)) {
+		if (isRootConditions(exportsField)) {
+			const resolved = resolveConditions(exportsField, conditions);
+			return resolved === void 0 ? Result.fail(new UnresolvedEntryPointError({
+				reason: "noConditionMatched",
+				conditions
+			})) : Result.succeed(resolved);
+		}
+		const dot = exportsField["."];
+		if (typeof dot === "string") return Result.succeed(dot);
+		if (isPlainObject(dot)) {
+			const resolved = resolveConditions(dot, conditions);
+			return resolved === void 0 ? Result.fail(new UnresolvedEntryPointError({
+				reason: "noConditionMatched",
+				conditions
+			})) : Result.succeed(resolved);
+		}
+		return Result.fail(new UnresolvedEntryPointError({ reason: "noRootExport" }));
+	}
+	if (exportsField !== void 0) return Result.fail(new UnresolvedEntryPointError({ reason: "unsupportedExportsForm" }));
+	return Result.succeed(typeof manifest.main === "string" && manifest.main !== "" ? manifest.main : "index.js");
+};
+
+//#endregion
+export { UnresolvedEntryPointError, resolveEntryPoint };

package/README.md

@@ -184,6 +184,32 @@ console.log(Effect.runSync(program));
 
 The `workspace:` range modifier is honored: `workspace:*` takes the bare version, `workspace:^` and `workspace:~` prefix it, and an explicit modifier is used as-is. The projection is `@effected/npm`'s `DependencySpecifier` statics with full pnpm publish semantics: the alias form `workspace:<name>@<range>` resolves the *target* package's version and becomes the `npm:<name>@<range>` alias pnpm publishes, and a blank catalog name selects the default catalog. A failed catalog assembly surfaces typed as `@effected/npm`'s `CatalogAssemblyError`, alongside the contracts' `DependencyResolutionError`.
 
+## Resolving an entry point
+
+`resolveEntryPoint` answers one question about a manifest — which file is the package's `"."` entry — and it is pure, IO-free and `Result`-returning, so it works against a plain object with no package on disk:
+
+```ts
+import { resolveEntryPoint } from "@effected/package-json";
+
+resolveEntryPoint({ exports: { import: "./esm.js", require: "./cjs.js" } });
+// Result.succeed("./esm.js")
+
+resolveEntryPoint({ exports: { require: "./cjs.js" } }, { conditions: ["require"] });
+// Result.succeed("./cjs.js")
+
+resolveEntryPoint({ main: "./legacy.js" });
+// Result.succeed("./legacy.js") — no exports field, so main applies
+
+resolveEntryPoint({ exports: { require: "./cjs.js" }, main: "./legacy.js" });
+// Result.fail(UnresolvedEntryPointError { reason: "noConditionMatched" })
+```
+
+All three legal `exports` spellings are honored — the string shorthand, a subpath map, and conditions at the root with no `"."` key — and conditions default to `["import", "default"]`, in priority order.
+
+The last case above is the semantic worth knowing: **`exports` encapsulates the package**, so a present-but-unmatched `exports` is a typed failure and `main` is *not* consulted. That is Node's rule. The lenient reading — falling through to `main`, then to `index.js` — answers a file the package deliberately does not export, and it loads and behaves plausibly instead of failing. Only an **absent** `exports` reaches `main`, and then the legacy `index.js` default. An `exports` form the resolver does not implement (an array fallback list, or a subpath map with no `"."` entry) fails for its own reason rather than being guessed at.
+
+Pair it with `@effected/npm`'s `PackageTarball` to find the entry file inside a tarball extracted before any install has run.
+
 ## Errors
 
 Every failure is a `Schema.TaggedError` routed with `Effect.catchTag`. Causes are preserved structurally on a `Schema.Defect` field — a `PackageDecodeError` hands you the `SchemaError` issue tree, not `String(error)`.
@@ -199,6 +225,7 @@ Every failure is a `Schema.TaggedError` routed with `Effect.catchTag`. Causes ar
 | `InvalidPackageNameError` | A string does not satisfy npm's naming rules. Raised by `Package.setName`. |
 | `InvalidSpdxLicenseError` | A string is not a valid SPDX license expression. Raised by `Package.setLicense`. |
 | `InvalidDependencySpecifierError` | A string is not a recognized dependency specifier. Raised by `DependencySpecifier.decode`. |
+| `UnresolvedEntryPointError` | No entry point could be resolved from a manifest. Returned in a `Result` by `resolveEntryPoint`, never raised, with `reason` telling `noConditionMatched`, `noRootExport` and `unsupportedExportsForm` apart. |
 
 `Package.setVersion` fails with `InvalidVersionError` from `@effected/semver`, which is where the version grammar lives.
 
@@ -208,6 +235,7 @@ Every failure is a `Schema.TaggedError` routed with `Effect.catchTag`. Causes ar
 - `Package.schema` / `Package.wireFor` — the open-JSON ↔ class wire codec, and the factory that builds one for a `.extend()`ed subclass so its custom fields decode as typed members instead of falling into `rest`.
 - `PackageJsonFile` — the IO surface: `read` and `write` over core `FileSystem` / `Path`, with the platform implementation supplied at the edge.
 - `PackageValidator` — rule-based validation aggregating every failure, with the default rule set, a parameterized `layerRules` factory, and the publish-gate rules `noUnresolvedDepsRule` and `noLocalDepsRule`.
+- `resolveEntryPoint` — the pure, `Result`-returning entry-point resolver over a manifest's `exports`/`main`, honoring `exports` encapsulation rather than falling through to `main`, with `EntryPointManifest` as its tolerant input shape.
 - `Package.resolve` — `catalog:` and `workspace:` expansion over the `@effected/npm` contracts with pnpm's publish-time projection (alias form included), as an explicit step that `write` never performs for you.
 - `PackageName`, `DependencySpecifier`, `Dependency`, `SpdxLicense`, `PackageManager`, `Person`, `Repository`, `Bugs`, `DevEngine` — the leaf concepts, each owning its own statics, brand and error, usable independently of `Package`. `Repository` and `Bugs` decode the `repository` and `bugs` fields from either their shorthand or object form, the same way `Person` does for `author`, `contributors` and `maintainers`; `Repository` also exposes `browseUrl` and `gitUrl` getters that normalize a shorthand or SSH form to `https://`.
 - `Package` also types `keywords`, `maintainers` and `homepage` directly, alongside the existing `author` and `contributors`.

package/index.d.ts

@@ -106,6 +106,124 @@ declare const DevEnginesSchema: Schema.Struct<{
  */
 type DevEngines = typeof DevEnginesSchema.Type;
 //#endregion
+//#region src/EntryPoint.d.ts
+/**
+ * Options for {@link resolveEntryPoint}.
+ *
+ * @public
+ */
+interface ResolveEntryPointOptions {
+  /**
+   * The export conditions to honour, in priority order.
+   *
+   * @remarks
+   * The first condition present in the manifest wins, so the order is the
+   * policy — `["require", "import"]` and `["import", "require"]` resolve the
+   * same manifest to different files, on purpose.
+   *
+   * @defaultValue `["import", "default"]`
+   */
+  readonly conditions?: ReadonlyArray<string>;
+}
+declare const UnresolvedEntryPointError_base: Schema.Class<UnresolvedEntryPointError, Schema.TaggedStruct<"UnresolvedEntryPointError", {
+  /**
+   * `noRootExport` — `exports` is a subpath map with no `"."` entry, so the
+   * package exports subpaths but no root. `noConditionMatched` — a root
+   * entry exists but none of the requested conditions are present, e.g. a
+   * `require`-only package read with `["import"]`.
+   * `unsupportedExportsForm` — an array fallback list, or another shape this
+   * resolver does not implement.
+   */
+  readonly reason: Schema.Literals<readonly ["noRootExport", "noConditionMatched", "unsupportedExportsForm"]>;
+  /** The conditions that were tried, for `noConditionMatched`. */
+  readonly conditions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a manifest resolves no root entry point.
+ *
+ * @remarks
+ * The reason is discriminated rather than a bare "not found" because the three
+ * shapes call for different responses, and a caller staring at a consumer's
+ * plugin at 3am needs to know which one it hit. Collapsing them into one
+ * sentinel is the same class of quiet wrong answer as an untyped error channel.
+ *
+ * @public
+ */
+declare class UnresolvedEntryPointError extends UnresolvedEntryPointError_base {
+  get message(): string;
+}
+/**
+ * The manifest fields entry resolution reads.
+ *
+ * @remarks
+ * Deliberately structural rather than the full {@link PackageManifest}, so a
+ * caller can resolve an entry point from any object carrying these two fields —
+ * a manifest parsed straight from a tarball, for instance, with nothing else
+ * validated yet.
+ *
+ * @public
+ */
+interface EntryPointManifest {
+  readonly exports?: unknown;
+  readonly main?: unknown;
+}
+/**
+ * Resolve a package's root entry point from its manifest.
+ *
+ * @remarks
+ * The half of "read something out of a published package" that has no home
+ * anywhere else: given a manifest, which file is the package's `"."` entry?
+ * It is pure and IO-free by design — nothing here touches a filesystem, so it
+ * is testable against plain manifest objects with no package on disk, and it
+ * composes with a directory that arrived by any route.
+ *
+ * All three legal `exports` spellings are honoured, because all three appear in
+ * real published packages:
+ *
+ * - **String shorthand** — `"exports": "./index.js"`, sugar for `{ ".": … }`.
+ * - **Subpath map** — `{ ".": "./index.js" }`, or `{ ".": { import, … } }`.
+ * - **Root conditions** — `{ "import": "./index.js", "default": "./index.cjs" }`,
+ *   conditions at the root with no `"."` key.
+ *
+ * **`exports` encapsulates the package.** When it is present but nothing
+ * matches, the answer is a typed failure and `main` is **not** consulted — that
+ * is Node's rule, and the lenient reading (falling through to `main`, then to
+ * `index.js`) is the subtly wrong one: it answers a file the package
+ * deliberately does not export, which loads and behaves plausibly instead of
+ * failing. Only when `exports` is **absent** does `main`, and then the legacy
+ * `index.js` default, apply.
+ *
+ * A failure is also the answer for an `exports` form this resolver does not
+ * implement — an array fallback list, or a subpath map with no `"."` entry.
+ * Both are honest "this resolver cannot tell you", never a guess, and each
+ * carries its own {@link UnresolvedEntryPointError} reason so a caller can log
+ * which shape a package actually had rather than a flat "could not resolve".
+ *
+ * @example
+ * ```ts
+ * import { resolveEntryPoint } from "@effected/package-json";
+ * import { Result, Schema } from "effect";
+ *
+ * resolveEntryPoint({ exports: { import: "./esm.js", require: "./cjs.js" } });
+ * // Result.succeed("./esm.js")
+ *
+ * resolveEntryPoint({ exports: { require: "./cjs.js" } }, { conditions: ["require"] });
+ * // Result.succeed("./cjs.js")
+ *
+ * resolveEntryPoint({ exports: { require: "./cjs.js" }, main: "./legacy.js" });
+ * // Result.fail(UnresolvedEntryPointError { reason: "noConditionMatched" })
+ * ```
+ *
+ * @param manifest - A package manifest, or any object carrying `exports`/`main`.
+ * @param options - Which conditions to honour, in priority order.
+ * @returns The entry path as written in the manifest, relative to the package
+ *   root, or a typed {@link UnresolvedEntryPointError} naming which shape
+ *   blocked resolution.
+ *
+ * @public
+ */
+declare const resolveEntryPoint: (manifest: EntryPointManifest, options?: ResolveEntryPointOptions) => Result.Result<string, UnresolvedEntryPointError>;
+//#endregion
 //#region src/License.d.ts
 declare const InvalidSpdxLicenseError_base: Schema.Class<InvalidSpdxLicenseError, Schema.TaggedStruct<"InvalidSpdxLicenseError", {
   /** The raw input string that failed validation. */
@@ -163,7 +281,10 @@ declare const PackageManager_base: Schema.Class<PackageManager, Schema.Struct<{
    * `CorepackIntegrityHash`, the shared restriction of the `IntegrityHash`
    * brand to the corepack `<algo>.<hex>` form.
    */
-  readonly integrity: Schema.Option<Schema.brand<Schema.String, "IntegrityHash">>;
+  readonly integrity: Schema.Option<Schema.brand<Schema.String, "IntegrityHash"> & {
+    FromSri: Schema.Codec<import("@effected/npm").IntegrityHashBrand, string, never, never>;
+    fromSri: (input: string) => Effect.Effect<import("@effected/npm").IntegrityHashBrand, import("@effected/npm").InvalidSriIntegrityHashError>;
+  }>;
 }>, {}>;
 /**
  * A structured `packageManager` value with `name`, `version` and an optional
@@ -974,7 +1095,10 @@ declare const PackageManagerRange_base: Schema.Class<PackageManagerRange, Schema
    * an integrity pins one artifact — but carried whenever the manifest
    * carries it, because fidelity outranks plausibility in a field model.
    */
-  readonly integrity: Schema.Option<Schema.brand<Schema.String, "IntegrityHash">>;
+  readonly integrity: Schema.Option<Schema.brand<Schema.String, "IntegrityHash"> & {
+    FromSri: Schema.Codec<import("@effected/npm").IntegrityHashBrand, string, never, never>;
+    fromSri: (input: string) => Effect.Effect<import("@effected/npm").IntegrityHashBrand, import("@effected/npm").InvalidSriIntegrityHashError>;
+  }>;
 }>, {}>;
 /**
  * A structured `packageManager` value whose version position is a semver
@@ -1418,5 +1542,5 @@ declare class PackageValidator extends PackageValidator_base {
   }): Layer.Layer<PackageValidator>;
 }
 //#endregion
-export { BinField, Bugs, Dependency, type DependencyKind, DependencyMapField, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, DevEngine, DevEngineOrArray, type DevEngines, DevEnginesSchema, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, type JsoncPath, Package, PackageDecodeError, type PackageFieldEdit, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, PackageJsonFile, type PackageJsonFileShape, PackageJsonFormat, PackageJsonModifyError, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageManagerRange, PackageManifest, PackageName, type PackagePatch, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, Repository, RepositoryField, type RuleFailure, ScopedPackageName, SpdxLicense, StringMapField, type UnresolvedDependency, UnscopedPackageName, type ValidationRule, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule };
+export { BinField, Bugs, Dependency, type DependencyKind, DependencyMapField, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, DevEngine, DevEngineOrArray, type DevEngines, DevEnginesSchema, type EntryPointManifest, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, type JsoncPath, Package, PackageDecodeError, type PackageFieldEdit, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, PackageJsonFile, type PackageJsonFileShape, PackageJsonFormat, PackageJsonModifyError, PackageJsonNotFoundError, PackageJsonParseError, PackageJsonReadError, PackageJsonSyntaxError, PackageJsonWriteError, PackageManager, PackageManagerRange, PackageManifest, PackageName, type PackagePatch, PackageValidationError, PackageValidator, PeerDependenciesMetaField, Person, PublishConfigField, Repository, RepositoryField, type ResolveEntryPointOptions, type RuleFailure, ScopedPackageName, SpdxLicense, StringMapField, type UnresolvedDependency, UnresolvedEntryPointError, UnscopedPackageName, type ValidationRule, defaultRules, isUnresolvedDependency, isValidDependencySpecifier, isValidSpdx, noLocalDepsRule, noUnresolvedDepsRule, resolveEntryPoint };
 //# sourceMappingURL=index.d.ts.map

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/package-json",
-	"version": "0.10.1",
+	"version": "0.11.0",
 	"private": false,
 	"description": "package.json parsing, editing, validation and file IO as Effect schemas.",
 	"keywords": [
@@ -39,7 +39,7 @@
 	},
 	"dependencies": {
 		"@effected/jsonc": "^0.7.0",
-		"@effected/npm": "^0.10.0",
+		"@effected/npm": "^0.12.0",
 		"@effected/semver": "^0.5.0",
 		"@effected/spdx": "^0.4.0"
 	},

package/tsdoc-metadata.json

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