@clossys/writer 0.3.8 → 0.4.0

package/dist/approved-copy-coverage-rate.js

@@ -0,0 +1,153 @@
+/**
+ * Computes the Writer charter metric `approved copy coverage rate` from
+ * consumer-supplied independent observations.
+ *
+ * This module does not invent observations and does not relabel
+ * `checkCopyRecord` or `checkCopyTraceability`. An empty evaluated set is
+ * indeterminate, never a perfect rate of 1. `writer-check` remains the
+ * multi-mode CLI.
+ */
+const METRIC = "approved copy coverage rate";
+const RESERVED_OBSERVERS = new Set(["writer", "@clossys/writer"]);
+const PROPOSED_POSITIONS = [];
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function timestamp(value) {
+    return text(value) && !Number.isNaN(Date.parse(value));
+}
+function finding(rule, message, path) {
+    return path === undefined ? { rule, severity: "error", message } : { rule, severity: "error", message, path };
+}
+function evidenceCounts(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return false;
+    return value.every((item) => record(item) && text(item.id) && text(item.description));
+}
+function reservedObserver(value) {
+    return RESERVED_OBSERVERS.has(value.trim().toLowerCase());
+}
+function report(state, evaluatedCopy, approvedCoveredCopy, rate, findings) {
+    return {
+        metric: METRIC,
+        state,
+        rate,
+        evaluatedCopy,
+        approvedCoveredCopy,
+        findings,
+        proposedPositions: PROPOSED_POSITIONS,
+    };
+}
+function isCovered(entry) {
+    return entry.approved && entry.traceable && entry.resolvedFromRegistry;
+}
+/**
+ * Computes `approved copy coverage rate`: shipped audience-facing copy
+ * resolved from approved traceable registry entries / all shipped
+ * audience-facing copy evaluated.
+ */
+export function assessApprovedCopyCoverageRate(input) {
+    if (!record(input)) {
+        return report("indeterminate", 0, 0, null, [finding("assessment-shape", "Assessment input must be an object.", "$")]);
+    }
+    const findings = [];
+    if (!timestamp(input.asOf)) {
+        findings.push(finding("assessment-as-of", "asOf must be an interpretable timestamp.", "asOf"));
+    }
+    const declaredCopy = input.declaredCopy;
+    if (!Array.isArray(declaredCopy)) {
+        findings.push(finding("declared-copy-required", "declaredCopy must be an array of { id } objects.", "declaredCopy"));
+        return report("indeterminate", 0, 0, null, findings);
+    }
+    const declaredIds = [];
+    const declaredSet = new Set();
+    declaredCopy.forEach((item, index) => {
+        const path = `declaredCopy[${index}]`;
+        if (!record(item) || !text(item.id)) {
+            findings.push(finding("copy-id-required", "id must be a non-empty string.", `${path}.id`));
+            return;
+        }
+        if (declaredSet.has(item.id)) {
+            findings.push(finding("duplicate-copy-id", `Duplicate id "${item.id}".`, `${path}.id`));
+            return;
+        }
+        declaredSet.add(item.id);
+        declaredIds.push(item.id);
+    });
+    if (declaredIds.length === 0) {
+        findings.push(finding("declared-copy-empty", "No declared copy is available for the approved-copy-coverage metric; the rate is indeterminate, never 1.", "declaredCopy"));
+    }
+    const observations = input.observations;
+    if (observations !== undefined && !Array.isArray(observations)) {
+        findings.push(finding("observations-shape", "observations must be an array.", "observations"));
+    }
+    const counting = new Map();
+    if (Array.isArray(observations)) {
+        observations.forEach((item, index) => {
+            const path = `observations[${index}]`;
+            if (!record(item)) {
+                findings.push(finding("observation-shape", "An observation must be an object.", path));
+                return;
+            }
+            if (text(item.observerRef) && reservedObserver(item.observerRef)) {
+                findings.push(finding("self-observation", "Writer cannot observe itself; reserved observerRef values are not independent.", `${path}.observerRef`));
+                return;
+            }
+            if (text(item.copyId) && !declaredSet.has(item.copyId)) {
+                findings.push(finding("unknown-copy", `Observation copyId "${item.copyId}" is not declared copy.`, `${path}.copyId`));
+                return;
+            }
+            if (item.independent !== true)
+                return;
+            if (typeof item.approved !== "boolean" ||
+                typeof item.traceable !== "boolean" ||
+                typeof item.resolvedFromRegistry !== "boolean")
+                return;
+            if (!text(item.observerRef) || !evidenceCounts(item.evidence) || !text(item.copyId) || !declaredSet.has(item.copyId))
+                return;
+            const bucket = counting.get(item.copyId) ?? [];
+            bucket.push({
+                approved: item.approved,
+                traceable: item.traceable,
+                resolvedFromRegistry: item.resolvedFromRegistry,
+            });
+            counting.set(item.copyId, bucket);
+        });
+    }
+    let evaluatedCopy = 0;
+    let approvedCoveredCopy = 0;
+    for (const id of declaredIds) {
+        const observed = counting.get(id) ?? [];
+        if (observed.length === 0) {
+            findings.push(finding("copy-unevaluated", `Declared copy "${id}" has no counting independent observation.`, `declaredCopy.${id}`));
+            continue;
+        }
+        evaluatedCopy += 1;
+        const allCovered = observed.every((entry) => isCovered(entry));
+        if (allCovered)
+            approvedCoveredCopy += 1;
+        else {
+            findings.push(finding("copy-not-covered", `Declared copy "${id}" was independently observed not resolved from an approved traceable registry entry.`, `declaredCopy.${id}`));
+        }
+        if (observed.length > 1) {
+            const first = observed[0];
+            const disagree = observed.some((entry) => entry.approved !== first.approved ||
+                entry.traceable !== first.traceable ||
+                entry.resolvedFromRegistry !== first.resolvedFromRegistry);
+            if (disagree) {
+                findings.push(finding("observation-disagreement", `Counting observations for "${id}" disagree.`, `observations.${id}`));
+            }
+        }
+    }
+    const rate = evaluatedCopy === 0 ? null : approvedCoveredCopy / evaluatedCopy;
+    if (evaluatedCopy === 0)
+        return report("indeterminate", 0, 0, null, findings);
+    const coverageComplete = evaluatedCopy === declaredIds.length;
+    const noErrorFindings = findings.length === 0;
+    const state = coverageComplete && approvedCoveredCopy === evaluatedCopy && noErrorFindings ? "satisfied" : "violated";
+    return report(state, evaluatedCopy, approvedCoveredCopy, rate, findings);
+}
+//# sourceMappingURL=approved-copy-coverage-rate.js.map

