@effected/package-json 0.12.0 → 0.14.0

package/Funding.js

@@ -0,0 +1,146 @@
+import { Effect, Schema, SchemaTransformation } from "effect";
+
+//#region src/Funding.ts
+const entryWires = /* @__PURE__ */ new WeakMap();
+/**
+* Entries that were the WHOLE field, written bare rather than inside an array.
+*
+* Keyed by the ENTRY, not by the decoded array: `Schema.Array` rebuilds the
+* array on the way out of the transform, so an array-keyed WeakMap is empty by
+* the time `encode` runs — verified by the arity round trip failing under it.
+* Arity provenance therefore rides the one instance that was the field, and
+* the replay is guarded on that instance still being alone.
+*/
+const bareEntries = /* @__PURE__ */ new WeakSet();
+const KNOWN_FUNDING_KEYS = /* @__PURE__ */ new Set(["type", "url"]);
+const FundingFields = Schema.Struct({
+	type: Schema.optionalKey(Schema.String),
+	url: Schema.String
+});
+const decodeFundingFields = Schema.decodeUnknownEffect(FundingFields);
+const restOf = (raw) => {
+	const rest = {};
+	for (const [key, value] of Object.entries(raw)) if (!KNOWN_FUNDING_KEYS.has(key)) rest[key] = value;
+	return rest;
+};
+/**
+* Whether the remembered object still describes this entry. Guarding the
+* replay is load-bearing: `Schema.Class` instances are not frozen, so an entry
+* mutated in place keeps a provenance entry that no longer describes it, and
+* an unguarded replay would write the ORIGINAL object back — silently
+* discarding the edit.
+*/
+const isFaithfulObject = (wire, funding) => {
+	if (wire.url !== funding.url) return false;
+	if ((typeof wire.type === "string" ? wire.type : void 0) !== funding.type) return false;
+	for (const [key, value] of Object.entries(funding.rest ?? {})) if (wire[key] !== value) return false;
+	return true;
+};
+/** Whether the bare string form can still carry everything this entry holds. */
+const isStringExpressible = (funding) => funding.type === void 0 && Object.keys(funding.rest ?? {}).length === 0;
+const encodeEntry = (funding) => {
+	const wire = entryWires.get(funding);
+	if (typeof wire === "string" && isStringExpressible(funding)) return funding.url;
+	if (wire !== void 0 && typeof wire !== "string" && isFaithfulObject(wire, funding)) return wire;
+	return {
+		...funding.type !== void 0 && { type: funding.type },
+		url: funding.url,
+		...funding.rest
+	};
+};
+const decodeEntry = (input) => {
+	if (typeof input === "string") {
+		const funding = Funding.make({ url: input });
+		entryWires.set(funding, input);
+		return Effect.succeed(funding);
+	}
+	return decodeFundingFields(input).pipe(Effect.mapError((error) => error.issue), Effect.map((fields) => {
+		const rest = restOf(input);
+		const funding = Funding.make({
+			...fields,
+			...Object.keys(rest).length > 0 ? { rest } : {}
+		});
+		entryWires.set(funding, input);
+		return funding;
+	}));
+};
+const EntryValue = Schema.Union([Schema.Record(Schema.String, Schema.Unknown), Schema.String]);
+const FieldValue = Schema.Union([EntryValue, Schema.Array(EntryValue)]);
+/**
+* Where to send money for a package: one funding entry.
+*
+* @remarks
+* npm's `funding` field accepts a bare URL string, this object form, or an
+* array of either. `url` is **required** — it is the only thing the field
+* actually says — so an object without one fails to decode rather than
+* producing a half-populated entry. `type` (`"individual"`, `"github"`, …) is
+* caller data and is kept **verbatim**, never normalized.
+*
+* @example
+* ```ts
+* import { Funding } from "@effected/package-json";
+* import { Effect, Schema } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   // Always an array, whichever encoding the manifest used.
+*   const entries = yield* Schema.decodeUnknownEffect(Funding.FromField)("https://example.com/sponsor");
+*   console.log(entries[0]?.url); // "https://example.com/sponsor"
+* });
+* ```
+*
+* @public
+*/
+var Funding = class Funding extends Schema.Class("Funding")({
+	/** The funding platform, when the object form carried one (`"github"`, …). */
+	type: Schema.optionalKey(Schema.String),
+	/** Where the money goes, exactly as the manifest wrote it. */
+	url: Schema.String,
+	/** Keys outside the documented set, preserved so encoding does not drop them. */
+	rest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown))
+}) {
+	/**
+	* A single `funding` entry: the bare URL string or the object form, always
+	* decoded to a {@link Funding} and always re-encoded in the form it was read
+	* from.
+	*
+	* @remarks
+	* Provenance belongs to the instance, so an entry that is *rebuilt* rather
+	* than carried through has none and encodes in the canonical object form.
+	*/
+	static FromValue = EntryValue.pipe(Schema.decodeTo(Schema.instanceOf(Funding), SchemaTransformation.transformOrFail({
+		decode: (input) => decodeEntry(input),
+		encode: (funding) => Effect.succeed(encodeEntry(funding))
+	})));
+	/**
+	* The `funding` field: a lone entry or an array of them, **always** decoded
+	* to an array so a consumer never branches on arity.
+	*
+	* @remarks
+	* The normalization is one-directional. A field written bare re-encodes
+	* bare, not as a one-element array — the arity is remembered against the
+	* single entry that WAS the field, and the replay is guarded on that entry
+	* still being alone, so pushing a second entry into the decoded array in
+	* place upgrades the field to the array form instead of silently dropping
+	* the addition. An entry built by hand has no provenance, so an array of
+	* such entries encodes as an array.
+	*/
+	static FromField = FieldValue.pipe(Schema.decodeTo(Schema.Array(Schema.instanceOf(Funding)), SchemaTransformation.transformOrFail({
+		decode: (input) => {
+			const bare = !Array.isArray(input);
+			const values = bare ? [input] : input;
+			return Effect.map(Effect.forEach(values, decodeEntry), (entries) => {
+				const only = entries[0];
+				if (bare && only !== void 0) bareEntries.add(only);
+				return entries;
+			});
+		},
+		encode: (entries) => {
+			const only = entries.length === 1 ? entries[0] : void 0;
+			if (only !== void 0 && bareEntries.has(only)) return Effect.succeed(encodeEntry(only));
+			return Effect.succeed(entries.map(encodeEntry));
+		}
+	})));
+};
+
+//#endregion
+export { Funding };

