@effected/lockfiles 0.1.0

package/BunExtension.js

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+
+//#region src/BunExtension.ts
+/**
+* Extension data specific to bun lockfiles, attached to `Lockfile.extension`
+* when the format is `"bun"`.
+*
+* @remarks
+* - `catalog` — the default (unnamed) catalog.
+* - `catalogs` — named catalog definitions.
+* - `overrides` — the version override map.
+* - `trustedDependencies` — packages allowed to run install scripts.
+*
+* @public
+*/
+var BunExtension = class extends Schema.Class("BunExtension")({
+	_tag: Schema.tag("bun"),
+	catalog: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),
+	catalogs: Schema.optionalKey(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+	overrides: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	trustedDependencies: Schema.optionalKey(Schema.Array(Schema.String))
+}) {};
+
+//#endregion
+export { BunExtension };

package/ImporterDependency.js

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { DependencyField, DependencySpecifier } from "@effected/npm";
+
+//#region src/ImporterDependency.ts
+/**
+* One declared dependency of one workspace importer, as the lockfile records it.
+*
+* @remarks
+* - `name` — the dependency's package name.
+* - `specifier` — the declared range, typed through `@effected/npm`'s
+*   `DependencySpecifier.FromString` codec: the decoded value is a tag-matchable
+*   `ClassifiedSpecifier` (`catalog:` / `workspace:` / range / dist-tag / raw),
+*   while encoding round-trips the **exact original string byte-for-byte** — the
+*   guarantee a before/after lockfile diff relies on.
+* - `version` — the concrete resolved version, **populated by pnpm only**. pnpm
+*   records `{ specifier, version }` per importer dependency; bun and npm record
+*   resolved versions on their package entries instead, so for those formats
+*   `version` is absent and a consumer joins by `name` against
+*   `Lockfile.packages`.
+* - `depType` — which dependency map declared it, spelled with `@effected/npm`'s
+*   kit-wide `DependencyField` vocabulary.
+*
+* @public
+*/
+var ImporterDependency = class extends Schema.Class("ImporterDependency")({
+	name: Schema.NonEmptyString,
+	specifier: DependencySpecifier.FromString,
+	version: Schema.optionalKey(Schema.String),
+	depType: DependencyField
+}) {};
+
+//#endregion
+export { ImporterDependency };

package/LICENSE

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

package/Lockfile.js