package/dist/approved-copy-coverage-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approved-copy-coverage-rate.js","sourceRoot":"","sources":["../src/approved-copy-coverage-rate.ts"],"names":[],"mappings":"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"}

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AAWH,OAAO,EAAyB,KAAK,eAAe,EAAE,KAAK,eAAe,EAAuB,MAAM,gBAAgB,CAAC;AAIxH,OAAO,EAAuC,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAkEpF,qHAAqH;AACrH,qBAAa,aAAc,SAAQ,KAAK;CAAG;AAsgB3C;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,eAAe,CAAC;IAChD,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnD;AAmBD,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAyL3C;AAsGD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAqCxD;AAkFD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CA6B9D"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AAWH,OAAO,EAAyB,KAAK,eAAe,EAAE,KAAK,eAAe,EAAuB,MAAM,gBAAgB,CAAC;AAMxH,OAAO,EAAuC,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAsEpF,qHAAqH;AACrH,qBAAa,aAAc,SAAQ,KAAK;CAAG;AAojB3C;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,eAAe,CAAC;IAChD,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnD;AAmBD,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CA2R3C;AAsGD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAqCxD;AA4ID;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAwC9D"}

package/dist/cli.js

@@ -126,10 +126,13 @@ import { fileURLToPath } from "node:url";
 import { checkAddressability, scanAddressabilitySources, } from "./addressability.js";
 import { checkCopyTraceability } from "./copy-gate.js";
 import { checkLocaleCoverage } from "./locale-coverage.js";
