@medicomind/rolldown-compression 2.3.5 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @medicomind/rolldown-compression
 
+## 2.4.0
+
+### Minor Changes
+
+- [`7731f9d`](https://github.com/Medico-Mind/rolldown-compression/commit/7731f9d48a0f98ec4b8f1e75f30729bceb8be5bf) Thanks [@Mnwa](https://github.com/Mnwa)! - Follow the Rolldown plugin conventions and harden asset handling.
+  
+  - The plugin is now named `rolldown-plugin-compression` (was `rolldown-compression`), as the [plugin conventions](https://rolldown.rs/apis/plugin-api#conventions) ask for. It also reports `version` and `meta.packageName`, and exposes an `api` (`algorithms`, `extensions`, `emittedFileNames()`) for inter-plugin communication.
+  - `deleteOriginalAssets` no longer removes an asset that ended up without a compressed variant — a file skipped by `skipIfLargerOrEqual` used to be deleted with nothing to replace it. Removing a chunk now logs a warning once, since only the compressed name is left on disk.
+  - Artifact names resolved from `filename` are validated: names that escape the output directory, are absolute, collide with another artifact of the same build, or would overwrite a file the build already owns now fail the build instead of silently clobbering.
+  - In stream mode `deleteOriginalAssets` now only unlinks files the build actually wrote — those the bundle declares, or those written while the output was being generated. A leftover from an earlier build in an output directory that was not emptied still gets compressed, but is no longer deleted.
+  - Per-output state is reset in `renderStart`, so with multiple outputs one output's artifacts no longer shadow another output's sources, and watch-mode rebuilds no longer accumulate it.
+  - Per-file detail (`skipped …`) moved from `this.info` to `this.debug`; the build summary stays on `this.info`.
+  - Assets no longer cross into the native module through a duplicated `Buffer`, and stream mode reads each batch's files concurrently instead of one at a time.
+
+### Patch Changes
+
+- [`0b10197`](https://github.com/Medico-Mind/rolldown-compression/commit/0b10197902c3278d9ba9dfe3dec7891fc8ff110f) Thanks [@Mnwa](https://github.com/Mnwa)! - Update simd-brotli to v10, speeding up brotli compression. On a 36 MB production-shaped bundle corpus (62 files): quality 11 is ~5% faster (7518ms -> 7143ms) and quality 6 ~3% faster (111ms -> 108ms), with byte-identical output.
+
+- [`97b67df`](https://github.com/Medico-Mind/rolldown-compression/commit/97b67df90db45e7b93605594616abe9b47773939) Thanks [@Mnwa](https://github.com/Mnwa)! - Remove the `@rollup/pluginutils` runtime dependency and use Node.js `path.matchesGlob` for include and exclude glob matching.
+
+- [`97571e9`](https://github.com/Medico-Mind/rolldown-compression/commit/97571e990720f135b3fa8c809bca9af831d18419) Thanks [@Mnwa](https://github.com/Mnwa)! - Route plugin messages through Rolldown's logging context instead of writing directly to the console.
+
+## 2.3.6
+
+### Patch Changes
+
+- [#36](https://github.com/Medico-Mind/rolldown-compression/pull/36) [`0b67e41`](https://github.com/Medico-Mind/rolldown-compression/commit/0b67e41be90e4ae8adfe9c6232e5b1be7ef29cc2) Thanks [@Mnwa](https://github.com/Mnwa)! - Reuse Brotli encoder allocations through a process-wide cache to reduce allocation count and volume across concurrent compression jobs.
+
 ## 2.3.5
 
 ### Patch Changes

package/README.md

@@ -82,17 +82,17 @@ export default defineConfig({
 
 | option                 | type                                            | default                                                                 | description                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 |------------------------|-------------------------------------------------|-------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `include`              | `string \| RegExp \| Array<string \| RegExp>`   | `/\.(html\|xml\|css\|json\|js\|mjs\|svg\|yaml\|yml\|toml\|txt\|wasm)$/` | Files to compress. Strings are [picomatch](https://github.com/micromatch/picomatch) globs, matched against bundle-relative file names ([`@rollup/pluginutils` `createFilter`](https://github.com/rollup/plugins/tree/master/packages/pluginutils#createfilter) semantics).                                                                                                                                                                                             |
+| `include`              | `string \| RegExp \| Array<string \| RegExp>`   | `/\.(html\|xml\|css\|json\|js\|mjs\|svg\|yaml\|yml\|toml\|txt\|wasm)$/` | Files to compress. Strings are [`path.matchesGlob`](https://nodejs.org/api/path.html#pathmatchesglobpath-pattern) patterns matched against bundle-relative file names. Source maps (`*.map`) are **not** covered by the default — add `/\.map$/` if you serve them pre-compressed.                                                                                                                                                                                                                                                                                                   |
 | `exclude`              | `string \| RegExp \| Array<string \| RegExp>`   | —                                                                       | Files to skip. **Wins over `include`.**                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `threshold`            | `number`                                        | `0`                                                                     | Minimum original size in bytes for a file to be compressed.                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `algorithms`           | `Array<AlgorithmName \| DefineAlgorithmResult>` | `['gzip', 'brotli']`                                                    | Algorithms to run. Aliases `gz`, `br`, `brotliCompress`, `zstandard` normalize to `gzip` / `brotli` / `zstd`.                                                                                                                                                                                                                                                                                                                                                          |
-| `filename`             | `string \| (fileName, algorithm) => string`     | `'[path][base]' + ext`                                                  | Name of the emitted artifact. Tokens: `[path]` (directory incl. trailing `/`), `[base]`, `[name]`, `[ext]` (with dot), `[hash]` (8-char sha256 of the content). Default extensions: `.gz`, `.br`, `.zst`.                                                                                                                                                                                                                                                              |
-| `deleteOriginalAssets` | `boolean`                                       | `false`                                                                 | Remove the original from the bundle after all algorithms processed it. Errors if `filename` resolves to the source name.                                                                                                                                                                                                                                                                                                                                               |
+| `filename`             | `string \| (fileName, algorithm) => string`     | `'[path][base]' + ext`                                                  | Name of the emitted artifact. Tokens: `[path]` (directory incl. trailing `/`), `[base]`, `[name]`, `[ext]` (with dot), `[hash]` (8-char sha256 of the **original**, uncompressed bytes). Default extensions: `.gz`, `.br`, `.zst`. The result must be a relative path inside the output directory, must differ from the source name, and must be unique across the build — anything else fails the build.                                                                                                                                                                                                                                                              |
+| `deleteOriginalAssets` | `boolean`                                       | `false`                                                                 | Remove the original once **every** algorithm produced a variant of it. Files with no variant (e.g. skipped by `skipIfLargerOrEqual`) are always kept, so this can never leave the build without a servable copy. Removing chunks logs a warning — see [deleting originals](#deleting-originals).                                                                                                                                                                                                                                                                                                                                               |
 | `skipIfLargerOrEqual`  | `boolean`                                       | `true`                                                                  | Don't emit artifacts whose compressed size is `>=` the original.                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `concurrency`          | `number`                                        | `0`                                                                     | Native worker threads. `0` = number of logical CPUs.                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `chunkSize`            | `number`                                        | `0`                                                                     | Max source bytes buffered per native compression batch. `0` = one batch for the whole build. A positive value (e.g. `64 * 1024 * 1024`) caps the plugin's peak memory overhead at roughly one batch of source copies plus its compressed outputs; a single file larger than `chunkSize` still forms its own batch. The bundler keeps the original bundle in memory regardless. In [stream mode](#stream-mode) `0` falls back to a 4 MB batch instead of one big batch. |
 | `stream`               | `boolean`                                       | `false`                                                                 | Compress from disk in `writeBundle` (order `post`) instead of in memory in `generateBundle`: files are read on demand in bounded batches (`chunkSize` bytes, default 4 MB), and assets written to disk by other plugins' `writeBundle` hooks are compressed too (see [stream mode](#stream-mode)).                                                                                                                                                                     |
-| `logLevel`             | `'silent' \| 'error' \| 'warn' \| 'info'`       | `'info'`                                                                | Plugin log verbosity; `info` prints a per-algorithm summary at build end.                                                                                                                                                                                                                                                                                                                                                                                              |
+| `logLevel`             | `'silent' \| 'error' \| 'warn' \| 'info'`       | `'info'`                                                                | Plugin log verbosity. `info` prints the per-algorithm summary through `this.info` and per-file detail through `this.debug`, so the bundler's own log level decides whether the detail is shown; `warn` keeps only warnings.                                                                                                                                                                                                                                                                                                                                                                                              |
 | `enableInWatchMode`    | `boolean`                                       | `false`                                                                 | The plugin is a no-op in watch/dev mode unless enabled (see [watch mode](#watch--dev-mode)).                                                                                                                                                                                                                                                                                                                                                                           |
 
 All options are validated when `compression()` is called — invalid levels (e.g. brotli quality 12), unknown algorithm names or malformed filters throw immediately, not mid-build.
@@ -128,6 +128,8 @@ The size penalty depends entirely on how far apart your content's repetitions ar
 - Buffers cross the FFI boundary without base64/string round-trips, and the compression working set lives in native memory — a 500 MB asset does not pressure the JS heap.
 - A failing task never aborts the batch: per-task errors are aggregated and fail the build with one message.
 - Already-compressed artifacts (`.gz`, `.br`, `.zst` — ours or pre-existing) are never re-compressed, so chaining plugin instances can't produce `app.js.gz.br`.
+- Artifact names are checked before anything is written: a name that escapes the output directory, collides with another artifact of the same build, or overwrites a file the build already owns fails the build instead of silently clobbering it.
+- Rolldown runs the output hooks once per output, so per-output state is reset in `renderStart` — one output's artifacts never shadow another output's sources, and watch-mode rebuilds don't accumulate state.
 
 Limitation of the default mode: assets written to disk by other plugins in `writeBundle`/`closeBundle` (i.e. after `generateBundle`) are not seen. This matches how `vite-plugin-compression2` handles the in-bundle pass. Set `stream: true` to remove it.
 
@@ -144,9 +146,38 @@ compression({
 
 - The output directory is scanned recursively and matching files are read **on demand**, never all at once: a batch is flushed to the native module whenever it reaches `chunkSize` source bytes, defaulting to **4 MB** when `chunkSize` is `0`. Peak memory overhead is one batch of sources plus its compressed outputs, regardless of build size.
 - Compressed artifacts are written straight to the output directory (`emitFile` is not available after write); `deleteOriginalAssets` unlinks the originals from disk.
-- The same filter, threshold and re-compression guards apply, and everything already in the output directory that matches them is compressed — including files produced by other plugins after `generateBundle`, the default mode's limitation. Assets written in `closeBundle` (after all `writeBundle` hooks) are still not seen.
+- The same filter, threshold and re-compression guards apply, and everything in the output directory that matches them is compressed — including files produced by other plugins after `generateBundle`, the default mode's limitation. Assets written in `closeBundle` (after all `writeBundle` hooks) are still not seen.
+- `deleteOriginalAssets` is deliberately narrower than that: it only unlinks files the build actually wrote — those the bundle declares, or those written while the output was being generated. A leftover from an earlier build in a directory that was not emptied gets compressed but never deleted, because deleting a file the build did not produce is not something a compression plugin can undo.
 - Trade-off: files the bundler already had in memory are re-read from disk, and per-batch FFI calls replace the single big batch — for small builds the default in-memory mode is faster.
 
+### Deleting originals
+
+`deleteOriginalAssets: true` removes an original only once a compressed variant of it exists. Anything the compressor skipped — incompressible binaries, files under a codec's break-even point — stays in place, and the plugin says which ones it kept. In [stream mode](#stream-mode) it additionally only touches files the build itself wrote.
+
+Removing **chunks** (JS/CSS) is a deployment decision, not just a bundling one: only the compressed name is left on disk, so requests resolve only if whatever serves the build rewrites the original path to the compressed variant. Dynamic imports and source map links still use the original names. The plugin warns once per process the first time it removes a chunk.
+
+### Plugin identity and `api`
+
+The plugin follows the rolldown [plugin conventions](https://rolldown.rs/apis/plugin-api#conventions): it is named `rolldown-plugin-compression` and reports the package it ships in, so tooling that inspects a build can attribute it.
+
+```ts
+const plugin = compression()
+plugin.name             // 'rolldown-plugin-compression'
+plugin.version          // the package version
+plugin.meta?.packageName // '@medicomind/rolldown-compression'
+```
+
+Other plugins can read its `api` through the documented [inter-plugin communication](https://rolldown.rs/apis/plugin-api/inter-plugin-communication) channel — useful for, say, a middleware that serves the artifacts:
+
+```ts
+interface CompressionPluginApi {
+  packageName: string
+  algorithms: readonly ('gzip' | 'brotli' | 'zstd')[]
+  extensions: readonly string[]          // '.gz', '.br', '.zst'
+  emittedFileNames(): string[]           // artifacts of the latest output
+}
+```
+
 ### Watch / dev mode
 
 The plugin declares `apply: 'build'` (honored by Vite / `rolldown-vite`) **and** checks `this.meta.watchMode` at `generateBundle` time, making it a no-op under `rolldown --watch`. Set `enableInWatchMode: true` to compress in watch builds anyway.

package/dist/index.cjs

@@ -24,7 +24,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = __toESM(node_path);
-let _rollup_pluginutils = require("@rollup/pluginutils");
 let node_fs_promises = require("node:fs/promises");
 let node_module = require("node:module");
 //#region ts/options.ts
@@ -65,6 +64,25 @@ const LOG_LEVELS = [
 	"warn",
 	"info"
 ];
+function toArray(patterns) {
+	if (patterns === void 0) return [];
+	return Array.isArray(patterns) ? patterns : [patterns];
+}
+function createFilter(include, exclude) {
+	const includes = toArray(include);
+	const excludes = toArray(exclude);
+	const matches = (fileName, pattern) => {
+		if (typeof pattern === "string") return node_path.default.matchesGlob(fileName, pattern);
+		pattern.lastIndex = 0;
+		return pattern.test(fileName);
+	};
+	return (fileName) => {
+		if (typeof fileName !== "string" || fileName.includes("\0")) return false;
+		const normalizedFileName = fileName.replaceAll("\\", "/");
+		if (excludes.some((pattern) => matches(normalizedFileName, pattern))) return false;
+		return includes.length === 0 || includes.some((pattern) => matches(normalizedFileName, pattern));
+	};
+}
 /** File extensions produced by this plugin; used by the re-compression guard. */
 const COMPRESSED_EXTENSION_RE = /\.(gz|br|zst)$/i;
 var OptionValidationError = class extends Error {
@@ -138,7 +156,7 @@ function resolveOptions(options = {}) {
 	if (filename !== void 0 && typeof filename !== "string" && typeof filename !== "function") throw new OptionValidationError("invalid filename: expected a string pattern or a function");
 	if (!Array.isArray(algorithms) || algorithms.length === 0) throw new OptionValidationError("invalid algorithms: expected a non-empty array");
 	return {
-		filter: (0, _rollup_pluginutils.createFilter)(include, exclude, { resolve: false }),
+		filter: createFilter(include, exclude),
 		threshold,
 		algorithms: algorithms.map(resolveAlgorithm),
 		filename,
@@ -152,9 +170,46 @@ function resolveOptions(options = {}) {
 	};
 }
 /**
+* Validate a resolved artifact name before anything is emitted or written.
+*
+* A `filename` function is arbitrary user code, so its result is checked the
+* same way a path from outside would be: it has to stay inside the output
+* directory and must not claim the name of the asset it was derived from.
+* Returns the normalized name to use, or the reason it was rejected.
+*/
+function checkArtifactName(outputFileName, sourceFileName, algorithm) {
+	const context = `the filename option resolved "${sourceFileName}" (${algorithm})`;
+	if (typeof outputFileName !== "string" || outputFileName.length === 0) return {
+		ok: false,
+		message: `${context} to ${JSON.stringify(outputFileName)}; expected a non-empty file name relative to the output directory`
+	};
+	if (outputFileName.includes("\0")) return {
+		ok: false,
+		message: `${context} to a name containing a NUL byte`
+	};
+	const normalized = node_path.default.posix.normalize(outputFileName.replaceAll("\\", "/"));
+	if (node_path.default.posix.isAbsolute(normalized) || /^[a-zA-Z]:/.test(normalized)) return {
+		ok: false,
+		message: `${context} to the absolute path "${outputFileName}"; expected a path relative to the output directory`
+	};
+	if (normalized === ".." || normalized.startsWith("../") || normalized.endsWith("/")) return {
+		ok: false,
+		message: `${context} to "${outputFileName}", which does not name a file inside the output directory`
+	};
+	if (normalized === sourceFileName) return {
+		ok: false,
+		message: `${context} to the same name as the source asset; refusing to overwrite it`
+	};
+	return {
+		ok: true,
+		fileName: normalized
+	};
+}
+/**
 * Resolve the emitted file name for a compressed artifact.
 *
-* Supported tokens: `[path]`, `[base]`, `[name]`, `[ext]`, `[hash]`.
+* Supported tokens: `[path]`, `[base]`, `[name]`, `[ext]`, `[hash]`. The
+* result is not validated here — see {@link checkArtifactName}.
 */
 function resolveOutputFileName(filename, fileName, algorithm, source) {
 	if (typeof filename === "function") return filename(fileName, algorithm.algorithm);
@@ -189,49 +244,69 @@ const compressBuffers = (0, node_module.createRequire)(require("url").pathToFile
 * {@link STREAM_DEFAULT_CHUNK_SIZE} when `chunkSize` is 0 — so the whole
 * build is never held in memory and assets written to disk by other
 * plugins' `writeBundle` hooks are compressed as well.
+*
+* Rolldown runs the output hooks once per output, so the per-output state
+* below is reset in `renderStart` rather than shared across a whole build.
 */
-const PLUGIN_NAME = "rolldown-compression";
+/**
+* Rolldown asks plugins to be named with a `rolldown-plugin-` prefix so they
+* are recognizable in logs, errors and hook traces.
+*/
+const PLUGIN_NAME = "rolldown-plugin-compression";
+const PACKAGE_NAME = "@medicomind/rolldown-compression";
 /** Source bytes per batch in stream mode when `chunkSize` is 0. */
 const STREAM_DEFAULT_CHUNK_SIZE = 4194304;
-const LOG_PRIORITY = {
-	silent: 0,
-	error: 1,
-	warn: 2,
-	info: 3
-};
-function createLogger(level) {
-	const priority = LOG_PRIORITY[level];
-	const prefix = `[${PLUGIN_NAME}]`;
-	return {
-		info: (message) => {
-			if (priority >= LOG_PRIORITY.info) console.info(`${prefix} ${message}`);
-		},
-		warn: (message) => {
-			if (priority >= LOG_PRIORITY.warn) console.warn(`${prefix} ${message}`);
-		},
-		error: (message) => {
-			if (priority >= LOG_PRIORITY.error) console.error(`${prefix} ${message}`);
-		}
-	};
+/**
+* Slack applied when deciding whether a file on disk was written by the
+* current output. Some filesystems store mtimes at one-second granularity,
+* and the wall clock can drift against them, so a strict comparison would
+* occasionally misread a file the build had just produced as a leftover.
+*/
+const MTIME_SLACK_MS = 2e3;
+/** Concurrent `stat` calls while scanning the output directory. */
+const STAT_CONCURRENCY = 32;
+/** Version of the shipping package, surfaced through `plugin.version`. */
+const PACKAGE_VERSION = readPackageVersion();
+function readPackageVersion() {
+	try {
+		const { version } = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
+		return typeof version === "string" ? version : void 0;
+	} catch {
+		return;
+	}
 }
 function toBuffer(source) {
-	return typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source);
+	if (typeof source === "string") return Buffer.from(source, "utf8");
+	if (Buffer.isBuffer(source)) return source;
+	return Buffer.from(source.buffer, source.byteOffset, source.byteLength);
 }
 function formatBytes(bytes) {
 	if (bytes < 1024) return `${bytes} B`;
 	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} kB`;
 	return `${(bytes / 1048576).toFixed(2)} MB`;
 }
+function createLogger(context, logLevel) {
+	const verbose = logLevel === "info";
+	const warns = logLevel === "info" || logLevel === "warn";
+	const noop = () => {};
+	return {
+		debug: verbose ? (message) => context.debug?.(message) : noop,
+		info: verbose ? (message) => context.info?.(message) : noop,
+		warn: warns ? (message) => context.warn?.(message) : noop
+	};
+}
 /**
 * Shared batching core: queues per-algorithm tasks, flushes them to the
 * native module and hands successful results to `emit`. Only one batch of
 * source buffers is referenced at a time once a flush trigger is set.
 */
-function createBatchRunner(options, logger, emittedNames, emit, fail) {
+function createBatchRunner({ options, log, emittedNames, isReserved, emit, fail }) {
 	const processedSources = /* @__PURE__ */ new Set();
 	const emittedBySource = /* @__PURE__ */ new Map();
 	const failures = [];
 	const stats = /* @__PURE__ */ new Map();
+	/** Artifact name -> the `source (algorithm)` that claimed it, for collision reporting. */
+	const claimed = /* @__PURE__ */ new Map();
 	const chunkSize = options.chunkSize > 0 ? options.chunkSize : options.stream ? STREAM_DEFAULT_CHUNK_SIZE : 0;
 	let pending = [];
 	let pendingSourceBytes = 0;
@@ -252,7 +327,7 @@ function createBatchRunner(options, logger, emittedNames, emit, fail) {
 				continue;
 			}
 			if (result.skipped) {
-				logger.info(`skipped ${artifact.outputFileName}: ${result.algorithm} output would not be smaller than the original`);
+				log.debug(`skipped ${artifact.outputFileName}: ${result.algorithm} output would not be smaller than the original`);
 				continue;
 			}
 			await emit(artifact, result.data);
@@ -271,8 +346,13 @@ function createBatchRunner(options, logger, emittedNames, emit, fail) {
 	};
 	const addFile = async (fileName, buffer) => {
 		for (const algorithm of options.algorithms) {
-			const outputFileName = resolveOutputFileName(options.filename, fileName, algorithm, buffer);
-			if (outputFileName === fileName) fail(`the filename option resolved "${fileName}" (${algorithm.algorithm}) to the same name as the source asset; refusing to overwrite it`);
+			const check = checkArtifactName(resolveOutputFileName(options.filename, fileName, algorithm, buffer), fileName, algorithm.algorithm);
+			if (!check.ok) return fail(check.message);
+			const outputFileName = check.fileName;
+			const owner = claimed.get(outputFileName);
+			if (owner !== void 0) fail(`both ${owner} and ${fileName} (${algorithm.algorithm}) resolve to the artifact "${outputFileName}"; make the filename option depend on the algorithm`);
+			if (isReserved(outputFileName)) fail(`the artifact "${outputFileName}" for ${fileName} (${algorithm.algorithm}) would overwrite a file this build already owns`);
+			claimed.set(outputFileName, `${fileName} (${algorithm.algorithm})`);
 			pending.push({
 				task: {
 					fileName,
@@ -299,12 +379,12 @@ function createBatchRunner(options, logger, emittedNames, emit, fail) {
 		stats
 	};
 }
-function logSummary(logger, stats, startedAt) {
+function formatSummary(stats, startedAt) {
 	const summary = [...stats.entries()].map(([algorithm, stat]) => `${algorithm}: ${stat.count} file(s), ${formatBytes(stat.originalBytes)} -> ${formatBytes(stat.outputBytes)}`).join("; ");
-	if (summary.length === 0) return;
+	if (summary.length === 0) return void 0;
 	const totalSaved = [...stats.values()].reduce((sum, stat) => sum + (stat.originalBytes - stat.outputBytes), 0);
 	const elapsedMs = performance.now() - startedAt;
-	logger.info(`${summary}; saved ${formatBytes(totalSaved)} in ${(elapsedMs / 1e3).toFixed(2)}s`);
+	return `${summary}; saved ${formatBytes(totalSaved)} in ${(elapsedMs / 1e3).toFixed(2)}s`;
 }
 /** Recursively list every file under `root`, in a deterministic order. */
 async function walkFiles(root) {
@@ -321,26 +401,133 @@ async function walkFiles(root) {
 	await visit(root);
 	return files;
 }
+/** Run `task` over `items` with at most `limit` in flight, preserving order. */
+async function mapConcurrent(items, limit, task) {
+	const results = new Array(items.length);
+	let next = 0;
+	const worker = async () => {
+		for (let index = next++; index < items.length; index = next++) results[index] = await task(items[index]);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return results;
+}
+/**
+* Every file under `outDir` eligible for compression, each tagged with whether
+* this build produced it.
+*
+* Compression stays deliberately broad — whatever is in the output directory
+* and matches the filter gets compressed, which is the point of stream mode.
+* Deletion does not: removing a file is not undoable, so it is restricted to
+* files the build owns and never reaches leftovers from an earlier build in a
+* directory that was not emptied.
+*/
+async function collectStreamSources(outDir, bundleNames, writtenSinceMs, options, emittedNames) {
+	const absolutePaths = await walkFiles(outDir);
+	const infos = await mapConcurrent(absolutePaths, STAT_CONCURRENCY, async (absolute) => {
+		try {
+			return await (0, node_fs_promises.stat)(absolute);
+		} catch {
+			return;
+		}
+	});
+	const sources = [];
+	for (const [index, absolute] of absolutePaths.entries()) {
+		const info = infos[index];
+		if (info === void 0) continue;
+		const fileName = node_path.default.relative(outDir, absolute).split(node_path.default.sep).join("/");
+		if (!options.filter(fileName)) continue;
+		if (COMPRESSED_EXTENSION_RE.test(fileName) || emittedNames.has(fileName)) continue;
+		if (info.size < options.threshold) continue;
+		sources.push({
+			fileName,
+			absolute,
+			size: info.size,
+			ownedByBuild: bundleNames.has(fileName) || info.mtimeMs >= writtenSinceMs
+		});
+	}
+	return sources;
+}
+/**
+* Split sources into read groups that mirror the batch boundaries
+* {@link createBatchRunner} would pick, so a group can be read concurrently
+* without ever holding more than one batch of file contents in memory.
+*/
+function* groupBySize(sources, maxBytes) {
+	let group = [];
+	let bytes = 0;
+	for (const source of sources) {
+		group.push(source);
+		bytes += source.size;
+		if (bytes >= maxBytes) {
+			yield group;
+			group = [];
+			bytes = 0;
+		}
+	}
+	if (group.length > 0) yield group;
+}
 function createCompressionPlugin(options) {
-	const logger = createLogger(options.logLevel);
 	const emittedNames = /* @__PURE__ */ new Set();
-	return Object.assign({
+	/**
+	* Wall-clock start of the current output. Stream mode compares file mtimes
+	* against it to tell what this build wrote from what it merely found in the
+	* output directory, which is what `deleteOriginalAssets` is allowed to touch.
+	*/
+	let outputStartedAtMs;
+	/** `deleteOriginalAssets` removing a chunk is worth saying once, not every build. */
+	let chunkDeletionWarned = false;
+	const warnDeletedChunks = (names, log) => {
+		if (names.length === 0 || chunkDeletionWarned) return;
+		chunkDeletionWarned = true;
+		const sample = names.slice(0, 3).join(", ");
+		log.warn(`deleteOriginalAssets removed ${names.length} chunk(s) (${sample}${names.length > 3 ? ", …" : ""}); requests for those paths only resolve if the server rewrites them to the compressed variant, and dynamic imports and source map links still reference the original names`);
+	};
+	const skipsWatchMode = (watchMode, log) => {
+		if (!watchMode || options.enableInWatchMode) return false;
+		log.info("watch mode detected, skipping compression (set enableInWatchMode to opt in)");
+		return true;
+	};
+	const plugin = {
 		name: PLUGIN_NAME,
+		...PACKAGE_VERSION === void 0 ? {} : { version: PACKAGE_VERSION },
+		meta: {
+			packageName: PACKAGE_NAME,
+			...PACKAGE_VERSION === void 0 ? {} : { version: PACKAGE_VERSION },
+			description: "Compresses emitted assets with gzip, brotli and zstd through a native Rust core"
+		},
+		api: {
+			packageName: PACKAGE_NAME,
+			algorithms: options.algorithms.map((algorithm) => algorithm.algorithm),
+			extensions: options.algorithms.map((algorithm) => algorithm.extension),
+			emittedFileNames: () => [...emittedNames]
+		},
+		renderStart() {
+			emittedNames.clear();
+			outputStartedAtMs = Date.now();
+		},
 		async generateBundle(_outputOptions, bundle) {
-			if (options.stream) return;
-			if (this.meta?.watchMode && !options.enableInWatchMode) {
-				logger.info("watch mode detected, skipping compression (set enableInWatchMode to opt in)");
+			if (options.stream) {
+				outputStartedAtMs ??= Date.now();
 				return;
 			}
+			const log = createLogger(this, options.logLevel);
+			if (skipsWatchMode(this.meta?.watchMode, log)) return;
 			const startedAt = performance.now();
 			const fail = (message) => this.error(/* @__PURE__ */ new Error(`[${PLUGIN_NAME}] ${message}`));
-			const runner = createBatchRunner(options, logger, emittedNames, (artifact, data) => {
-				this.emitFile({
-					type: "asset",
-					fileName: artifact.outputFileName,
-					source: data
-				});
-			}, fail);
+			const runner = createBatchRunner({
+				options,
+				log,
+				emittedNames,
+				isReserved: (fileName) => Object.hasOwn(bundle, fileName),
+				emit: (artifact, data) => {
+					this.emitFile({
+						type: "asset",
+						fileName: artifact.outputFileName,
+						source: data
+					});
+				},
+				fail
+			});
 			for (const [fileName, output] of Object.entries(bundle)) {
 				if (!options.filter(fileName)) continue;
 				if (COMPRESSED_EXTENSION_RE.test(fileName) || emittedNames.has(fileName)) continue;
@@ -351,54 +538,90 @@ function createCompressionPlugin(options) {
 			await runner.flush();
 			if (runner.processedSources.size === 0) return;
 			if (runner.failures.length > 0) fail(`${runner.failures.length} compression task(s) failed:\n${runner.failures.join("\n")}`);
-			if (options.deleteOriginalAssets) for (const fileName of runner.processedSources) {
-				if ((runner.emittedBySource.get(fileName) ?? 0) === 0) logger.warn(`deleteOriginalAssets removed "${fileName}" even though no compressed variant was emitted for it`);
-				delete bundle[fileName];
+			if (options.deleteOriginalAssets) {
+				const deletedChunks = [];
+				for (const fileName of runner.processedSources) {
+					if ((runner.emittedBySource.get(fileName) ?? 0) === 0) {
+						log.warn(`kept "${fileName}": deleteOriginalAssets only removes an asset once a compressed variant of it exists`);
+						continue;
+					}
+					if (bundle[fileName]?.type === "chunk") deletedChunks.push(fileName);
+					delete bundle[fileName];
+				}
+				warnDeletedChunks(deletedChunks, log);
 			}
-			logSummary(logger, runner.stats, startedAt);
+			const summary = formatSummary(runner.stats, startedAt);
+			if (summary !== void 0) log.info(summary);
 		},
 		writeBundle: {
 			order: "post",
-			async handler(outputOptions) {
+			async handler(outputOptions, bundle) {
 				if (!options.stream) return;
-				if (this.meta?.watchMode && !options.enableInWatchMode) {
-					logger.info("watch mode detected, skipping compression (set enableInWatchMode to opt in)");
-					return;
-				}
+				const log = createLogger(this, options.logLevel);
+				if (skipsWatchMode(this.meta?.watchMode, log)) return;
 				const outDir = outputOptions.dir !== void 0 ? node_path.default.resolve(outputOptions.dir) : outputOptions.file !== void 0 ? node_path.default.resolve(node_path.default.dirname(outputOptions.file)) : void 0;
 				if (outDir === void 0) {
-					logger.warn("stream mode could not determine the output directory, skipping compression");
+					log.warn("stream mode could not determine the output directory, skipping compression");
 					return;
 				}
 				const startedAt = performance.now();
 				const fail = (message) => this.error(/* @__PURE__ */ new Error(`[${PLUGIN_NAME}] ${message}`));
-				const runner = createBatchRunner(options, logger, emittedNames, async (artifact, data) => {
-					const target = node_path.default.join(outDir, artifact.outputFileName);
-					await (0, node_fs_promises.mkdir)(node_path.default.dirname(target), { recursive: true });
-					await (0, node_fs_promises.writeFile)(target, data);
-				}, fail);
-				for (const absolute of await walkFiles(outDir)) {
-					const fileName = node_path.default.relative(outDir, absolute).split(node_path.default.sep).join("/");
-					if (!options.filter(fileName)) continue;
-					if (COMPRESSED_EXTENSION_RE.test(fileName) || emittedNames.has(fileName)) continue;
-					if ((await (0, node_fs_promises.stat)(absolute)).size < options.threshold) continue;
-					await runner.addFile(fileName, await (0, node_fs_promises.readFile)(absolute));
+				const sources = await collectStreamSources(outDir, new Set(Object.keys(bundle ?? {})), outputStartedAtMs === void 0 ? -Infinity : outputStartedAtMs - MTIME_SLACK_MS, options, emittedNames);
+				const sourceNames = new Set(sources.map((source) => source.fileName));
+				const ownedNames = new Set(sources.filter((source) => source.ownedByBuild).map((source) => source.fileName));
+				const runner = createBatchRunner({
+					options,
+					log,
+					emittedNames,
+					isReserved: (fileName) => sourceNames.has(fileName),
+					emit: async (artifact, data) => {
+						const target = node_path.default.join(outDir, artifact.outputFileName);
+						await (0, node_fs_promises.mkdir)(node_path.default.dirname(target), { recursive: true });
+						await (0, node_fs_promises.writeFile)(target, data);
+					},
+					fail
+				});
+				const batchBytes = options.chunkSize > 0 ? options.chunkSize : STREAM_DEFAULT_CHUNK_SIZE;
+				for (const group of groupBySize(sources, batchBytes)) {
+					const buffers = await mapConcurrent(group, group.length, (source) => (0, node_fs_promises.readFile)(source.absolute));
+					for (const [index, source] of group.entries()) await runner.addFile(source.fileName, buffers[index]);
 				}
 				await runner.flush();
 				if (runner.processedSources.size === 0) return;
 				if (runner.failures.length > 0) fail(`${runner.failures.length} compression task(s) failed:\n${runner.failures.join("\n")}`);
-				if (options.deleteOriginalAssets) for (const fileName of runner.processedSources) {
-					if ((runner.emittedBySource.get(fileName) ?? 0) === 0) logger.warn(`deleteOriginalAssets removed "${fileName}" even though no compressed variant was emitted for it`);
-					await (0, node_fs_promises.unlink)(node_path.default.join(outDir, fileName));
+				if (options.deleteOriginalAssets) {
+					const deletedChunks = [];
+					for (const fileName of runner.processedSources) {
+						if ((runner.emittedBySource.get(fileName) ?? 0) === 0) {
+							log.warn(`kept "${fileName}": deleteOriginalAssets only removes an asset once a compressed variant of it exists`);
+							continue;
+						}
+						if (!ownedNames.has(fileName)) {
+							log.warn(`kept "${fileName}": deleteOriginalAssets only removes files this build wrote to the output directory`);
+							continue;
+						}
+						if (bundle?.[fileName]?.type === "chunk") deletedChunks.push(fileName);
+						await (0, node_fs_promises.unlink)(node_path.default.join(outDir, fileName));
+					}
+					warnDeletedChunks(deletedChunks, log);
 				}
-				logSummary(logger, runner.stats, startedAt);
+				const summary = formatSummary(runner.stats, startedAt);
+				if (summary !== void 0) log.info(summary);
 			}
 		}
-	}, { apply: "build" });
+	};
+	plugin.apply = "build";
+	return plugin;
 }
 //#endregion
 //#region ts/index.ts
 /**
+* @medicomind/rolldown-compression
+*
+* Rolldown plugin that compresses emitted assets with gzip, brotli and zstd
+* using a native Rust core (napi-rs + rayon).
+*/
+/**
 * Create the compression plugin.
 *
 * Options are validated eagerly: invalid levels, algorithm names, thresholds