@@ -0,0 +1,258 @@
+import { BunExtension } from "./BunExtension.js";
+import { LockfileImporter } from "./LockfileImporter.js";
+import { ResolvedPackage } from "./ResolvedPackage.js";
+import { WorkspaceDependency } from "./WorkspaceDependency.js";
+import { parseBun } from "./internal/bun.js";
+import { parseNpm } from "./internal/npm.js";
+import { PnpmExtension } from "./PnpmExtension.js";
+import { parsePnpm } from "./internal/pnpm.js";
+import { parseYarn } from "./internal/yarn.js";
+import { LockfileFormat } from "./LockfileFormat.js";
+import { Effect, Option, Schema } from "effect";
+
+//#region src/Lockfile.ts
+const EMPTY_IMPORTERS = [];
+/**
+* Failure of `Lockfile.parse`: the given content is not a valid lockfile of
+* the requested format.
+*
+* @remarks
+* - `format` — which format was being parsed.
+* - `stage` — `"syntax"` when the text itself failed to parse (YAML, JSON,
+*   JSONC), `"validation"` when the text parsed but did not have the
+*   format's expected shape.
+* - `cause` — the underlying jsonc/yaml/JSON/Schema error, preserved
+*   structurally.
+*
+* Malformed input always exits through this typed failure, never as a
+* defect. Parse takes content, not a path — the caller that did the IO owns
+* any path context.
+*
+* @public
+*/
+var LockfileParseError = class extends Schema.TaggedErrorClass()("LockfileParseError", {
+	format: LockfileFormat,
+	stage: Schema.Literals(["syntax", "validation"]),
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return this.stage === "syntax" ? `Failed to parse ${this.format} lockfile: the content is not well-formed` : `Failed to parse ${this.format} lockfile: the content does not have the expected ${this.format} shape`;
+	}
+};
+/**
+* Failure of `Lockfile.parse`: the content parsed as text, but no single
+* lockfile document could be located in it.
+*
+* @remarks
+* `pnpm-lock.yaml` is a YAML **stream**. pnpm 11 writes a
+* config-dependencies preamble document ahead of the lockfile whenever the
+* workspace uses `configDependencies`, so the file holds two documents. The
+* lockfile is the last one — pnpm composes the preamble as a prefix — and a
+* parser that reads only the first document gets the preamble: a document
+* that *validates*, and yields a lockfile with an empty workspace. This error
+* exists so that case can never again succeed quietly.
+*
+* - `format` — which format was being parsed.
+* - `documents` — how many YAML documents the stream carried.
+* - `reason`:
+*   - `"noLockfileDocument"` — the stream carries no lockfile document. An
+*     env-only `pnpm-lock.yaml` (a config-dependencies preamble and nothing
+*     after it) reads this way, as does empty content. pnpm itself treats
+*     such a file as having no lockfile.
+*   - `"noImporters"` — the located document declares no importers, so it
+*     describes no workspace. pnpm always records at least the root importer.
+*   - `"unexpectedDocuments"` — the stream carries several documents in a
+*     format that defines no document framing (yarn). Rather than silently
+*     taking the first, parsing refuses to guess.
+*
+* It carries typed fields rather than a `cause`: unlike
+* {@link LockfileParseError}, there is no underlying engine failure to wrap —
+* the text parsed fine.
+*
+* @public
+*/
+var LockfileFramingError = class extends Schema.TaggedErrorClass()("LockfileFramingError", {
+	format: LockfileFormat,
+	reason: Schema.Literals([
+		"noLockfileDocument",
+		"noImporters",
+		"unexpectedDocuments"
+	]),
+	documents: Schema.Int
+}) {
+	get message() {
+		const detail = this.reason === "noImporters" ? "the lockfile document declares no importers, so it describes no workspace" : this.reason === "unexpectedDocuments" ? `expected a single YAML document but the content carries ${this.documents}` : `the content carries no lockfile document (${this.documents} YAML document(s) found)`;
+		return `Failed to parse ${this.format} lockfile: ${detail}`;
+	}
+};
+const dispatch = (format, content) => {
+	switch (format) {
+		case "bun": return parseBun(content);
+		case "npm": return parseNpm(content);
+		case "pnpm": return parsePnpm(content);
+		case "yarn": return parseYarn(content);
+	}
+};
+/**
+* The unified lockfile model all four formats normalize into.
+*
+* @remarks
+* - `format` — which lockfile format produced the data.
+* - `lockfileVersion` — the lockfile format version string.
+* - `packages` — every resolved package.
+* - `workspaceDependencies` — inter-workspace dependency edges.
+* - `importers` — each workspace importer's declared dependencies
+*   ({@link LockfileImporter}), keyed by importer path. Populated by the pnpm,
+*   bun and npm parsers; always empty for yarn, which records no importers.
+* - `extension` — format-specific residue (`PnpmExtension` or
+*   `BunExtension`) when the format records any.
+*
+* For pnpm, `Lockfile.parse` emits the honest importer-path-keyed model
+* (workspace packages named by importer path, version `"0.0.0"`);
+* {@link Lockfile.withImporterNames} is the explicit, pure second stage
+* that rewrites those names once the caller has read the workspace
+* manifests. npm, yarn and bun lockfiles carry real names and need no
+* second stage.
+*
+* @public
+*/
+var Lockfile = class Lockfile extends Schema.Class("Lockfile")({
+	format: LockfileFormat,
+	lockfileVersion: Schema.String,
+	packages: Schema.Array(ResolvedPackage),
+	workspaceDependencies: Schema.Array(WorkspaceDependency),
+	importers: Schema.Array(LockfileImporter).pipe(Schema.withDecodingDefaultKey(Effect.succeed([])), Schema.withConstructorDefault(Effect.succeed(EMPTY_IMPORTERS))),
+	extension: Schema.optionalKey(Schema.Union([PnpmExtension, BunExtension]))
+}) {
+	/** Lazily built name → packages index; deliberately outside the schema, never encodes. */
+	#nameIndex;
+	/** Lazily built importer-path → importer index; deliberately outside the schema, never encodes. */
+	#importerIndex;
+	/**
+	* Parse lockfile content of a known format into the unified model — the
+	* package's only fallible boundary.
+	*
+	* @param content - The lockfile text (this package does no IO; the caller
+	*   reads the file).
+	* @param options - The lockfile format to parse as.
+	* @returns An `Effect` succeeding with the {@link Lockfile}, or failing
+	*   with {@link LockfileParseError} (malformed text or the wrong shape) or
+	*   {@link LockfileFramingError} (the text parsed, but no lockfile document
+	*   could be located in the stream — see that error for why a
+	*   multi-document `pnpm-lock.yaml` needs it).
+	*/
+	static parse = Effect.fn("Lockfile.parse")(function* (content, options) {
+		const fields = yield* dispatch(options.format, content).pipe(Effect.mapError((failure) => failure.stage === "framing" ? new LockfileFramingError({
+			format: options.format,
+			reason: failure.reason,
+			documents: failure.documents
+		}) : new LockfileParseError({
+			format: options.format,
+			stage: failure.stage,
+			cause: failure.cause
+		})));
+		return Lockfile.make({
+			format: options.format,
+			lockfileVersion: fields.lockfileVersion,
+			packages: fields.packages,
+			workspaceDependencies: fields.workspaceDependencies,
+			importers: fields.importers,
+			...fields.extension !== void 0 ? { extension: fields.extension } : {}
+		});
+	});
+	/**
+	* Rewrite pnpm importer-path names to real package names — the explicit
+	* second stage of pnpm parsing. Total and pure.
+	*
+	* @remarks
+	* Workspace packages whose `relativePath` appears in `names` are renamed;
+	* dependency edge ends are rewritten through the same map. Entries not in
+	* the map keep their path name, and non-pnpm lockfiles are unaffected (no
+	* key matches). Versions are not touched — pnpm workspace packages keep
+	* `"0.0.0"` (the lockfile does not record their real versions).
+	*
+	* @param names - Importer path → real package name.
+	* @returns A new {@link Lockfile} with names rewritten.
+	*/
+	withImporterNames(names) {
+		const packages = this.packages.map((pkg) => {
+			if (!pkg.isWorkspace || pkg.relativePath === void 0) return pkg;
+			const realName = names.get(pkg.relativePath);
+			if (realName === void 0 || realName === "" || realName === pkg.name) return pkg;
+			return ResolvedPackage.make({
+				name: realName,
+				version: pkg.version,
+				...pkg.integrity !== void 0 ? { integrity: pkg.integrity } : {},
+				isWorkspace: pkg.isWorkspace,
+				relativePath: pkg.relativePath,
+				dependencies: pkg.dependencies
+			});
+		});
+		const workspaceDependencies = this.workspaceDependencies.map((dep) => {
+			const mappedFrom = names.get(dep.from);
+			const mappedTo = names.get(dep.to);
+			const from = mappedFrom === void 0 || mappedFrom === "" ? dep.from : mappedFrom;
+			const to = mappedTo === void 0 || mappedTo === "" ? dep.to : mappedTo;
+			if (from === dep.from && to === dep.to) return dep;
+			return WorkspaceDependency.make({
+				from,
+				to,
+				depType: dep.depType,
+				constraint: dep.constraint
+			});
+		});
+		return Lockfile.make({
+			format: this.format,
+			lockfileVersion: this.lockfileVersion,
+			packages,
+			workspaceDependencies,
+			importers: this.importers,
+			...this.extension !== void 0 ? { extension: this.extension } : {}
+		});
+	}
+	/**
+	* Every resolved package with the given name — one entry per resolved
+	* version. Backed by a lazily built index, so repeated lookups are O(1).
+	*
+	* @param name - The package name to look up.
+	* @returns The matching packages, empty when the name is not in the
+	*   lockfile.
+	*/
+	packagesNamed(name) {
+		if (this.#nameIndex === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const pkg of this.packages) {
+				const bucket = index.get(pkg.name);
+				if (bucket === void 0) index.set(pkg.name, [pkg]);
+				else bucket.push(pkg);
+			}
+			this.#nameIndex = index;
+		}
+		return this.#nameIndex.get(name) ?? [];
+	}
+	/**
+	* The importer at the given path — `"."` for the workspace root — or
+	* `Option.none()` when the lockfile records no importer there. Backed by a
+	* lazily built index, so repeated lookups are O(1). The index is a `Map`,
+	* so an attacker-adjacent path (`__proto__`, `constructor`) neither pollutes
+	* nor collides.
+	*
+	* @param path - The importer path to look up.
+	* @returns The matching {@link LockfileImporter}, or `Option.none()`.
+	*/
+	importer(path) {
+		if (this.#importerIndex === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const imp of this.importers) index.set(imp.path, imp);
+			this.#importerIndex = index;
+		}
+		return Option.fromUndefinedOr(this.#importerIndex.get(path));
+	}
+	/** The workspace-local packages. */
+	get workspacePackages() {
+		return this.packages.filter((pkg) => pkg.isWorkspace);
+	}
+};
+
+//#endregion
+export { Lockfile, LockfileFramingError, LockfileParseError };