+import { liveTreeExists, scanLiveCopyTrees } from "./live-copy-gate.js";
 import { checkPassageComposition, readPassageRecord } from "./passage.js";
 import { readCopyRecord } from "./registry.js";
+import { checkRenderRegistryParity } from "./render-registry-parity.js";
 import { scanCopySourceTree } from "./scan.js";
-import { checkVoiceDerivationCoverage } from "./voice/index.js";
+import { checkTreatmentWordBudgets } from "./treatment-word-budget.js";
+import { checkVoiceDerivationCoverage, parseVoiceRecord } from "./voice/index.js";
 const USAGE = `Usage: writer-check <record-file> [scan-dir] [options]
    or: writer-check voice-derivation-coverage <obligations-file> <brand-derived-rule-ids-file> [options]
    or: writer-check locale-coverage <registries-file> <source-locale> [declared-locale...] [options]
@@ -147,6 +150,9 @@ are separate, stricter gates; neither runs as part of this default command.
 
 Options:
   --help         Print this message and exit 0.
+  --render-registry <file>  Path the surface passes to createCopyResolver at render. When set, must be the same file as record-file (after realpath). When omitted, record-file itself must be a CopyRegistry — not a plain CopyRecord or an in-memory-only store.
+  --live <dir>   Declared live-copy tree the page actually renders (repeatable). Requires --voice-record.
+  --voice-record <file>  Voice record JSON for claims when --live is set.
   --format <text|json>  Output format. Defaults to text. "json" prints exactly one
                  machine-readable object to stdout (see CopyTraceabilityReport in
                  cli.ts) instead of the human-readable report — "verdict" states the
@@ -196,6 +202,9 @@ export class CliInputError extends Error {
 function parseArgs(argv) {
     let recordFile;
     let scanDir;
+    let renderRegistryFile;
+    const liveTrees = [];
+    let voiceRecordFile;
     let format = "text";
     let help = false;
     for (let i = 0; i < argv.length; i++) {
@@ -204,6 +213,14 @@ function parseArgs(argv) {
             help = true;
             continue;
         }
+        if (arg === "--render-registry") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-")) {
+                throw new CliInputError("--render-registry requires a file path");
+            }
+            renderRegistryFile = value;
+            continue;
+        }
         if (arg === "--format") {
             const value = argv[++i];
             if (value !== "text" && value !== "json") {
@@ -212,6 +229,20 @@ function parseArgs(argv) {
             format = value;
             continue;
         }
+        if (arg === "--live") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-"))
+                throw new CliInputError("--live requires a directory path");
+            liveTrees.push(value);
+            continue;
+        }
+        if (arg === "--voice-record") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-"))
+                throw new CliInputError("--voice-record requires a file path");
+            voiceRecordFile = value;
+            continue;
+        }
         if (arg.startsWith("-")) {
             throw new CliInputError(`unknown flag "${arg}"`);
         }
@@ -225,7 +256,20 @@ function parseArgs(argv) {
             throw new CliInputError(`unexpected extra argument "${arg}"`);
         }
     }
-    return { recordFile, scanDir, format, help };
+    if (liveTrees.length > 0 && !voiceRecordFile) {
+        throw new CliInputError("--voice-record is required when --live is declared");
+    }
+    return { recordFile, scanDir, renderRegistryFile, liveTrees, voiceRecordFile, format, help };
+}
+function printTreatmentWordBudgetReport(findings) {
+    if (findings.length === 0) {
+        console.log("No treatment word-budget findings.");
+        return;
+    }
+    console.log(`\n${findings.length} treatment word-budget finding(s):`);
+    for (const f of findings) {
+        console.log(`  [${f.rule}] ${f.entryId}  ${f.message}`);
+    }
 }
 function requireDirectory(label, path) {
     if (!existsSync(path))
@@ -637,7 +681,11 @@ function printAddressabilityReport(result) {
     else {
         console.log(`\n[addressability] ${result.violations.length} violation(s):`);
         for (const v of result.violations) {
-            const where = v.position === "markup-text" ? "a markup text node" : `the "${v.attribute}" attribute`;
+            const where = v.position === "markup-text"
+                ? "a markup text node"
+                : v.position === "object-literal-copy"
+                    ? `object-literal key "${v.keyPath ?? v.objectKey}"`
+                    : `the "${v.attribute}" attribute`;
             console.log(`  [copy-addressability] ${v.file}:${v.line}  inline prose in ${where}, not resolved from the copy registry by id: ${v.raw}`);
         }
     }
@@ -711,6 +759,35 @@ export function main(argv) {
         emitJson(emptyReport(recordFile, scanDir, 2, `copy record could not be loaded: ${read.issues.map((i) => `[${i.reason}] ${i.detail}`).join("; ")}`));
         return 2;
     }
+    let recordRaw;
+    try {
+        recordRaw = JSON.parse(readFileSync(recordFile, "utf8"));
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (!jsonMode) {
+            console.error(`\nCopy record could not be re-read for registry parity: ${detail}`);
+            console.error("Refusing to report a pass without confirming the render registry store.");
+        }
+        emitJson(emptyReport(recordFile, scanDir, 2, `copy record could not be re-read: ${detail}`));
+        return 2;
+    }
+    const renderRegistryPath = args.renderRegistryFile ? resolve(args.renderRegistryFile) : undefined;
+    if (renderRegistryPath)
+        requireFile("render-registry", renderRegistryPath);
+    const parity = checkRenderRegistryParity(recordFile, recordRaw, renderRegistryPath);
+    if (!parity.ok || !parity.registry) {
+        if (!jsonMode) {
+            console.error(`\nRender registry parity: ${parity.detail ?? parity.reason}`);
+            console.error("Refusing to report a pass when the CLI is not reading the same store createCopyResolver uses.");
+        }
+        emitJson(emptyReport(recordFile, scanDir, 2, parity.detail ?? parity.reason ?? "render registry parity failed"));
+        return 2;
+    }
+    const treatmentBudget = checkTreatmentWordBudgets(parity.registry);
+    if (!jsonMode && treatmentBudget.entriesChecked > 0) {
+        console.log(`Treatment word budgets: ${treatmentBudget.entriesChecked} approved entr${treatmentBudget.entriesChecked === 1 ? "y" : "ies"} with a treatment checked.`);
+    }
     // No argv flag populates `pathExclusions` today — this CLI always calls
     // `scanCopySourceTree` with defaults (`[]`), so `scan.excludedFiles`/
     // `scan.pathExclusionFindings` are always empty in THIS binary as
@@ -781,6 +858,70 @@ export function main(argv) {
     const result = checkCopyTraceability(scan.candidates, scan.citations, read.record, scan.filesScanned, scan.unchecked);
     if (!jsonMode)
         printGateReport(result);
+    if (!jsonMode)
+        printTreatmentWordBudgetReport(treatmentBudget.findings);
+    const hasTreatmentFindings = treatmentBudget.findings.length > 0;
+    if (args.liveTrees.length > 0) {
+        for (const livePath of args.liveTrees) {
+            const resolvedLive = resolve(livePath);
+            if (!liveTreeExists(resolvedLive)) {
+                if (!jsonMode) {
+                    console.error(`\nDeclared live-copy tree "${resolvedLive}" does not exist.`);
+                    console.error("Refusing to report a pass without scanning every declared live tree.");
+                }
+                emitJson(emptyReport(recordFile, scanDir, 2, `declared live-copy tree missing: ${resolvedLive}`));
+                return 2;
+            }
+        }
+        const voicePath = resolve(args.voiceRecordFile);
+        requireFile("voice-record", voicePath);
+        let voiceRaw;
+        try {
+            voiceRaw = JSON.parse(readFileSync(voicePath, "utf8"));
+        }
+        catch (error) {
+            if (!jsonMode)
+                console.error(`Voice record could not be loaded: ${error instanceof Error ? error.message : String(error)}`);
+            emitJson(emptyReport(recordFile, scanDir, 2, "voice record could not be loaded"));
+            return 2;
+        }
+        let voiceRecord;
+        try {
+            voiceRecord = parseVoiceRecord(voiceRaw);
+        }
+        catch (error) {
+            if (!jsonMode)
+                console.error(`Voice record is invalid: ${error instanceof Error ? error.message : String(error)}`);
+            emitJson(emptyReport(recordFile, scanDir, 2, "voice record is invalid"));
+            return 2;
+        }
+        const liveScan = scanLiveCopyTrees(voiceRecord, args.liveTrees.map((p) => resolve(p)));
+        if (!jsonMode) {
+            console.log(`Live-copy trees: ${args.liveTrees.length}, ${liveScan.filesScanned} file(s) scanned.`);
+            if (liveScan.findings.length > 0) {
+                console.log(`\n${liveScan.findings.length} live-copy finding(s):`);
+                for (const f of liveScan.findings)
+                    console.log(`  [${f.rule}] ${f.file}:${f.line}  ${f.message}`);
+            }
+        }
+        if (liveScan.findings.length > 0) {
+            const exitCode = result.unchecked.length > 0 ? 2 : 1;
+            emitJson({
+                recordFile,
+                scanDir,
+                verdict: result.unchecked.length > 0 ? "indeterminate" : "findings",
+                exitCode,
+                filesScanned: scan.filesScanned,
+                candidatesScanned: result.candidatesScanned,
+                matched: result.matched,
+                findings: result.findings,
+                ignored: result.ignored,
+                unchecked: result.unchecked,
+                parseFailures: scan.parseFailures.map((p) => ({ file: p.file, detail: p.detail })),
+            });
+            return exitCode;
+        }
+    }
     // `unchecked` wins over everything else in the exit-code decision — see
     // this file's own top doc comment for why it is a `2`, not a `1`: it
     // means part of a matched file was never actually examined, which is
@@ -799,8 +940,12 @@ export function main(argv) {
     // the SAME object, so a consumer keying on `exitCode`/`verdict` alone
     // still fails closed exactly as this package intends, while a consumer
     // that reads further is never forced to throw away what was measured.
-    const exitCode = result.unchecked.length > 0 ? 2 : result.findings.length > 0 ? 1 : 0;
-    const verdict = result.unchecked.length > 0 ? "indeterminate" : result.findings.length > 0 ? "findings" : "clean";
+    const exitCode = result.unchecked.length > 0 ? 2 : result.findings.length > 0 || hasTreatmentFindings ? 1 : 0;
+    const verdict = result.unchecked.length > 0
+        ? "indeterminate"
+        : result.findings.length > 0 || hasTreatmentFindings
+            ? "findings"
+            : "clean";
     emitJson({
         recordFile,
         scanDir,
@@ -992,17 +1137,68 @@ registry-text-match escape hatch here, unlike the default command.
 
 Options:
   --help         Print this message and exit 0.
+  --extensions <ext>  File extension(s) to scan, including the leading dot (for example .mjs). Repeatable, and each occurrence may itself be a comma-separated list (for example --extensions .mjs,.cjs); values union across both forms. When omitted, default is .ts, .tsx, .js, .jsx. When present, replaces that default. Every value must include the leading dot; a flag that resolves to zero extensions (for example a bare comma) is a usage error, never a vacuous pass.
+  --chrome <file>  Persistent chrome (site header, footer, skip link, nav labels) shell or layout file to scan in addition to scan-dir (repeatable; paths relative to scan-dir unless absolute). Each file must exist.
+  --require-chrome  Refuse to run (exit 2) when no --chrome file was declared — use when the surface mounts persistent chrome outside scan-dir.
 
-Exit codes: 0 = clean, 1 = at least one inline user-facing string found, 2 = could not run (bad input, nothing matched to scan, every matched file failed to parse, or a string position could not be confidently classified).
+Exit codes: 0 = clean, 1 = at least one inline user-facing string found, 2 = could not run (bad input, nothing matched to scan, every matched file failed to parse, a string position could not be confidently classified, a declared chrome file is missing, or --require-chrome was set without --chrome).
 `;