package/LenientManifest.js

@@ -60,6 +60,10 @@ const FIELD_GUARDS = /* @__PURE__ */ new Map([
 	}],
 	["repository", stringOrRecordGuard],
 	["bugs", stringOrRecordGuard],
+	["funding", {
+		expected: "a string, an object, or an array of either",
+		test: (value) => isStringOrRecord(value) || isStringOrRecordArray(value)
+	}],
 	["homepage", stringGuard],
 	["dependencies", stringRecordGuard],
 	["devDependencies", stringRecordGuard],
@@ -163,6 +167,7 @@ var LenientManifest = class LenientManifest extends Schema.Class("LenientManifes
 	keywords: Schema.optionalKey(Schema.Array(Schema.String)),
 	repository: Schema.optionalKey(StringOrRecord),
 	bugs: Schema.optionalKey(StringOrRecord),
+	funding: Schema.optionalKey(Schema.Union([StringOrRecord, Schema.Array(StringOrRecord)])),
 	homepage: Schema.optionalKey(Schema.String),
 	dependencies: Schema.optionalKey(StringRecord),
 	devDependencies: Schema.optionalKey(StringRecord),

package/License.js

@@ -1,5 +1,5 @@
-import { Schema } from "effect";
-import { isValidExpression } from "@effected/spdx";
+import { Result, Schema } from "effect";
+import { SpdxExpression, isValidExpression } from "@effected/spdx";
 
 //#region src/License.ts
 /**
@@ -32,9 +32,54 @@ const isValidSpdx = (value) => {
 * A valid SPDX license identifier, expression, `UNLICENSED`, or
 * `SEE LICENSE IN <file>`.
 *
+* @remarks
+* **A branded value here is not necessarily parseable as SPDX.** npm's
+* `license` field admits two strings that the SPDX grammar does not —
+* `UNLICENSED` and `SEE LICENSE IN <file>` — and this brand accepts both,
+* because it models what a manifest may legally carry, not what SPDX defines.
+* Feeding a branded value straight to `SpdxExpression.parse` therefore fails
+* on exactly those two forms. Do not hand-screen for them — reach for
+* {@link licenseExpressionOf}, which answers "what expression is this, if any"
+* and yields `Option.none()` for a spelling that is not one. Reach for
+* {@link isValidSpdx} when the question is instead "may a manifest carry this".
+*
 * @public
 */
 const SpdxLicense = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => isValidSpdx(value) ? void 0 : "Expected a valid SPDX license expression")), Schema.brand("SpdxLicense"));
+/**
+* The parsed SPDX expression a manifest's `license` denotes, or `Option.none()`
+* when it denotes no expression at all.
+*
+* @remarks
+* This is the accessor to reach for whenever a branded `SpdxLicense` has
+* to become an actual expression — a license URL, a badge, structured data, a
+* policy check. It exists because the brand and the grammar disagree, and that
+* disagreement is knowledge these two packages jointly own rather than
+* something each consumer should rediscover.
+*
+* `UNLICENSED` and `SEE LICENSE IN <file>` are legal in a manifest and are not
+* SPDX expressions, so they yield `Option.none()`. Everything else parses.
+* A consumer screening for those two spellings by hand gets it wrong the day
+* npm admits a third — this accessor is the mechanism that prose could not be,
+* and it needs no change on that day, because "not an expression" is answered
+* by the grammar rather than by a list of spellings kept in step with npm.
+*
+* @example
+* ```ts
+* import { licenseExpressionOf } from "@effected/package-json";
+* import { SpdxExpression } from "@effected/spdx";
+*
+* // "MIT"          => Option.some(<LicenseNode MIT>)
+* // "UNLICENSED"   => Option.none()
+* // "SEE LICENSE IN LICENSE.txt" => Option.none()
+* ```
+*
+* @param license - a branded manifest license value
+* @returns the parsed expression, or none for a spelling that is not one
+*
+* @public
+*/
+const licenseExpressionOf = (license) => Result.getSuccess(SpdxExpression.parseResult(license));
 
 //#endregion
-export { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx };
+export { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx, licenseExpressionOf };

package/Package.js

@@ -1,5 +1,6 @@
 import { Dependency } from "./Dependency.js";
 import { DevEnginesSchema } from "./DevEngines.js";
+import { Funding } from "./Funding.js";
 import { renderJson, resolveFormatOptions } from "./internal/format.js";
 import { makeWire } from "./internal/wire.js";
 import { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx } from "./License.js";