package/LockfileFormat.js

@@ -0,0 +1,52 @@
+import { Option, Schema } from "effect";
+
+//#region src/LockfileFormat.ts
+/**
+* The lockfile formats this package parses: bun's `bun.lock` (JSONC), npm's
+* `package-lock.json` (v2/v3 JSON), pnpm's `pnpm-lock.yaml` and yarn Berry's
+* `yarn.lock` (both YAML).
+*
+* @remarks
+* The literal names the *lockfile format*, not the package manager that
+* happens to write it — this package models lockfiles. Yarn support is
+* Berry only; classic (v1) `yarn.lock` is not YAML and fails
+* `Lockfile.parse` with a typed `LockfileParseError`.
+*
+* @public
+*/
+const LockfileFormat = Schema.Literals([
+	"bun",
+	"npm",
+	"pnpm",
+	"yarn"
+]);
+const FILENAMES = {
+	bun: "bun.lock",
+	npm: "package-lock.json",
+	pnpm: "pnpm-lock.yaml",
+	yarn: "yarn.lock"
+};
+/**
+* The conventional lockfile filename for a format: `"bun.lock"`,
+* `"package-lock.json"`, `"pnpm-lock.yaml"` or `"yarn.lock"`.
+*
+* @public
+*/
+const filenameFor = (format) => FILENAMES[format];
+/**
+* The format a lockfile filename identifies, if any.
+*
+* @remarks
+* Matches exact conventional filenames only (`"bun.lock"`,
+* `"package-lock.json"`, `"pnpm-lock.yaml"`, `"yarn.lock"`) — paths and
+* other spellings return `Option.none()`.
+*
+* @public
+*/
+const fromFilename = (name) => {
+	for (const format of LockfileFormat.literals) if (FILENAMES[format] === name) return Option.some(format);
+	return Option.none();
+};
+
+//#endregion
+export { LockfileFormat, filenameFor, fromFilename };

