@packall/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,227 +1,16 @@
+import { _ as OutputError, a as layerCallback, b as RegistryUnreachableError, c as ArchiveError, d as InvalidInputFileError, f as InvalidSpecError, g as NoMatchingVersionsError, h as LockfileOutOfDateError, i as emit, l as AuthenticationError, m as LockfileIncompleteError, n as createArchive, o as layerSilent, p as LockfileError, r as Progress, s as makeCollector, t as Archiver, u as IntegrityError, v as PackageNotFoundError, x as VersionNotFoundError, y as RegistryResponseError } from "./archive-6sqTn1C4.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Getter from "effect/SchemaGetter";
 import semver from "semver";
 import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import * as Ref from "effect/Ref";
-import { createHash, timingSafeEqual } from "node:crypto";
+import * as Crypto from "effect/Crypto";
+import * as Encoding from "effect/Encoding";
 import { parse } from "yaml";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { create } from "tar";
 
-//#region src/errors.ts
-var BundlerErrorBase = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = new.target.name;
-	}
-};
-/** A package spec on the command line or in an input file could not be parsed. */
-var InvalidSpecError = class extends BundlerErrorBase {
-	_tag = "InvalidSpecError";
-	spec;
-	reason;
-	constructor(spec, reason) {
-		super(`Invalid package spec ${JSON.stringify(spec)}: ${reason}`);
-		this.spec = spec;
-		this.reason = reason;
-	}
-};
-/** `--file` pointed at something that is neither a usable package.json nor a spec list. */
-var InvalidInputFileError = class extends BundlerErrorBase {
-	_tag = "InvalidInputFileError";
-	path;
-	reason;
-	constructor(path, reason, options) {
-		super(`Cannot read specs from ${path}: ${reason}`, options);
-		this.path = path;
-		this.reason = reason;
-	}
-};
-/** A lockfile could not be read, or is in a format we do not support. */
-var LockfileError = class extends BundlerErrorBase {
-	_tag = "LockfileError";
-	path;
-	reason;
-	constructor(path, reason, options) {
-		super(`Lockfile ${path}: ${reason}`, options);
-		this.path = path;
-		this.reason = reason;
-	}
-};
-/**
-* The lockfile parsed, but does not pin everything the bundle needs.
-*
-* Falling back to a range here would defeat the entire point of reading a
-* lockfile — you would get a bundle that is *mostly* what CI installed, with no
-* indication of which parts were guessed. So this is fatal, and it names every
-* gap at once so one `npm install` fixes all of them.
-*/
-var LockfileIncompleteError = class extends BundlerErrorBase {
-	_tag = "LockfileIncompleteError";
-	path;
-	missing;
-	constructor(path, missing, detail, remedy) {
-		const shown = missing.slice(0, 10).map((entry) => `    ${entry}`).join("\n");
-		const rest = missing.length > 10 ? `\n    … and ${missing.length - 10} more` : "";
-		super(`${path} is incomplete — ${detail}:\n${shown}${rest}\n  ${remedy}\n  Or pass --lockfile off to resolve version ranges fresh instead.`);
-		this.path = path;
-		this.missing = missing;
-	}
-};
-/**
-* The lockfile pins versions the registry no longer serves.
-*
-* Unpublished, or never mirrored into a private registry. Either way the
-* bundle cannot be built as specified, and quietly substituting a nearby
-* version would produce exactly the mismatch this feature exists to prevent.
-*/
-var LockfileOutOfDateError = class extends BundlerErrorBase {
-	_tag = "LockfileOutOfDateError";
-	path;
-	registry;
-	missing;
-	constructor(path, registry, missing) {
-		const shown = missing.slice(0, 10).map((entry) => `    ${entry.name}@${entry.version} — ${entry.detail}`).join("\n");
-		const rest = missing.length > 10 ? `\n    … and ${missing.length - 10} more` : "";
-		super(`${path} pins ${missing.length} version${missing.length === 1 ? "" : "s"} that ${registry} does not serve:\n${shown}${rest}\n  Refresh the lockfile against this registry, or pass --lockfile off to\n  resolve version ranges fresh instead.`);
-		this.path = path;
-		this.registry = registry;
-		this.missing = missing.map(({ name, version }) => ({
-			name,
-			version
-		}));
-	}
-};
-/**
-* The registry could not be reached at all — DNS failure, refused connection,
-* proxy blackhole, or a preflight that timed out.
-*
-* This is the error that fixes "hangs forever with no network": we surface it
-* quickly and say which host we could not reach.
-*/
-var RegistryUnreachableError = class extends BundlerErrorBase {
-	_tag = "RegistryUnreachableError";
-	registry;
-	timeoutMs;
-	constructor(registry, detail, options) {
-		super(`Cannot reach registry ${registry}: ${detail}.\n  Check your network connection, VPN, and the proxy settings in your .npmrc.`, options);
-		this.registry = registry;
-		this.timeoutMs = options?.timeoutMs;
-	}
-};
-/** The registry answered, but has never heard of this package. */
-var PackageNotFoundError = class extends BundlerErrorBase {
-	_tag = "PackageNotFoundError";
-	packageName;
-	registry;
-	constructor(packageName, registry) {
-		super(`Package "${packageName}" was not found on ${registry}`);
-		this.packageName = packageName;
-		this.registry = registry;
-	}
-};
-/** The package exists but the exact version requested does not. */
-var VersionNotFoundError = class extends BundlerErrorBase {
-	_tag = "VersionNotFoundError";
-	packageName;
-	version;
-	available;
-	constructor(packageName, version, available) {
-		const tail = available.slice(-5).join(", ");
-		super(`${packageName}@${version} does not exist.` + (tail.length > 0 ? ` Most recent published versions: ${tail}` : ""));
-		this.packageName = packageName;
-		this.version = version;
-		this.available = available;
-	}
-};
-/** A range (or dist-tag) matched nothing that is actually published. */
-var NoMatchingVersionsError = class extends BundlerErrorBase {
-	_tag = "NoMatchingVersionsError";
-	packageName;
-	selector;
-	available;
-	constructor(packageName, selector, available) {
-		const tail = available.slice(-5).join(", ");
-		super(`No published version of ${packageName} satisfies "${selector}".` + (tail.length > 0 ? ` Most recent published versions: ${tail}` : ""));
-		this.packageName = packageName;
-		this.selector = selector;
-		this.available = available;
-	}
-};
-/** The registry responded, but with something we cannot use. */
-var RegistryResponseError = class extends BundlerErrorBase {
-	_tag = "RegistryResponseError";
-	url;
-	status;
-	constructor(url, detail, options) {
-		super(`Unexpected response from ${url}: ${detail}`, options);
-		this.url = url;
-		this.status = options?.status;
-	}
-};
-/** 401/403 — almost always a missing or stale token in `.npmrc`. */
-var AuthenticationError = class extends BundlerErrorBase {
-	_tag = "AuthenticationError";
-	registry;
-	status;
-	constructor(registry, status, packageName) {
-		super(`Registry ${registry} rejected the request with HTTP ${status}` + (packageName ? ` while fetching "${packageName}"` : "") + `.\n  Add credentials to your .npmrc, e.g.\n    //${safeHost(registry)}/:_authToken=\${NPM_TOKEN}`);
-		this.registry = registry;
-		this.status = status;
-	}
-};
-/**
-* A downloaded tarball did not match the checksum the registry advertised.
-*
-* Never soft-fail this: a bundle is a supply-chain artifact and a corrupt or
-* substituted tarball is exactly what integrity checking exists to catch.
-*/
-var IntegrityError = class extends BundlerErrorBase {
-	_tag = "IntegrityError";
-	packageName;
-	version;
-	expected;
-	actual;
-	constructor(packageName, version, expected, actual) {
-		super(`Integrity check failed for ${packageName}@${version}.\n  expected: ${expected}\n  actual:   ${actual}\n  The download was discarded. This is either corruption in transit or a tampered artifact.`);
-		this.packageName = packageName;
-		this.version = version;
-		this.expected = expected;
-		this.actual = actual;
-	}
-};
-/** Something went wrong writing the `.tgz`. */
-var ArchiveError = class extends BundlerErrorBase {
-	_tag = "ArchiveError";
-	path;
-	constructor(path, detail, options) {
-		super(`Failed to create archive ${path}: ${detail}`, options);
-		this.path = path;
-	}
-};
-/** Something went wrong preparing or writing to the output directory. */
-var OutputError = class extends BundlerErrorBase {
-	_tag = "OutputError";
-	path;
-	constructor(path, detail, options) {
-		super(`Output error at ${path}: ${detail}`, options);
-		this.path = path;
-	}
-};
-const safeHost = (registry) => {
-	try {
-		const url = new URL(registry);
-		return url.host + url.pathname.replace(/\/+$/, "");
-	} catch {
-		return registry;
-	}
-};
-
-//#endregion
 //#region src/enums/artifact-kind.ts
 /** What a bundle run wrote to the output directory. */
 const ArtifactKind = {
@@ -764,49 +553,25 @@ const defaultBundleOptions = {
 var Registry = class extends Context.Service()("@packall/core/Registry") {};
 
 //#endregion
-//#region src/progress.ts
-/** Service tag for progress reporting. */
-var Progress = class extends Context.Service()("@packall/core/Progress") {};
-/** Emits an event to whichever reporter is installed. */
-const emit = (event) => Effect.gen(function* () {
-	yield* (yield* Progress).emit(event);
-});
-/**
-* Discards every event.
-*
-* The default for library consumers and for tests that do not care about
-* progress — silence should never require ceremony.
-*/
-const layerSilent = Layer.succeed(Progress)({ emit: () => Effect.void });
-/** Sends every event to a callback. Used by the CLI renderer. */
-const layerCallback = (onEvent) => Layer.succeed(Progress)({ emit: (event) => Effect.sync(() => onEvent(event)) });
+//#region src/integrity.ts
 /**
-* Accumulates every event into a `Ref`, for assertions.
+* The digests npm publishes, mapped to what `Crypto.digest` calls them.
 *
-* Returned as `{ layer, events }` so a test can provide the layer and then read
-* the transcript afterwards.
+* Doubles as the supported-algorithm list: an SRI token whose algorithm is not
+* a key here is one we cannot check, and is dropped during parsing.
 */
-const makeCollector = Effect.gen(function* () {
-	const ref = yield* Ref.make([]);
-	return {
-		layer: Layer.succeed(Progress)({ emit: (event) => Ref.update(ref, (events) => [...events, event]) }),
-		events: Ref.get(ref)
-	};
-});
-
-//#endregion
-//#region src/integrity.ts
-const SUPPORTED = new Set([
-	"sha512",
-	"sha384",
-	"sha256",
-	"sha1"
-]);
+const digestAlgorithmByName = {
+	sha512: "SHA-512",
+	sha384: "SHA-384",
+	sha256: "SHA-256",
+	sha1: "SHA-1"
+};
+const isSupported = (algorithm) => Object.hasOwn(digestAlgorithmByName, algorithm);
 /**
 * Parses an SRI string such as `sha512-abc...==`.
 *
 * npm permits several space-separated hashes; we keep every one we can verify
-* and ignore algorithms Node does not implement.
+* and ignore algorithms we cannot.
 */
 const parseIntegrity = (integrity) => {
 	const hashes = [];
@@ -816,7 +581,7 @@ const parseIntegrity = (integrity) => {
 		if (dash <= 0) continue;
 		const algorithm = token.slice(0, dash).toLowerCase();
 		const digest = token.slice(dash + 1);
-		if (!SUPPORTED.has(algorithm) || digest.length === 0) continue;
+		if (!isSupported(algorithm) || digest.length === 0) continue;
 		hashes.push({
 			algorithm,
 			digest
@@ -824,15 +589,26 @@ const parseIntegrity = (integrity) => {
 	}
 	return hashes;
 };
+const digestBytes = (data, algorithm) => Effect.gen(function* () {
+	return yield* (yield* Crypto.Crypto).digest(digestAlgorithmByName[algorithm], data);
+});
 /** Computes the base64 digest of some bytes under one algorithm. */
-const digestOf = (data, algorithm) => createHash(algorithm).update(data).digest("base64");
+const digestOf = (data, algorithm) => Effect.map(digestBytes(data, algorithm), Encoding.encodeBase64);
 /** Computes the hex digest of some bytes — the form legacy `shasum` uses. */
-const hexDigestOf = (data, algorithm) => createHash(algorithm).update(data).digest("hex");
-/** Constant-time comparison of two digest strings of equal length. */
+const hexDigestOf = (data, algorithm) => Effect.map(digestBytes(data, algorithm), Encoding.encodeHex);
+/**
+* Constant-time comparison of two digest strings.
+*
+* Written by hand rather than with `node:crypto`'s `timingSafeEqual`, which
+* needs `Buffer` and would pin this module to Node. Both digests here are
+* public knowledge, so the timing property is close to theatre — but it costs
+* four lines, and the alternative is explaining in a review why it was dropped.
+*/
 const digestsEqual = (a, b) => {
-	const left = Buffer.from(a);
-	const right = Buffer.from(b);
-	return left.length === right.length && timingSafeEqual(left, right);
+	if (a.length !== b.length) return false;
+	let difference = 0;
+	for (let index = 0; index < a.length; index++) difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+	return difference === 0;
 };
 /**
 * Checks bytes against whichever checksums the registry supplied.
@@ -842,14 +618,14 @@ const digestsEqual = (a, b) => {
 * as `Unverifiable` rather than silently treated as a pass — the caller decides
 * whether to tolerate it.
 */
-const verify = (data, dist) => {
+const verify = (data, dist) => Effect.gen(function* () {
 	if (dist.integrity !== void 0 && dist.integrity.length > 0) {
-		const [best] = parseIntegrity(dist.integrity).toSorted((a, b) => strength(b.algorithm) - strength(a.algorithm));
+		const [best] = parseIntegrity(dist.integrity).toSorted((a, b) => strengthByAlgorithm[b.algorithm] - strengthByAlgorithm[a.algorithm]);
 		if (best === void 0) return {
 			_tag: "Unverifiable",
 			reason: `no supported algorithm in "${dist.integrity}"`
 		};
-		const actual = digestOf(data, best.algorithm);
+		const actual = yield* digestOf(data, best.algorithm);
 		return digestsEqual(actual, best.digest) ? {
 			_tag: "Verified",
 			using: best.algorithm
@@ -860,7 +636,7 @@ const verify = (data, dist) => {
 		};
 	}
 	if (dist.shasum !== void 0 && dist.shasum.length > 0) {
-		const actual = hexDigestOf(data, "sha1");
+		const actual = yield* hexDigestOf(data, "sha1");
 		return digestsEqual(actual.toLowerCase(), dist.shasum.toLowerCase()) ? {
 			_tag: "Verified",
 			using: "sha1"
@@ -874,14 +650,12 @@ const verify = (data, dist) => {
 		_tag: "Unverifiable",
 		reason: "registry advertised no integrity or shasum"
 	};
-};
-const strength = (algorithm) => {
-	switch (algorithm) {
-		case "sha512": return 4;
-		case "sha384": return 3;
-		case "sha256": return 2;
-		default: return 1;
-	}
+});
+const strengthByAlgorithm = {
+	sha512: 4,
+	sha384: 3,
+	sha256: 2,
+	sha1: 1
 };
 
 //#endregion
@@ -895,10 +669,12 @@ const strength = (algorithm) => {
 *     @babel/core/-/core-7.24.0.tgz
 *
 * That is not an Artifactory convention — it is the path structure in every
-* `dist.tarball` URL npm publishes, which is why the same tree imports into
-* Artifactory, Nexus and Verdaccio without translation. Note that a scoped
-* package's file name drops the scope: `@babel/core` becomes `core-7.24.0.tgz`
-* under an `@babel/core/-/` directory.
+* `dist.tarball` URL npm publishes. See `notes/requirements.md` § FR-12 for
+* what that buys.
+*
+* The one shape worth noticing before editing anything here: a scoped
+* package's file name drops the scope, so `@babel/core` becomes
+* `core-7.24.0.tgz` under an `@babel/core/-/` directory.
 */
 /** Splits `@scope/name` into its parts. `scope` is undefined when unscoped. */
 const splitName = (name) => {
@@ -934,13 +710,45 @@ const README_FILE = "IMPORT.md";
 /**
 * Name of the archive produced for one root spec in `per-spec` layout.
 *
-* Scoped names are flattened (`@babel/core` -> `babel-core`) because a `/` in a
-* file name is not a thing, and `@` confuses enough shells and web UIs to be
-* worth avoiding.
+* It is the spec, with the one character a file name cannot hold taken out:
+* `@types/react@19.2.18` becomes `@types-react@19.2.18.tgz`. So the name of the
+* file answers the question somebody has when they are looking at a directory
+* of them — which package, and which version — in the notation they would have
+* typed to ask for it.
+*
+* The version is joined with `@` rather than `-` for the same reason. A
+* hyphen made `foo-bar-1.0.0` ambiguous by eye: package `foo` at `bar-1.0.0`,
+* or `foo-bar` at `1.0.0`? npm's own syntax has no such problem, because a
+* package name may not contain `@` beyond its scope.
+*
+* **The scope's `@` stays**, and it is the difference between a correct bundle
+* and a quietly incomplete one.
+*
+* Dropping it — which this did, matching what `npm pack` produces — meant
+* `@something/somewhat` and `something-somewhat` were both
+* `something-somewhat-1.0.0.tgz`. Two different packages, one path: the second
+* landed on the first, and the run reported two artifacts for the one file that
+* survived. A bundle short a package, called complete, found at the far end of
+* an air gap.
+*
+* Keeping the `@` makes that impossible by construction rather than by a check,
+* because an unscoped npm name may not begin with one. It is also the more
+* honest name: the scope is part of what the package *is*, and a directory of
+* archives that has forgotten which ones were scoped is a directory somebody
+* has to cross-reference against a manifest.
+*
+* It does not make every collision impossible — `@a/b-c` and `@a-b/c` still
+* meet — so `assertDistinctOutputs` still runs. That pair is pathological; the
+* scoped-against-unscoped one is `@babel/core` beside `babel-core`, which is a
+* real migration somebody could be bundling.
+*
+* The leading `@` is safe here in a way it is not inside the archive: tar's
+* splice convention applies to the *file list* it is given, which is what
+* `archive.ts` guards with `./`. This is the output path, not an entry.
 */
 const perSpecArchiveName = (name, version) => {
 	const { scope, bare } = splitName(name);
-	return `${scope === void 0 ? bare : `${scope.slice(1)}-${bare}`}-${version}.tgz`;
+	return `${scope === void 0 ? bare : `${scope}-${bare}`}@${version}.tgz`;
 };
 /** Name of the archive produced in `single` layout. */
 const singleArchiveName = (base = "bundle") => `${base}.tgz`;
@@ -2545,66 +2353,6 @@ const formatSpecErrors = (errors, rawLines) => {
 };
 const describeError = (error) => error instanceof Error ? error.message : String(error);
 
-//#endregion
-//#region src/archive.ts
-/**
-* Packs `entries` (paths relative to `cwd`) into a gzipped tar at `outPath`.
-*
-* `portable` normalises uid/gid/mtime so the same inputs produce byte-identical
-* output — which matters when a security team wants to diff two bundles or
-* re-derive one from a manifest.
-*/
-const createArchive = (options) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	yield* emit({
-		_tag: "ArchiveStarted",
-		path: options.outPath,
-		entryCount: options.entries.length
-	});
-	yield* Effect.tryPromise({
-		try: () => create({
-			gzip: options.gzipLevel === void 0 ? true : { level: options.gzipLevel },
-			file: options.outPath,
-			cwd: options.cwd,
-			portable: true,
-			onWriteEntry: (entry) => {
-				entry.path = entry.path.replace(/^\.\//, "");
-			}
-		}, options.entries.toSorted().map(dotSlash)),
-		catch: (cause) => new ArchiveError(options.outPath, describe(cause), { cause })
-	});
-	const info = yield* fs.stat(options.outPath);
-	const bytes = Number(info.size);
-	yield* emit({
-		_tag: "ArchiveCompleted",
-		path: options.outPath,
-		bytes
-	});
-	return {
-		path: options.outPath,
-		bytes
-	};
-});
-/**
-* Guards every entry against tar's `@` convention.
-*
-* In a tar file list, a leading `@` means "splice in the entries of this other
-* archive" — a GNU convention `node-tar` implements by stripping the `@` and
-* looking for what is left. Every scoped package is a top-level entry starting
-* with `@`, so this hit the bundler in both possible ways:
-*
-* - `@oxc-project` became `oxc-project`, which does not exist, and the run died
-*   with an ENOENT naming a path that appears nowhere in the staging tree.
-* - `@esbuild` became `esbuild`, which *does* exist — the unscoped package of
-*   the same name sitting right next to it. No error, and every scoped tarball
-*   silently missing from a bundle that reported success. That is the dangerous
-*   one: you would not find out until the install failed behind the firewall.
-*
-* `./@scope` is not subject to the convention and resolves identically.
-*/
-const dotSlash = (entry) => entry.startsWith("./") ? entry : `./${entry}`;
-const describe = (cause) => cause instanceof Error ? cause.message : String(cause);
-
 //#endregion
 //#region src/download.ts
 /**
@@ -2635,7 +2383,7 @@ const downloadAll = (packages, destDir, options) => Effect.gen(function* () {
 		});
 		const bytes = yield* registry.download(pkg.manifest);
 		if (options.verifyIntegrity) {
-			const result = verify(bytes, pkg.manifest.dist);
+			const result = yield* verify(bytes, pkg.manifest.dist);
 			if (result._tag === "Mismatch") return yield* Effect.fail(new IntegrityError(pkg.name, pkg.version, result.expected, result.actual));
 			if (result._tag === "Unverifiable") yield* emit({
 				_tag: "Warning",
@@ -2679,11 +2427,44 @@ const downloadAll = (packages, destDir, options) => Effect.gen(function* () {
 
 //#endregion
 //#region src/bundle.ts
+/**
+* The archives `per-spec` emits — one per distinct root package version.
+*
+* Roots are *specs*, and several specs can name one package: `react`,
+* `react@latest` and `react@19.2.8` are three ways of asking for the same
+* thing, and after resolution they are indistinguishable. Without this they
+* were three archives — the same bytes, under the same file name, written over
+* each other. The run then reported three artifacts and three times the size
+* for one file on disk, and the duplication ratio it computes to decide whether
+* to ask about the layout counted them too, so the tool would offer to
+* deduplicate a bundle it had duplicated itself.
+*
+* Keyed by name and version rather than by the archive's file name. A scoped
+* name is flattened to make a file name, so `@foo/bar` and `foo-bar` can spell
+* the same one — and those are two different packages, which should collide
+* loudly rather than being merged here.
+*
+* Roots only. The packages *inside* an archive were deduplicated by resolution
+* long before this, which is why the same closure fetched from twenty specs is
+* fetched once.
+*/
+const perSpecTargets = (resolution) => {
+	const seen = /* @__PURE__ */ new Set();
+	return resolution.roots.flatMap((root) => root.versions.flatMap((version) => {
+		const key = `${root.spec.name}@${version}`;
+		if (seen.has(key)) return [];
+		seen.add(key);
+		return {
+			root,
+			version
+		};
+	}));
+};
 /** Computes the plan summary for a resolution. */
 const summarize = (resolution) => {
 	let perSpecArchives = 0;
 	let perSpecEntries = 0;
-	for (const root of resolution.roots) for (const version of root.versions) {
+	for (const { root, version } of perSpecTargets(resolution)) {
 		perSpecArchives += 1;
 		perSpecEntries += (root.closures.get(version) ?? []).length;
 	}
@@ -2775,11 +2556,11 @@ const bundleResolved = (resolution, options) => Effect.gen(function* () {
 const plannedOutputs = (resolution, options) => {
 	if (options.layout === Layout.Dir) return [{ file: MANIFEST_FILE }, { file: README_FILE }];
 	if (options.layout === Layout.Single) return [{ file: singleArchiveName(options.archiveName ?? "bundle") }];
-	return resolution.roots.flatMap((root) => root.versions.map((version) => ({
+	return perSpecTargets(resolution).map(({ root, version }) => ({
 		file: perSpecArchiveName(root.spec.name, version),
 		name: root.spec.name,
 		version
-	})));
+	}));
 };
 const runBundle = (resolution, options) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -2889,7 +2670,7 @@ const emitPerSpec = (input, staging) => Effect.gen(function* () {
 	const index = indexPackages(input.resolution);
 	const artifacts = [];
 	let counter = 0;
-	for (const root of input.resolution.roots) for (const version of root.versions) {
+	for (const { root, version } of perSpecTargets(input.resolution)) {
 		if (input.options.skipExisting?.has(perSpecArchiveName(root.spec.name, version)) === true) continue;
 		const included = includedPackages(index, root.closures.get(version) ?? []);
 		const rootDir = path.join(staging, "roots", String(counter++));
@@ -2970,6 +2751,48 @@ const topLevelEntries = (dir) => Effect.gen(function* () {
 	return (yield* (yield* FileSystem.FileSystem).readDirectory(dir)).toSorted();
 });
 /**
+* Two different packages must not want the same file name.
+*
+* Most of what this used to catch is now impossible: an archive is named for
+* the spec, `@types-react@19.2.18.tgz`, and an unscoped npm name may not begin
+* with `@`, so it cannot spell a scoped one. What survives is **two scoped
+* packages whose scope boundary falls in a different place**, because that
+* boundary is the one character the file name drops:
+*
+*     @a/b-c  ->  @a-b-c@1.0.0.tgz
+*     @a-b/c  ->  @a-b-c@1.0.0.tgz
+*
+* Pathological rather than plausible — it needs somebody to hold the `@a-b`
+* scope as well as `@a`, and both packages in one run at one version. It is
+* kept anyway because of what it costs to be wrong: they are *different
+* packages*, so deduplicating them would be wrong, and writing both is worse —
+* the second lands on the first and the run reports two artifacts for the one
+* file that survived. A bundle short a package, called complete, found at the
+* far end of an air gap by somebody who cannot go and fetch the missing one.
+*
+* Nothing else would catch it. The overwrite check below compares this run's
+* planned files against what is *already on disk*, and both of these are new.
+*
+* So it refuses, and names both specs. Not silently renamed: an archive whose
+* name nobody chose is a file somebody has to identify later.
+*
+* Unconditional, unlike the overwrite check: `--force` is permission to replace
+* what was already in the directory, not to let one run overwrite itself.
+*/
+const assertDistinctOutputs = (resolution, options) => Effect.gen(function* () {
+	const owners = /* @__PURE__ */ new Map();
+	for (const planned of plannedOutputs(resolution, options)) {
+		const claimed = owners.get(planned.file);
+		const spec = planned.name === void 0 ? planned.file : `${planned.name}@${planned.version}`;
+		if (claimed === void 0) owners.set(planned.file, [spec]);
+		else claimed.push(spec);
+	}
+	const collisions = [...owners].filter(([, specs]) => specs.length > 1);
+	if (collisions.length === 0) return;
+	const described = collisions.map(([file, specs]) => `${specs.join(" and ")} would both be ${file}`).join("; ");
+	return yield* Effect.fail(new OutputError(options.outDir, `two packages want the same archive name — ${described}. The \`/\` in a scope becomes a \`-\` to make a file name, so \`@a/b-c\` and \`@a-b/c\` meet. Use --layout single, or bundle them into separate --out directories.`));
+});
+/**
 * Fails if the run would overwrite something, unless `--force`.
 *
 * The guard is on the *files this run writes*, not on whether the directory has
@@ -2979,12 +2802,14 @@ const topLevelEntries = (dir) => Effect.gen(function* () {
 * default `.` unusable.
 *
 * Checked before anything is downloaded. Discovering the collision *after* a
-* twenty-minute download would be a uniquely irritating way to fail.
+* twenty-minute download would be a uniquely irritating way to fail — which is
+* also why `assertDistinctOutputs` runs from here rather than at emit time.
 */
 const prepareOutputDir = (resolution, options) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const outDir = options.outDir;
+	yield* assertDistinctOutputs(resolution, options);
 	if (!options.force) {
 		const clashes = [];
 		for (const planned of plannedOutputs(resolution, options)) {
@@ -2998,5 +2823,5 @@ const prepareOutputDir = (resolution, options) => Effect.gen(function* () {
 });
 
 //#endregion
-export { ArchiveError, ArtifactKind, AuthenticationError, DirectOnlyKind, EdgeKind, InputFileKind, IntegrityError, InvalidInputFileError, InvalidSpecError, Layout, Layouts, LockedRootKind, LockfileError, LockfileFormat, LockfileIncompleteError, LockfileOutOfDateError, MANIFEST_FILE, MANIFEST_VERSION, NoMatchingVersionsError, OptionalFlagRecordOrAbsentSchema, OptionalFlagRecordSchema, OptionalStringArraySchema, OptionalStringRecordSchema, OutputError, PackageNotFoundError, Phase, Progress, README_FILE, Registry, RegistryResponseError, RegistryUnreachableError, StringArraySchema, StringRecordSchema, VersionNotFoundError, allPlatforms, buildManifest, bundle, bundleLocked, bundleResolved, currentPlatform, dedupeSpecs, defaultBundleOptions, defaultInputFileOptions, defaultResolveOptions, defaultScope, detectLockfile, digestOf, emit as emitProgress, formatByLockfileName, formatPlatformFilter, formatSelector, formatSpec, hexDigestOf, importGuide, indexPackages, isIncluded, isRecord, layerCallback as layerCallbackProgress, layerSilent as layerSilentProgress, lockfileNamesFor, makeCollector as makeProgressCollector, packageKey, packagePath, parseDependencyTarget, parseInputFile, parseIntegrity, parseLockfile, parsePlatformTarget, parseSpec, parseSpecs, perSpecArchiveName, plan, planLocked, plannedOutputs, platformTargets, readInputFile, resolve, resolveLocked, selectVersions, serializeManifest, singleArchiveName, splitName, summarize, tarballFileName, tolerant, verify as verifyIntegrity, withLayout };
+export { ArchiveError, Archiver, ArtifactKind, AuthenticationError, DirectOnlyKind, EdgeKind, InputFileKind, IntegrityError, InvalidInputFileError, InvalidSpecError, Layout, Layouts, LockedRootKind, LockfileError, LockfileFormat, LockfileIncompleteError, LockfileOutOfDateError, MANIFEST_FILE, MANIFEST_VERSION, NoMatchingVersionsError, OptionalFlagRecordOrAbsentSchema, OptionalFlagRecordSchema, OptionalStringArraySchema, OptionalStringRecordSchema, OutputError, PackageNotFoundError, Phase, Progress, README_FILE, Registry, RegistryResponseError, RegistryUnreachableError, StringArraySchema, StringRecordSchema, VersionNotFoundError, allPlatforms, buildManifest, bundle, bundleLocked, bundleResolved, createArchive, currentPlatform, dedupeSpecs, defaultBundleOptions, defaultInputFileOptions, defaultResolveOptions, defaultScope, detectLockfile, digestOf, emit as emitProgress, formatByLockfileName, formatPlatformFilter, formatSelector, formatSpec, hexDigestOf, importGuide, indexPackages, isIncluded, isRecord, layerCallback as layerCallbackProgress, layerSilent as layerSilentProgress, lockfileNamesFor, makeCollector as makeProgressCollector, packageKey, packagePath, parseDependencyTarget, parseInputFile, parseIntegrity, parseLockfile, parsePlatformTarget, parseSpec, parseSpecs, perSpecArchiveName, plan, planLocked, plannedOutputs, platformTargets, readInputFile, resolve, resolveLocked, selectVersions, serializeManifest, singleArchiveName, splitName, summarize, tarballFileName, tolerant, verify as verifyIntegrity, withLayout };
 //# sourceMappingURL=index.js.map