+const ADDRESSABILITY_EXTENSION_RE = /^\.[a-zA-Z0-9]+$/;
 function parseAddressabilityArgs(argv) {
     let scanDir;
+    const extensions = [];
+    const chromeFiles = [];
     let help = false;
-    for (const arg of argv) {
+    let sawExtensions = false;
+    let requireChrome = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
         if (arg === "--help" || arg === "-h") {
             help = true;
             continue;
         }
+        if (arg === "--require-chrome") {
+            requireChrome = true;
+            continue;
+        }
+        if (arg === "--chrome") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-")) {
+                throw new CliInputError("--chrome requires a file path");
+            }
+            chromeFiles.push(value);
+            continue;
+        }
+        if (arg === "--extensions") {
+            sawExtensions = true;
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-")) {
+                throw new CliInputError("--extensions requires an extension such as .mjs");
+            }
+            // Repeatable AND comma-separated: `--extensions .mjs,.cjs` and
+            // `--extensions .mjs --extensions .cjs` union to the same set. Every
+            // token from the split is validated individually — a bare comma or a
+            // trailing/leading comma yields an empty token, which is a usage
+            // error below rather than being silently dropped (an --extensions
+            // flag that resolves to zero extensions must never fall back to the
+            // default set — that would be a vacuous pass on the caller's own
+            // explicit-but-empty request).
+            const tokens = value.split(",");
+            if (tokens.length === 0 || tokens.some((token) => token.trim().length === 0)) {
+                throw new CliInputError(`--extensions requires at least one non-empty extension such as .mjs, got ${JSON.stringify(value)}`);
+            }
+            for (const rawToken of tokens) {
+                const token = rawToken.trim().toLowerCase();
+                if (!token.startsWith(".")) {
+                    throw new CliInputError(`--extensions values must include the leading dot, got ${JSON.stringify(token)}`);
+                }
+                if (!ADDRESSABILITY_EXTENSION_RE.test(token)) {
+                    throw new CliInputError(`invalid --extensions value ${JSON.stringify(token)}`);
+                }
+                extensions.push(token);
+            }
+            continue;
+        }
         if (arg.startsWith("-")) {
             throw new CliInputError(`unknown flag "${arg}"`);
         }