@@ -121,6 +122,7 @@ var Package = class Package extends Schema.Class("Package")({
 	keywords: Schema.optionalKey(Schema.Array(Schema.String)),
 	repository: Schema.optionalKey(Repository.FromValue),
 	bugs: Schema.optionalKey(Bugs.FromValue),
+	funding: Schema.optionalKey(Funding.FromField),
 	homepage: Schema.optionalKey(Schema.String),
 	dependencies: DependencyMapField,
 	devDependencies: DependencyMapField,

package/README.md

@@ -264,7 +264,10 @@ Every failure is a `Schema.TaggedError` routed with `Effect.catchTag`. Causes ar
 - `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.
 - `LenientManifest` — the shape-lenient discovery tier below `PackageManifest`: malformed known fields degrade to absence, are preserved verbatim in `rest` and reported on `issues`, rather than failing the document; `decodeResult`/`decode` and `parseResult`/`parse` in the package's usual `Result`/`Effect` pairing.
 - `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://`.
+- `PackageName`, `DependencySpecifier`, `Dependency`, `SpdxLicense`, `PackageManager`, `Person`, `Repository`, `Bugs`, `Funding`, `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://`.
+- `Repository.directoryUrl` — the browse URL of a monorepo member's own subdirectory, built from `repository.directory` against the host's path convention on GitHub, GitLab and Bitbucket. `none` for a host whose convention is unknown, or for a `directory` that climbs out of the repository — a guessed path would resolve to nothing while looking authoritative. With no `directory`, it is `browseUrl`.
+- `Funding` — the `funding` field, decoded from a bare URL string, an object, or an array of either, and **always** to an array so a consumer never branches on arity. Each entry re-encodes in the form it was read from, and unrecognized keys survive in `rest`.
+- `licenseExpressionOf` — a `SpdxLicense` as an `Option<SpdxExpression>` from `@effected/spdx`, for a caller that wants the parsed expression rather than the string. `none` for the `SEE LICENSE IN …` and `UNLICENSED` forms, which are valid `license` values but not license expressions.
 - `Package` also types `keywords`, `maintainers` and `homepage` directly, alongside the existing `author` and `contributors`.
 - Field schemas (`DependencyMapField`, `BinField`, `ExportsField`, `PublishConfigField`, `PeerDependenciesMetaField`, `StringMapField`) exported for subclasses that extend the model. `RepositoryField` is exported too but deprecated: `Package.repository` now decodes through `Repository.FromValue`, which round-trips the original shorthand or object form; `RepositoryField` remains only for consumers still matching on the raw union.
 

package/Repository.js

@@ -13,6 +13,16 @@ const BARE_SHORTHAND = /^[\w.-]+\/[\w.-]+$/;
 const PREFIXED_SHORTHAND = /^([a-z]+):(.+)$/;
 /** The scp-like form git accepts: `git@host:owner/name.git`. */
 const SCP_LIKE = /^(?:([\w.-]+)@)?([\w.-]+):(.+)$/;
+/**
+* How each known forge spells "browse this subdirectory". `HEAD` is used
+* rather than a branch name because the default branch is not knowable from a
+* manifest, and every one of these hosts resolves `HEAD` to it.
+*/
+const DIRECTORY_PATHS = /* @__PURE__ */ new Map([
+	["github.com", "tree/HEAD"],
+	["gitlab.com", "-/tree/HEAD"],
+	["bitbucket.org", "src/HEAD"]
+]);
 const stripGitSuffix = (value) => value.endsWith(".git") ? value.slice(0, -4) : value;
 /**
 * The browsable `https://host/path` form of a repository reference, or none
@@ -53,6 +63,34 @@ const KNOWN_REPOSITORY_KEYS = /* @__PURE__ */ new Set([
 	"directory"
 ]);
 const KNOWN_BUGS_KEYS = /* @__PURE__ */ new Set(["url", "email"]);
+const sameRest = (a, b) => JSON.stringify(a ?? {}) === JSON.stringify(b ?? {});
+/** The keys of `wire` outside the documented set, which is what `rest` holds. */
+const restOf = (wire, known) => {
+	const rest = {};
+	for (const [key, value] of Object.entries(wire)) if (!known.has(key)) rest[key] = value;
+	return rest;
+};
+/**
+* Whether the shorthand string can still carry everything this value holds.
+*
+* @remarks
+* A shorthand is only a `url` — it has no syntax for `type`, `directory` or an
+* unknown key. So a repository decoded from a string that later GAINS one of
+* those is no longer described by the wire it remembers, and replaying that
+* wire drops the addition silently. This is the same stale-provenance class the
+* object branch guards, reached through the one field the shorthand cannot
+* express, and `Person.isShorthandExpressible` / `Funding.isStringExpressible`
+* already gate their own string branches this way.
+*
+* `directory` is the live case: this package ships `Repository.directoryUrl`,
+* so a consumer reading a bare-string `repository` and making it a monorepo
+* member is the natural mutator.
+*/
+const isStringExpressibleRepository = (repository) => repository.type === void 0 && repository.directory === void 0 && Object.keys(repository.rest ?? {}).length === 0;
+/** Whether the bare URL string can still carry everything this `bugs` entry holds. */
+const isStringExpressibleBugs = (bugs) => bugs.email === void 0 && Object.keys(bugs.rest ?? {}).length === 0;
+const isFaithfulRepository = (wire, repository) => wire.url === repository.url && wire.type === repository.type && wire.directory === repository.directory && sameRest(restOf(wire, KNOWN_REPOSITORY_KEYS), repository.rest);
+const isFaithfulBugs = (wire, bugs) => wire.url === bugs.url && wire.email === bugs.email && sameRest(restOf(wire, KNOWN_BUGS_KEYS), bugs.rest);
 /**
 * Where a package's source lives.
 *
@@ -92,6 +130,60 @@ var Repository = class Repository extends Schema.Class("Repository")({
 		return Option.map(this.browseUrl, (url) => `${url}.git`);
 	}
 	/**
+	* The browsable URL of **this package** — {@link Repository.browseUrl}
+	* descended into `directory` when the package is a monorepo
+	* member.
+	*
+	* @remarks
+	* Prefer this over `browseUrl` whenever the question is "where does this
+	* package live". For a monorepo, `browseUrl` answers with the repository
+	* root, so every member of the repository reports the same location — which
+	* matters because that URL is exactly what a consumer (a docs site's
+	* structured data, say) uses to tell two packages apart.
+	*
+	* The three outcomes are deliberately distinct:
+	*
+	* - **No `directory`** — the package *is* the repository root, so this is
+	*   `browseUrl`. A correct answer, not a missing one.
+	* - **`directory` on a host this model knows** (GitHub, GitLab, Bitbucket) —
+	*   the descended URL.
+	* - **`directory` on any other host** — `Option.none()`. The path convention
+	*   for browsing a subdirectory is per-forge and cannot be guessed, and
+	*   fabricating one would produce a URL that resolves to nothing while
+	*   looking authoritative.
+	*
+	* What to do with that `none` is a policy this getter deliberately leaves to
+	* the caller, because it depends on what is being filled in. Falling back to
+	* {@link Repository.browseUrl} is reasonable wherever a less precise answer
+	* beats no answer — the repository root is a *true* location for the package,
+	* merely one that does not distinguish it from its siblings. Omit the value
+	* instead wherever that lack of distinction is the whole point. What is never
+	* reasonable is inventing a subdirectory path for a host this model does not
+	* recognize, which is the case this `none` exists to prevent.
+	*
+	* A `directory` that escapes the repository (any `..` segment) is refused the
+	* same way. One that resolves to the root itself (`"."`, `"/"`) is the root.
+	*
+	* @example
+	* ```ts
+	* // { url: "effected/kit", directory: "packages/spdx" }
+	* // => https://github.com/effected/kit/tree/HEAD/packages/spdx
+	* ```
+	*/
+	get directoryUrl() {
+		const directory = this.directory;
+		if (directory === void 0) return this.browseUrl;
+		const segments = directory.split("/").map((segment) => segment.trim()).filter((segment) => segment !== "" && segment !== ".");
+		if (segments.some((segment) => segment === "..")) return Option.none();
+		if (segments.length === 0) return this.browseUrl;
+		return Option.flatMap(this.browseUrl, (url) => {
+			const host = /^https:\/\/([^/]+)/.exec(url)?.[1];
+			const path = host === void 0 ? void 0 : DIRECTORY_PATHS.get(host);
+			if (path === void 0) return Option.none();
+			return Option.some(`${url}/${path}/${segments.map((segment) => encodeURIComponent(segment)).join("/")}`);
+		});
+	}
+	/**
 	* The `repository` field: the shorthand string or the object form, always
 	* decoded to a {@link Repository}, and always re-encoded in the form it was
 	* read from.
@@ -116,8 +208,8 @@ var Repository = class Repository extends Schema.Class("Repository")({
 		},
 		encode: (repository) => {
 			const wire = repositoryWires.get(repository);
-			if (typeof wire === "string" && wire === repository.url) return wire;
-			if (wire !== void 0 && typeof wire !== "string") return wire;
+			if (typeof wire === "string" && wire === repository.url && isStringExpressibleRepository(repository)) return wire;
+			if (wire !== void 0 && typeof wire !== "string" && isFaithfulRepository(wire, repository)) return wire;
 			return {
 				...repository.type !== void 0 && { type: repository.type },
 				url: repository.url,
@@ -164,8 +256,8 @@ var Bugs = class Bugs extends Schema.Class("Bugs")({
 		},
 		encode: (bugs) => {
 			const wire = bugsWires.get(bugs);
-			if (typeof wire === "string" && wire === bugs.url && bugs.email === void 0) return wire;
-			if (wire !== void 0 && typeof wire !== "string") return wire;
+			if (typeof wire === "string" && wire === bugs.url && isStringExpressibleBugs(bugs)) return wire;
+			if (wire !== void 0 && typeof wire !== "string" && isFaithfulBugs(wire, bugs)) return wire;
 			return {
 				...bugs.url !== void 0 && { url: bugs.url },
 				...bugs.email !== void 0 && { email: bugs.email },

package/index.d.ts

@@ -2,6 +2,7 @@ import { JsoncEdit, JsoncEdit as JsoncEdit$1, JsoncPath, JsoncPath as JsoncPath$
 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, Result, Schema } from "effect";
+import { SpdxExpression } from "@effected/spdx";
 //#region src/Dependency.d.ts
 declare const Dependency_base: Schema.Class<Dependency, Schema.Struct<{
   /** The package name. */
@@ -20,7 +21,7 @@ declare const Dependency_base: Schema.Class<Dependency, Schema.Struct<{
  *
  * @public
  */
-declare class Dependency extends Dependency_base {
+export 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. */
@@ -59,7 +60,7 @@ type UnresolvedDependency = Dependency & {
  *
  * @public
  */
-declare const isUnresolvedDependency: <T extends {
+export declare const isUnresolvedDependency: <T extends {
   readonly isUnresolved: boolean;
 }>(dependency: T) => dependency is T & {
   readonly isUnresolved: true;
@@ -79,20 +80,20 @@ declare const DevEngine_base: Schema.Class<DevEngine, Schema.Struct<{
  *
  * @public
  */
-declare class DevEngine extends DevEngine_base {}
+export 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>]>;
+export 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<{
+export declare const DevEnginesSchema: Schema.Struct<{
   readonly packageManager: Schema.optionalKey<typeof DevEngineOrArray>;
   readonly runtime: Schema.optionalKey<typeof DevEngineOrArray>;
   readonly os: Schema.optionalKey<typeof DevEngineOrArray>;
@@ -149,7 +150,7 @@ declare const UnresolvedEntryPointError_base: Schema.Class<UnresolvedEntryPointE
  *
  * @public
  */
-declare class UnresolvedEntryPointError extends UnresolvedEntryPointError_base {
+export declare class UnresolvedEntryPointError extends UnresolvedEntryPointError_base {
   get message(): string;
 }
 /**
@@ -222,7 +223,73 @@ interface EntryPointManifest {
  *
  * @public
  */
-declare const resolveEntryPoint: (manifest: EntryPointManifest, options?: ResolveEntryPointOptions) => Result.Result<string, UnresolvedEntryPointError>;
+export declare const resolveEntryPoint: (manifest: EntryPointManifest, options?: ResolveEntryPointOptions) => Result.Result<string, UnresolvedEntryPointError>;
+//#endregion
+//#region src/Funding.d.ts
+declare const Funding_base: Schema.Class<Funding, Schema.Struct<{
+  /** The funding platform, when the object form carried one (`"github"`, …). */
+  readonly type: Schema.optionalKey<Schema.String>;
+  /** Where the money goes, exactly as the manifest wrote it. */
+  readonly url: Schema.String;
+  /** Keys outside the documented set, preserved so encoding does not drop them. */
+  readonly rest: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+/**
+ * Where to send money for a package: one funding entry.
+ *
+ * @remarks
+ * npm's `funding` field accepts a bare URL string, this object form, or an
+ * array of either. `url` is **required** — it is the only thing the field
+ * actually says — so an object without one fails to decode rather than
+ * producing a half-populated entry. `type` (`"individual"`, `"github"`, …) is
+ * caller data and is kept **verbatim**, never normalized.
+ *
+ * @example
+ * ```ts
+ * import { Funding } from "@effected/package-json";
+ * import { Effect, Schema } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   // Always an array, whichever encoding the manifest used.
+ *   const entries = yield* Schema.decodeUnknownEffect(Funding.FromField)("https://example.com/sponsor");
+ *   console.log(entries[0]?.url); // "https://example.com/sponsor"
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare class Funding extends Funding_base {
+  /**
+   * A single `funding` entry: the bare URL string or the object form, always
+   * decoded to a {@link Funding} and always re-encoded in the form it was read
+   * from.
+   *
+   * @remarks
+   * Provenance belongs to the instance, so an entry that is *rebuilt* rather
+   * than carried through has none and encodes in the canonical object form.
+   */
+  static readonly FromValue: Schema.Codec<Funding, string | {
+    readonly [k: string]: unknown;
+  }>;
+  /**
+   * The `funding` field: a lone entry or an array of them, **always** decoded
+   * to an array so a consumer never branches on arity.
+   *
+   * @remarks
+   * The normalization is one-directional. A field written bare re-encodes
+   * bare, not as a one-element array — the arity is remembered against the
+   * single entry that WAS the field, and the replay is guarded on that entry
+   * still being alone, so pushing a second entry into the decoded array in
+   * place upgrades the field to the array form instead of silently dropping
+   * the addition. An entry built by hand has no provenance, so an array of
+   * such entries encodes as an array.
+   */
+  static readonly FromField: Schema.Codec<ReadonlyArray<Funding>, string | {
+    readonly [k: string]: unknown;
+  } | ReadonlyArray<string | {
+    readonly [k: string]: unknown;
+  }>>;
+}
 //#endregion
 //#region src/License.d.ts
 declare const InvalidSpdxLicenseError_base: Schema.Class<InvalidSpdxLicenseError, Schema.TaggedStruct<"InvalidSpdxLicenseError", {
@@ -237,7 +304,7 @@ declare const InvalidSpdxLicenseError_base: Schema.Class<InvalidSpdxLicenseError
  *
  * @public
  */
-declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseError_base {
+export declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseError_base {
   get message(): string;
 }
 /**
@@ -246,20 +313,65 @@ declare class InvalidSpdxLicenseError extends InvalidSpdxLicenseError_base {
  *
  * @public
  */
-declare const isValidSpdx: (value: string) => boolean;
+export declare const isValidSpdx: (value: string) => boolean;
 /**
  * A valid SPDX license identifier, expression, `UNLICENSED`, or
  * `SEE LICENSE IN <file>`.
  *
+ * @remarks
+ * **A branded value here is not necessarily parseable as SPDX.** npm's
+ * `license` field admits two strings that the SPDX grammar does not —
+ * `UNLICENSED` and `SEE LICENSE IN <file>` — and this brand accepts both,
+ * because it models what a manifest may legally carry, not what SPDX defines.
+ * Feeding a branded value straight to `SpdxExpression.parse` therefore fails
+ * on exactly those two forms. Do not hand-screen for them — reach for
+ * {@link licenseExpressionOf}, which answers "what expression is this, if any"
+ * and yields `Option.none()` for a spelling that is not one. Reach for
+ * {@link isValidSpdx} when the question is instead "may a manifest carry this".
+ *
  * @public
  */
-declare const SpdxLicense: Schema.brand<Schema.String, "SpdxLicense">;
+export declare const SpdxLicense: Schema.brand<Schema.String, "SpdxLicense">;
 /**
  * A branded SPDX license string.
  *
  * @public
  */
-type SpdxLicense = string & Brand.Brand<"SpdxLicense">;
+export type SpdxLicense = string & Brand.Brand<"SpdxLicense">;
+/**
+ * The parsed SPDX expression a manifest's `license` denotes, or `Option.none()`
+ * when it denotes no expression at all.
+ *
+ * @remarks
+ * This is the accessor to reach for whenever a branded `SpdxLicense` has
+ * to become an actual expression — a license URL, a badge, structured data, a
+ * policy check. It exists because the brand and the grammar disagree, and that
+ * disagreement is knowledge these two packages jointly own rather than
+ * something each consumer should rediscover.
+ *
+ * `UNLICENSED` and `SEE LICENSE IN <file>` are legal in a manifest and are not
+ * SPDX expressions, so they yield `Option.none()`. Everything else parses.
+ * A consumer screening for those two spellings by hand gets it wrong the day
+ * npm admits a third — this accessor is the mechanism that prose could not be,
+ * and it needs no change on that day, because "not an expression" is answered
+ * by the grammar rather than by a list of spellings kept in step with npm.
+ *
+ * @example
+ * ```ts
+ * import { licenseExpressionOf } from "@effected/package-json";
+ * import { SpdxExpression } from "@effected/spdx";
+ *
+ * // "MIT"          => Option.some(<LicenseNode MIT>)
+ * // "UNLICENSED"   => Option.none()
+ * // "SEE LICENSE IN LICENSE.txt" => Option.none()
+ * ```
+ *
+ * @param license - a branded manifest license value
+ * @returns the parsed expression, or none for a spelling that is not one
+ *
+ * @public
+ */
+export declare const licenseExpressionOf: (license: SpdxLicense) => Option.Option<SpdxExpression>;
 //#endregion
 //#region src/PackageManager.d.ts
 declare const PackageManager_base: Schema.Class<PackageManager, Schema.Struct<{
@@ -325,7 +437,7 @@ declare const PackageManager_base: Schema.Class<PackageManager, Schema.Struct<{
  *
  * @public
  */
-declare class PackageManager extends PackageManager_base {
+export declare class PackageManager extends PackageManager_base {
   /**
    * Schema transformation between the `"name@version+integrity"` string and a
    * {@link PackageManager}.
@@ -357,7 +469,7 @@ declare const InvalidPackageNameError_base: Schema.Class<InvalidPackageNameError
  *
  * @public
  */
-declare class InvalidPackageNameError extends InvalidPackageNameError_base {
+export declare class InvalidPackageNameError extends InvalidPackageNameError_base {
   get message(): string;
 }
 /**
@@ -365,31 +477,31 @@ declare class InvalidPackageNameError extends InvalidPackageNameError_base {
  *
  * @public
  */
-declare const ScopedPackageName: Schema.brand<Schema.String, "ScopedPackageName">;
+export declare const ScopedPackageName: Schema.brand<Schema.String, "ScopedPackageName">;
 /**
  * A valid npm scoped package name.
  *
  * @public
  */
-type ScopedPackageName = string & Brand.Brand<"ScopedPackageName">;
+export type ScopedPackageName = string & Brand.Brand<"ScopedPackageName">;
 /**
  * A valid npm unscoped package name (no `@scope/` prefix).
  *
  * @public
  */
-declare const UnscopedPackageName: Schema.brand<Schema.String, "UnscopedPackageName">;
+export declare const UnscopedPackageName: Schema.brand<Schema.String, "UnscopedPackageName">;
 /**
  * A valid npm unscoped package name.
  *
  * @public
  */
-type UnscopedPackageName = string & Brand.Brand<"UnscopedPackageName">;
+export type UnscopedPackageName = string & Brand.Brand<"UnscopedPackageName">;
 /**
  * A valid npm package name, scoped or unscoped.
  *
  * @public
  */
-type PackageName = ScopedPackageName | UnscopedPackageName;
+export type PackageName = ScopedPackageName | UnscopedPackageName;
 /**
  * The union of `ScopedPackageName` and `UnscopedPackageName`,
  * carrying the classification statics (`PackageName.isValid` and friends)
@@ -398,7 +510,7 @@ type PackageName = ScopedPackageName | UnscopedPackageName;
  *
  * @public
  */
-declare const PackageName: Schema.Union<readonly [Schema.brand<Schema.String, "ScopedPackageName">, Schema.brand<Schema.String, "UnscopedPackageName">]> & {
+export 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;
@@ -422,7 +534,7 @@ declare const Person_base: Schema.Class<Person, Schema.Struct<{
  *
  * @public
  */
-declare class Person extends Person_base {
+export 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
@@ -497,7 +609,7 @@ declare const Repository_base: Schema.Class<Repository, Schema.Struct<{
  *
  * @public
  */
-declare class Repository extends Repository_base {
+export declare class Repository extends Repository_base {
   /**
    * The browsable `https://` URL, or `Option.none()` when `url` is not a form
    * this model recognizes.
@@ -505,6 +617,48 @@ declare class Repository extends Repository_base {
   get browseUrl(): Option.Option<string>;
   /** The canonical https clone URL, or none when it cannot be derived. */
   get gitUrl(): Option.Option<string>;
+  /**
+   * The browsable URL of **this package** — {@link Repository.browseUrl}
+   * descended into `directory` when the package is a monorepo
+   * member.
+   *
+   * @remarks
+   * Prefer this over `browseUrl` whenever the question is "where does this
+   * package live". For a monorepo, `browseUrl` answers with the repository
+   * root, so every member of the repository reports the same location — which
+   * matters because that URL is exactly what a consumer (a docs site's
+   * structured data, say) uses to tell two packages apart.
+   *
+   * The three outcomes are deliberately distinct:
+   *
+   * - **No `directory`** — the package *is* the repository root, so this is
+   *   `browseUrl`. A correct answer, not a missing one.
+   * - **`directory` on a host this model knows** (GitHub, GitLab, Bitbucket) —
+   *   the descended URL.
+   * - **`directory` on any other host** — `Option.none()`. The path convention
+   *   for browsing a subdirectory is per-forge and cannot be guessed, and
+   *   fabricating one would produce a URL that resolves to nothing while
+   *   looking authoritative.
+   *
+   * What to do with that `none` is a policy this getter deliberately leaves to
+   * the caller, because it depends on what is being filled in. Falling back to
+   * {@link Repository.browseUrl} is reasonable wherever a less precise answer
+   * beats no answer — the repository root is a *true* location for the package,
+   * merely one that does not distinguish it from its siblings. Omit the value
+   * instead wherever that lack of distinction is the whole point. What is never
+   * reasonable is inventing a subdirectory path for a host this model does not
+   * recognize, which is the case this `none` exists to prevent.
+   *
+   * A `directory` that escapes the repository (any `..` segment) is refused the
+   * same way. One that resolves to the root itself (`"."`, `"/"`) is the root.
+   *
+   * @example
+   * ```ts
+   * // { url: "effected/kit", directory: "packages/spdx" }
+   * // => https://github.com/effected/kit/tree/HEAD/packages/spdx
+   * ```
+   */
+  get directoryUrl(): Option.Option<string>;
   /**
    * The `repository` field: the shorthand string or the object form, always
    * decoded to a {@link Repository}, and always re-encoded in the form it was
@@ -531,7 +685,7 @@ declare const Bugs_base: Schema.Class<Bugs, Schema.Struct<{
  *
  * @public
  */
-declare class Bugs extends Bugs_base {
+export declare class Bugs extends Bugs_base {
   /** The `bugs` field: a URL string or the object form. */
   static readonly FromValue: Schema.Codec<Bugs, string | {
     readonly [k: string]: unknown;
@@ -546,7 +700,7 @@ declare class Bugs extends Bugs_base {
  *
  * @public
  */
-declare const DependencyMapField: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>, never, never>;
+export 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
@@ -554,21 +708,21 @@ declare const DependencyMapField: Schema.decodeTo<Schema.HashMap<Schema.String,
  *
  * @public
  */
-declare const StringMapField: Schema.decodeTo<Schema.HashMap<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.String>, never, never>;
+export 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>]>;
+export 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>]>;
+export 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
@@ -576,14 +730,14 @@ declare const ExportsField: Schema.Union<readonly [Schema.String, Schema.$Record
  *
  * @public
  */
-declare const PublishConfigField: Schema.$Record<Schema.String, Schema.Unknown>;
+export 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<{
+export declare const PeerDependenciesMetaField: Schema.$Record<Schema.String, Schema.Struct<{
   readonly optional: Schema.optionalKey<Schema.Boolean>;
 }>>;
 /**
@@ -596,7 +750,7 @@ declare const PeerDependenciesMetaField: Schema.$Record<Schema.String, Schema.St
  *
  * @public
  */
-declare const RepositoryField: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>;
+export 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;
@@ -610,7 +764,7 @@ declare const PackageDecodeError_base: Schema.Class<PackageDecodeError, Schema.T
  *
  * @public
  */
-declare class PackageDecodeError extends PackageDecodeError_base {
+export declare class PackageDecodeError extends PackageDecodeError_base {
   get message(): string;
 }
 /**
@@ -681,6 +835,11 @@ declare const Package_base: Schema.Class<Package, Schema.Struct<{
   readonly bugs: Schema.optionalKey<Schema.Codec<Bugs, string | {
     readonly [k: string]: unknown;
   }, never, never>>;
+  readonly funding: Schema.optionalKey<Schema.Codec<readonly Funding[], string | readonly (string | {
+    readonly [k: string]: unknown;
+  })[] | {
+    readonly [k: string]: unknown;
+  }, never, never>>;
   readonly homepage: Schema.optionalKey<Schema.String>;
   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>;
@@ -723,7 +882,7 @@ declare const Package_base: Schema.Class<Package, Schema.Struct<{
  *
  * @public
  */
-declare class Package extends Package_base {
+export 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;
@@ -886,7 +1045,7 @@ declare const PackageJsonSyntaxError_base: Schema.Class<PackageJsonSyntaxError,
  *
  * @public
  */
-declare class PackageJsonSyntaxError extends PackageJsonSyntaxError_base {
+export declare class PackageJsonSyntaxError extends PackageJsonSyntaxError_base {
   get message(): string;
 }
 /**
@@ -936,7 +1095,7 @@ declare const PackageJsonModifyError_base: Schema.Class<PackageJsonModifyError,
  *
  * @public
  */
-declare class PackageJsonModifyError extends PackageJsonModifyError_base {
+export declare class PackageJsonModifyError extends PackageJsonModifyError_base {
   get message(): string;
 }
 /**
@@ -958,7 +1117,7 @@ declare class PackageJsonModifyError extends PackageJsonModifyError_base {
  *
  * @public
  */
-declare class PackageJsonFormat {
+export declare class PackageJsonFormat {
   private constructor();
   /**
    * Order a package.json object's keys canonically **without decoding it into
@@ -1112,6 +1271,7 @@ declare const LenientManifest_base: Schema.Class<LenientManifest, Schema.Struct<
   readonly keywords: Schema.optionalKey<Schema.$Array<Schema.String>>;
   readonly repository: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>>;
   readonly bugs: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>>;
+  readonly funding: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Unknown>]>>]>>;
   readonly homepage: Schema.optionalKey<Schema.String>;
   readonly dependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
   readonly devDependencies: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
@@ -1185,7 +1345,7 @@ declare const LenientManifest_base: Schema.Class<LenientManifest, Schema.Struct<
  *
  * @public
  */
-declare class LenientManifest extends LenientManifest_base {
+export declare class LenientManifest extends LenientManifest_base {
   /**
    * Decode an unknown JSON value leniently, degrading malformed fields instead
    * of failing the document. The sync primitive backing
@@ -1293,7 +1453,7 @@ declare const PackageManagerRange_base: Schema.Class<PackageManagerRange, Schema
  *
  * @public
  */
-declare class PackageManagerRange extends PackageManagerRange_base {
+export declare class PackageManagerRange extends PackageManagerRange_base {
   /**
    * Schema transformation between the `"name@range[+integrity]"` string and a
    * {@link PackageManagerRange}.
@@ -1343,6 +1503,11 @@ declare const PackageManifest_base: Schema.Class<PackageManifest, Schema.Struct<
   readonly bugs: Schema.optionalKey<Schema.Codec<Bugs, string | {
     readonly [k: string]: unknown;
   }, never, never>>;
+  readonly funding: Schema.optionalKey<Schema.Codec<readonly Funding[], string | readonly (string | {
+    readonly [k: string]: unknown;
+  })[] | {
+    readonly [k: string]: unknown;
+  }, never, never>>;
   readonly homepage: Schema.optionalKey<Schema.String>;
   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>;
@@ -1416,7 +1581,7 @@ declare const PackageManifest_base: Schema.Class<PackageManifest, Schema.Struct<
  *
  * @public
  */
-declare class PackageManifest extends PackageManifest_base {
+export declare class PackageManifest extends PackageManifest_base {
   /**
    * The wire codec: an open JSON object ↔ a {@link PackageManifest} instance,
    * partitioning unknown keys into `rest` and flattening them back on encode —
@@ -1460,7 +1625,7 @@ declare const PackageJsonReadError_base: Schema.Class<PackageJsonReadError, Sche
  *
  * @public
  */
-declare class PackageJsonReadError extends PackageJsonReadError_base {
+export declare class PackageJsonReadError extends PackageJsonReadError_base {
   get message(): string;
 }
 declare const PackageJsonNotFoundError_base: Schema.Class<PackageJsonNotFoundError, Schema.TaggedStruct<"PackageJsonNotFoundError", {
@@ -1473,7 +1638,7 @@ declare const PackageJsonNotFoundError_base: Schema.Class<PackageJsonNotFoundErr
  *
  * @public
  */
-declare class PackageJsonNotFoundError extends PackageJsonNotFoundError_base {
+export declare class PackageJsonNotFoundError extends PackageJsonNotFoundError_base {
   get message(): string;
 }
 declare const PackageJsonParseError_base: Schema.Class<PackageJsonParseError, Schema.TaggedStruct<"PackageJsonParseError", {
@@ -1487,7 +1652,7 @@ declare const PackageJsonParseError_base: Schema.Class<PackageJsonParseError, Sc
  *
  * @public
  */
-declare class PackageJsonParseError extends PackageJsonParseError_base {
+export declare class PackageJsonParseError extends PackageJsonParseError_base {
   get message(): string;
 }
 declare const PackageJsonWriteError_base: Schema.Class<PackageJsonWriteError, Schema.TaggedStruct<"PackageJsonWriteError", {
@@ -1503,7 +1668,7 @@ declare const PackageJsonWriteError_base: Schema.Class<PackageJsonWriteError, Sc
  *
  * @public
  */
-declare class PackageJsonWriteError extends PackageJsonWriteError_base {
+export declare class PackageJsonWriteError extends PackageJsonWriteError_base {
   get message(): string;
 }
 /**
@@ -1591,7 +1756,7 @@ declare const PackageJsonFile_base: Context.ServiceClass<PackageJsonFile, "@effe
  *
  * @public
  */
-declare class PackageJsonFile extends PackageJsonFile_base {
+export 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>;
   /**
@@ -1641,7 +1806,7 @@ declare const PackageValidationError_base: Schema.Class<PackageValidationError,
  *
  * @public
  */
-declare class PackageValidationError extends PackageValidationError_base {
+export declare class PackageValidationError extends PackageValidationError_base {
   get message(): string;
 }
 /**
@@ -1650,21 +1815,21 @@ declare class PackageValidationError extends PackageValidationError_base {
  *
  * @public
  */
-declare const noUnresolvedDepsRule: ValidationRule;
+export declare const noUnresolvedDepsRule: ValidationRule;
 /**
  * A rule that fails when any dependency uses a local `file:`, `link:` or
  * `portal:` specifier.
  *
  * @public
  */
-declare const noLocalDepsRule: ValidationRule;
+export declare const noLocalDepsRule: ValidationRule;
 /**
  * The default validation rules: license, description, repository and
  * not-private.
  *
  * @public
  */
-declare const defaultRules: ReadonlyArray<ValidationRule>;
+export declare const defaultRules: ReadonlyArray<ValidationRule>;
 declare const PackageValidator_base: Context.ServiceClass<PackageValidator, "@effected/package-json/PackageValidator", {
   readonly validate: (pkg: Package) => Effect.Effect<void, PackageValidationError>;
 }>;
@@ -1686,7 +1851,7 @@ declare const PackageValidator_base: Context.ServiceClass<PackageValidator, "@ef
  *
  * @public
  */
-declare class PackageValidator extends PackageValidator_base {
+export declare class PackageValidator extends PackageValidator_base {
   /** The default layer, backed by {@link defaultRules}. */
   static readonly layer: Layer.Layer<PackageValidator>;
   /**
@@ -1700,5 +1865,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, type EntryPointManifest, ExportsField, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, type JsoncPath, type LenientFieldIssue, LenientManifest, 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 };
+export { type DependencyKind, type DependencyProtocol, DependencySpecifier, type DependencySpecifierBrand, type DevEngines, type EntryPointManifest, InvalidDependencySpecifierError, JsoncEdit, type JsoncPath, type LenientFieldIssue, type PackageFieldEdit, type PackageFormatOptions, type PackageFormatTextOptions, type PackageIndent, type PackageJsonFileShape, type PackagePatch, type ResolveEntryPointOptions, type RuleFailure, type UnresolvedDependency, type ValidationRule, isValidDependencySpecifier };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,7 +1,8 @@
 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 { Funding } from "./Funding.js";
+import { InvalidSpdxLicenseError, SpdxLicense, isValidSpdx, licenseExpressionOf } from "./License.js";
 import { PackageManager } from "./PackageManager.js";
 import { InvalidPackageNameError, PackageName, ScopedPackageName, UnscopedPackageName } from "./PackageName.js";
 import { Person } from "./Person.js";
@@ -16,4 +17,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, LenientManifest, 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 };
+export { BinField, Bugs, Dependency, DependencyMapField, DependencySpecifier, DevEngine, DevEngineOrArray, DevEnginesSchema, ExportsField, Funding, InvalidDependencySpecifierError, InvalidPackageNameError, InvalidSpdxLicenseError, JsoncEdit, LenientManifest, 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, licenseExpressionOf, noLocalDepsRule, noUnresolvedDepsRule, resolveEntryPoint };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/package-json",
-	"version": "0.12.0",
+	"version": "0.14.0",
 	"private": false,
 	"description": "package.json parsing, editing, validation and file IO as Effect schemas.",
 	"keywords": [
@@ -38,13 +38,13 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/jsonc": "^0.8.0",
-		"@effected/npm": "^0.12.0",
-		"@effected/semver": "^0.5.0",
-		"@effected/spdx": "^0.4.0"
+		"@effected/jsonc": "^0.9.0",
+		"@effected/npm": "^0.13.0",
+		"@effected/semver": "^0.6.0",
+		"@effected/spdx": "^0.6.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.109"
+		"effect": "4.0.0-rc.112"
 	},
 	"engines": {
 		"node": ">=24.11.0"