package/LockfileImporter.js

@@ -0,0 +1,29 @@
+import { ImporterDependency } from "./ImporterDependency.js";
+import { Schema } from "effect";
+
+//#region src/LockfileImporter.ts
+/**
+* One workspace importer's declared dependencies, as the lockfile records them.
+*
+* @remarks
+* - `path` — the importer path relative to the workspace root, `"."` for the
+*   root package (never empty — a `NonEmptyString`) — the same keys as
+*   `WorkspaceDiscovery.importerMap()` in
+*   `@effected/workspaces`. This is the stable join key: `Lockfile#importer`
+*   looks importers up by it, and `Lockfile#withImporterNames` deliberately
+*   leaves importers untouched because the path — not a package name — keys
+*   them.
+* - `dependencies` — each declared dependency as an {@link ImporterDependency}.
+*
+* Populated by the pnpm, bun and npm parsers. yarn does not record importers,
+* so a yarn lockfile always yields an empty `importers` array.
+*
+* @public
+*/
+var LockfileImporter = class extends Schema.Class("LockfileImporter")({
+	path: Schema.NonEmptyString,
+	dependencies: Schema.Array(ImporterDependency)
+}) {};
+
+//#endregion
+export { LockfileImporter };

package/LockfileIntegrity.js

@@ -0,0 +1,123 @@
+import { DEP_TYPES, isWorkspaceSpecifier } from "./internal/shared.js";
+import { Exit, Schema } from "effect";
+import { DependencyField } from "@effected/npm";
+import { Range, SemVer } from "@effected/semver";
+
+//#region src/LockfileIntegrity.ts
+/**
+* The minimal manifest shape {@link LockfileIntegrity.compare} checks a
+* lockfile against: a package name plus the four optional dependency maps.
+*
+* @remarks
+* Deliberately *not* a `@effected/package-json` type — this package takes
+* manifests as plain values so its consumers own the manifest IO (and may
+* derive these from any richer model).
+*
+* @public
+*/
+var WorkspaceManifest = class extends Schema.Class("WorkspaceManifest")({
+	name: Schema.NonEmptyString,
+	dependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	devDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	peerDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	optionalDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+}) {};
+const decodeRange = Schema.decodeUnknownExit(Range.FromString);
+const decodeSemVer = Schema.decodeUnknownExit(SemVer.FromString);
+/**
+* Result of checking a parsed lockfile against the workspace's declared
+* manifests.
+*
+* @remarks
+* A data type, not an error: it reports *what* mismatches exist without
+* failing anything.
+*
+* - `valid` — `true` when the lockfile is fully consistent.
+* - `missingWorkspaces` — workspace names present in the manifests but
+*   absent from the lockfile.
+* - `extraWorkspaces` — workspace names in the lockfile with no matching
+*   manifest.
+* - `unsatisfiedConstraints` — declared constraints the lockfile's resolved
+*   versions do not satisfy.
+*
+* @public
+*/
+var LockfileIntegrity = class LockfileIntegrity extends Schema.Class("LockfileIntegrity")({
+	valid: Schema.Boolean,
+	missingWorkspaces: Schema.Array(Schema.String),
+	extraWorkspaces: Schema.Array(Schema.String),
+	unsatisfiedConstraints: Schema.Array(Schema.Struct({
+		workspace: Schema.String,
+		dependency: Schema.String,
+		constraint: Schema.String,
+		resolved: Schema.String,
+		depType: DependencyField
+	}))
+}) {
+	/**
+	* Check a lockfile's consistency against workspace manifests — a total,
+	* pure function: no Effect, no error channel, no IO.
+	*
+	* @remarks
+	* Constraint checking is best-effort by design: `workspace:` / `link:` /
+	* `file:` specifiers and rows whose range (or every resolved version) does
+	* not parse as SemVer are skipped, exactly as in the v3 implementation.
+	* A lockfile may resolve the same package at several versions; a
+	* constraint is satisfied when *any* resolved version matches, and an
+	* unsatisfied row reports every candidate in `resolved`. The
+	* caller reads the manifests (this package does no IO). For pnpm, apply
+	* `Lockfile#withImporterNames` first so workspace names align with
+	* manifest names.
+	*
+	* (Named `compare`, not `check`: every v4 `Schema.Class` already carries
+	* a `static check(...checks)` for attaching schema checks, and statics
+	* cannot be shadowed with an incompatible signature.)
+	*
+	* @param lockfile - The parsed lockfile.
+	* @param manifests - The workspace manifests to compare against.
+	* @returns The integrity report.
+	*/
+	static compare(lockfile, manifests) {
+		const workspacePackages = lockfile.packages.filter((p) => p.isWorkspace && p.relativePath !== void 0);
+		const lockfileWsNames = new Set(workspacePackages.map((p) => p.name));
+		const manifestNames = new Set(manifests.map((m) => m.name));
+		const missingWorkspaces = [...manifestNames].filter((n) => !lockfileWsNames.has(n));
+		const extraWorkspaces = [...lockfileWsNames].filter((n) => !manifestNames.has(n));
+		const resolvedIndex = /* @__PURE__ */ new Map();
+		for (const p of lockfile.packages) {
+			const versions = resolvedIndex.get(p.name);
+			if (versions === void 0) resolvedIndex.set(p.name, [p.version]);
+			else versions.push(p.version);
+		}
+		const unsatisfiedConstraints = [];
+		for (const manifest of manifests) for (const depType of DEP_TYPES) {
+			const depMap = manifest[depType];
+			if (!depMap) continue;
+			for (const [dependency, constraint] of Object.entries(depMap)) {
+				if (isWorkspaceSpecifier(constraint)) continue;
+				const candidates = resolvedIndex.get(dependency);
+				if (candidates === void 0) continue;
+				const rangeExit = decodeRange(constraint);
+				if (Exit.isFailure(rangeExit)) continue;
+				const versions = candidates.map((candidate) => decodeSemVer(candidate)).filter(Exit.isSuccess);
+				if (versions.length === 0) continue;
+				if (!versions.some((v) => rangeExit.value.test(v.value))) unsatisfiedConstraints.push({
+					workspace: manifest.name,
+					dependency,
+					constraint,
+					resolved: candidates.join(", "),
+					depType
+				});
+			}
+		}
+		return LockfileIntegrity.make({
+			valid: missingWorkspaces.length === 0 && extraWorkspaces.length === 0 && unsatisfiedConstraints.length === 0,
+			missingWorkspaces,
+			extraWorkspaces,
+			unsatisfiedConstraints
+		});
+	}
+};
+
+//#endregion
+export { LockfileIntegrity, WorkspaceManifest };

package/PnpmExtension.js

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+
+//#region src/PnpmExtension.ts
+/**
+* Extension data specific to pnpm lockfiles, attached to `Lockfile.extension`
+* when the format is `"pnpm"`.
+*
+* @remarks
+* - `catalogs` — pnpm catalog definitions ({@link PnpmCatalogs}).
+* - `overrides` — the version override map recorded in the lockfile header.
+* - `settings` — pnpm settings recorded in the lockfile header.
+*
+* @public
+*/
+var PnpmExtension = class extends Schema.Class("PnpmExtension")({
+	_tag: Schema.tag("pnpm"),
+	catalogs: Schema.optionalKey(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Struct({
+		specifier: Schema.String,
+		version: Schema.String
+	})])))),
+	overrides: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	settings: Schema.optionalKey(Schema.Struct({
+		autoInstallPeers: Schema.optionalKey(Schema.Boolean),
+		excludeLinksFromLockfile: Schema.optionalKey(Schema.Boolean)
+	}))
+}) {};
+
+//#endregion
+export { PnpmExtension };