@@ -1013,7 +1209,7 @@ function parseAddressabilityArgs(argv) {
             throw new CliInputError(`unexpected extra argument "${arg}"`);
         }
     }
-    return { scanDir, help };
+    return { scanDir, help, extensions: sawExtensions ? extensions : undefined, chromeFiles, requireChrome };
 }
 /**
  * Exported (unlike a typical CLI `main`) for the identical reason `main`
@@ -1029,11 +1225,22 @@ export function mainAddressabilityCheck(argv) {
     }
     const scanDir = resolve(args.scanDir ?? process.cwd());
     requireDirectory("scan-dir", scanDir);
+    if (args.requireChrome && args.chromeFiles.length === 0) {
+        throw new CliInputError("--require-chrome was set but no --chrome file was declared");
+    }
     console.log(`Scan directory: ${scanDir}`);
+    if (args.chromeFiles.length > 0) {
+        console.log(`Chrome files: ${args.chromeFiles.join(", ")}`);
+    }
+    const scanOptions = {};
+    if (args.extensions)
+        scanOptions.extensions = args.extensions;
+    if (args.chromeFiles.length > 0)
+        scanOptions.chromeFiles = args.chromeFiles;
     // Throws (fail-closed) on an unreadable directory, exactly like
     // `scanCopySourceTree` — caught by `runAddressabilityCheck()`'s own
     // catch-all below.
-    const scan = scanAddressabilitySources(scanDir);
+    const scan = scanAddressabilitySources(scanDir, scanOptions);
     printAddressabilityAccounting(scan);
     const result = checkAddressability(scan);
     printAddressabilityReport(result);