@afterpack/parcel-optimizer 0.2.0-rc.20260930T1421 → 0.2.1

package/README.md

@@ -28,6 +28,24 @@ that way.
 Keep the `"..."`: it runs Parcel's own minifier first and AfterPack last. If obfuscation fails, the
 build fails.
 
+## Check a deploy
+
+Add the plugin's reporter to the build command, and each build writes `.afterpack-protection.json`
+into the target's output directory, a receipt with a hash per obfuscated bundle:
+
+```sh
+parcel build index.html --reporter @afterpack/parcel-optimizer/reporter
+npx afterpack verify dist   # in the deploy step, before the upload
+```
+
+`afterpack verify` fails if a file changed after it was obfuscated, or if there is no receipt. The
+reporter writes none when a bundle it shipped was not obfuscated in that build: the optimizer is
+missing from `.parcelrc`, `build.autorun` is off, or Parcel reused the bundle from `.parcel-cache`.
+Parcel's naming rule for plugins in `.parcelrc` leaves no place there for a reporter in this
+package, so it goes on the command line. The optimizer leaves the reporter one small record per
+bundle in `.afterpack/parcel/`. The reporter clears them as each build starts; without it they stay
+there, ignored by git.
+
 ## Configuration
 
 `.parcelrc` cannot pass options, so put them in `afterpack.json` at your project root, or in
@@ -81,8 +99,7 @@ source, so never deploy or commit it.
   `"preset": "minify"`. Parcel's default ES module output is not affected.
 - **Cache.** Parcel caches optimizer output. Clear `.parcel-cache` for a fresh seed on an unchanged
   build.
-- **Not available here:** [`build.backup`][build.backup] and [`paths.include`][paths.include], and there is no protection receipt, so
-  `afterpack verify` has nothing to check on a Parcel build.
+- **Not available here:** [`build.backup`][build.backup] and [`paths.include`][paths.include].
 - Parcel may print that ES module dependencies are experimental and that the plugin has
   non-statically analyzable dependencies. Both are harmless.
 

package/dist/index.js

@@ -1,3 +1,4 @@
+import { clearBundleRecord, escapeParcelMarkdown, writeBundleRecord } from "./records-Bgj9LonR.js";
 import { join } from "node:path";
 import { text } from "node:stream/consumers";
 import { processBatch, version } from "@afterpack/core";
@@ -19,9 +20,6 @@ async function blobToString(blob) {
 	if (Buffer.isBuffer(blob)) return blob.toString("utf8");
 	return await text(blob);
 }
-function escapeParcelMarkdown(message) {
-	return message.replace(/[\\*_`~]/g, (c) => `\\${c}`);
-}
 const CONTENT_HASH_REF = /HASH_REF_\w{16}/g;
 function contentHashRefsExcludingSourceMapComment(code) {
 	const refs = new Set(code.match(CONTENT_HASH_REF) ?? []);
@@ -61,6 +59,7 @@ var src_default = new Optimizer({
 			map
 		};
 		if (bundle.type !== "js") return unchanged;
+		clearBundleRecord(options.projectRoot, bundle.id);
 		if (!bundle.env.shouldOptimize) return unchanged;
 		const autorun = config.options.build?.autorun ?? true;
 		if (!autorun) return unchanged;
@@ -138,6 +137,15 @@ var src_default = new Optimizer({
 			origin: PLUGIN_NAME,
 			hints: ["Run `parcel build --no-content-hash` (chunk URLs stop being content-addressed).", "Or set `\"preset\": \"minify\"` in afterpack.json to ship minify-only."]
 		} });
+		const receipt = result.deferredReceipt;
+		if (receipt) writeBundleRecord(options.projectRoot, bundle.id, {
+			tool: receipt.tool,
+			engine: receipt.engine,
+			engineVersion: receipt.engineVersion,
+			seed: String(receipt.seed),
+			seedOrigin: receipt.seedOrigin,
+			transformed: receipt.transformed.includes(projectedFilePath)
+		});
 		let outCode = out.code;
 		let originalRelativeSourceMap = null;
 		if (result.policy.sourceMap && out.sourceMap != null) {

package/dist/records-Bgj9LonR.js

@@ -0,0 +1,49 @@
+import { join } from "node:path";
+import { ensureAfterpackGitignore } from "@afterpack/integration-utils";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+
+//#region src/markdown.ts
+function escapeParcelMarkdown(message) {
+	return message.replace(/[\\*_`~]/g, (c) => `\\${c}`);
+}
+
+//#endregion
+//#region src/records.ts
+function afterpackDirOf(projectRoot) {
+	return join(projectRoot, ".afterpack");
+}
+function recordsDirOf(projectRoot) {
+	return join(afterpackDirOf(projectRoot), "parcel");
+}
+function recordPathOf(projectRoot, bundleId) {
+	return join(recordsDirOf(projectRoot), `${bundleId}.json`);
+}
+function writeBundleRecord(projectRoot, bundleId, record) {
+	const path = recordPathOf(projectRoot, bundleId);
+	mkdirSync(recordsDirOf(projectRoot), { recursive: true });
+	ensureAfterpackGitignore(afterpackDirOf(projectRoot));
+	writeFileSync(path, `${JSON.stringify(record)}\n`);
+}
+function clearBundleRecord(projectRoot, bundleId) {
+	rmSync(recordPathOf(projectRoot, bundleId), { force: true });
+}
+function clearBundleRecords(projectRoot) {
+	rmSync(recordsDirOf(projectRoot), {
+		recursive: true,
+		force: true
+	});
+}
+function readBundleRecord(projectRoot, bundleId) {
+	try {
+		const raw = JSON.parse(readFileSync(recordPathOf(projectRoot, bundleId), "utf8"));
+		if (raw === null || typeof raw !== "object") return null;
+		const record = raw;
+		if (typeof record.tool !== "string" || typeof record.transformed !== "boolean") return null;
+		return record;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { clearBundleRecord, clearBundleRecords, escapeParcelMarkdown, readBundleRecord, writeBundleRecord };

package/dist/reporter.d.ts

@@ -0,0 +1,6 @@
+import { Reporter } from "@parcel/plugin";
+
+//#region src/reporter.d.ts
+declare const _default: Reporter;
+//#endregion
+export { _default as default };

package/dist/reporter.js

@@ -0,0 +1,74 @@
+import { clearBundleRecords, escapeParcelMarkdown, readBundleRecord } from "./records-Bgj9LonR.js";
+import { join, relative } from "node:path";
+import { PROTECTION_RECEIPT_FILE, writeProtectionReceipt } from "@afterpack/integration-utils";
+import { Reporter } from "@parcel/plugin";
+import { rmSync } from "node:fs";
+
+//#region src/reporter.ts
+const LABEL = "afterpack-parcel";
+function shipsObfuscatedJs(bundle) {
+	return bundle.type === "js" && bundle.env.shouldOptimize && bundle.bundleBehavior !== "inline";
+}
+function agreed(values) {
+	const distinct = [...new Set(values)];
+	return distinct.length === 1 ? distinct[0] : null;
+}
+function joined(values) {
+	return [...new Set(values)].join(",");
+}
+function collectDistTrees(bundles, projectRoot) {
+	const trees = new Map();
+	for (const bundle of bundles) {
+		if (!shipsObfuscatedJs(bundle)) continue;
+		const dir = bundle.target.distDir;
+		let tree = trees.get(dir);
+		if (!tree) {
+			tree = {
+				files: [],
+				records: [],
+				transformed: [],
+				unrecorded: []
+			};
+			trees.set(dir, tree);
+		}
+		const record = readBundleRecord(projectRoot, bundle.id);
+		if (!record) {
+			tree.unrecorded.push(relative(projectRoot, bundle.filePath));
+			continue;
+		}
+		tree.files.push(bundle.filePath);
+		tree.records.push(record);
+		if (record.transformed) tree.transformed.push(bundle.filePath);
+	}
+	return trees;
+}
+var reporter_default = new Reporter({ report({ event, options, logger }) {
+	if (event.type === "buildStart") clearBundleRecords(options.projectRoot);
+	if (event.type !== "buildSuccess") return;
+	const trees = collectDistTrees(event.bundleGraph.getBundles(), options.projectRoot);
+	for (const [dir, tree] of trees) {
+		const receiptPath = join(dir, PROTECTION_RECEIPT_FILE);
+		if (tree.unrecorded.length > 0) {
+			rmSync(receiptPath, { force: true });
+			logger.warn({ message: escapeParcelMarkdown(`[${LABEL}] no protection receipt for ${relative(options.projectRoot, dir)}: AfterPack has no record of obfuscating ${tree.unrecorded.join(", ")} in this build. Keep @afterpack/parcel-optimizer in .parcelrc and build.autorun on; a bundle Parcel reused from .parcel-cache has no record either, so clear .parcel-cache and rebuild.`) });
+			continue;
+		}
+		const records = tree.records;
+		writeProtectionReceipt({
+			dir,
+			tool: records[0].tool,
+			engine: agreed(records.map((r) => r.engine)),
+			engineVersion: agreed(records.map((r) => r.engineVersion)),
+			seed: joined(records.map((r) => r.seed)),
+			seedOrigin: joined(records.map((r) => r.seedOrigin)),
+			bundler: "parcel",
+			buildId: null,
+			files: tree.files,
+			transformed: tree.transformed
+		});
+		logger.info({ message: escapeParcelMarkdown(`[${LABEL}] wrote protection receipt -> ${receiptPath} (afterpack verify)`) });
+	}
+} });
+
+//#endregion
+export { reporter_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afterpack/parcel-optimizer",
-  "version": "0.2.0-rc.20260930T1421",
+  "version": "0.2.1",
   "description": "Parcel 2 optimizer for AfterPack: obfuscate each JavaScript bundle in memory during parcel build",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./reporter": {
+      "types": "./dist/reporter.d.ts",
+      "import": "./dist/reporter.js",
+      "default": "./dist/reporter.js"
     }
   },
   "files": [
@@ -21,11 +26,11 @@
     "@parcel/core": ">=2.9.0"
   },
   "dependencies": {
-    "@afterpack/core": "~0.2.0",
+    "@afterpack/core": "~0.2.2",
     "@parcel/diagnostic": "^2.9.0",
     "@parcel/plugin": "^2.9.0",
     "@parcel/source-map": "^2.1.1",
-    "@afterpack/integration-utils": "0.2.0-rc.20260930T1421"
+    "@afterpack/integration-utils": "0.2.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
@@ -68,8 +73,8 @@
     "url": "https://github.com/afterpack-dev/afterpack/issues"
   },
   "scripts": {
-    "build": "tsdown src/index.ts --format esm --dts",
-    "dev": "tsdown src/index.ts --format esm --watch",
+    "build": "tsdown src/index.ts src/reporter.ts --format esm --dts",
+    "dev": "tsdown src/index.ts src/reporter.ts --format esm --watch",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "typecheck": "tsc --noEmit",