claude-dev-env 2.8.0 → 2.10.0

package/bin/CLAUDE.md

@@ -1,18 +1,27 @@
 # bin
 
-The installer and its companion modules. Running `npx claude-dev-env` (or `node bin/install.mjs`) copies package files into `~/.claude/`, merges hook entries into `~/.claude/settings.json`, installs Git hooks, and writes `~/.mypy.ini`.
+The installer and its companion modules. Running `npx claude-dev-env` (or `node bin/install.mjs`) copies package files into the managed root (`~/.claude/` by default; `CLAUDE_CONFIG_DIR` or `--target` selects another), merges hook entries into that root's `settings.json`, installs Git hooks, and writes `~/.mypy.ini` under the process home.
 
 ## Files
 
 | File | Purpose |
 |---|---|
-| `install.mjs` | Main installer: discovers install groups, copies content directories (`rules`, `docs`, `commands`, `agents`, `system-prompts`, `scripts`, `_shared`, `audit-rubrics`), merges hooks into `settings.json`, installs skills, prunes retired skill directories, retired hook entries, and stale files under every managed root on a full install, retires older prune backups, runs `git_hooks_installer.mjs` and `install_mypy_ini.mjs` |
-| `install-constants.mjs` | The named values `install.mjs` reads: `SKIPPED_SOURCE_ENTRY_NAMES` and `SKIPPED_SOURCE_FILE_EXTENSIONS` for the build artifacts the source walk leaves behind, `RUN_BACKUP_DIRECTORY_NAME_PATTERN` for the timestamp shape a run backup directory carries, `MANAGED_SKILLS_DIRECTORY_NAME` and `MANAGED_HOOKS_DIRECTORY_NAME` for the directory name each of those trees carries in a package source and under `~/.claude` — read by the copy loops, the hooks.json reads, the git-hook shims, the mypy configuration, and the prunes alike — `SETTINGS_FILE_NAME` for the settings file the merge, the retired-hook prune, and the uninstall purge share, and `MYPY_INI_FILE_NAME` for the home-directory file `install_mypy_ini.mjs` writes |
+| `install.mjs` | Main installer: builds a read-only plan via `install-plan.mjs`, then runs mutations inside `install-transaction.mjs` recovery (copy content directories, merge hooks, install skills, prune, git hooks, mypy.ini); routes `CLAUDE_HOME`, the manifest path, and `~/.mypy.ini` through `resolve-install-root.mjs`; resolves single or multi-profile targets before mutation and writes one ownership manifest per target |
+| `resolve-install-root.mjs` | Pure install-root resolver: precedence `--target` > `CLAUDE_CONFIG_DIR` > `~/.claude`, separator-boundary containment, and the declared external allowlist for `~/.mypy.ini` |
+| `select-install-targets.mjs` | Pure target selection for main-default, explicit `--target`, and `--profile`/`--profiles`; rejects ambiguous or duplicate targets; builds per-target manifest records with `targetIdentity` and `managedRoot` |
+| `install-plan.mjs` | Read-only install and uninstall plans: install preflight (managed root, source conflicts, Python, settings when hooks install) and uninstall preflight (settings JSON before removal, removable vs skipped manifest records), freezes plans E2/F execute |
+| `install-transaction.mjs` | Install, update, and uninstall transaction journal: captures prior settings, manifest, managed files, and `core.hooksPath`, restores them on failure, and supports fault injection phases for recovery tests |
+| `install.transaction.test.mjs` | Unit and sandbox installer tests for snapshot/restore and fault phases (`after_file_staging`, `after_settings_write`, `after_git_config`, `after_manifest_write`) |
+| `install.uninstall-transaction.test.mjs` | Uninstall plan preflight and recovery: malformed/non-object settings fail before removal, each fault phase restores files/settings/manifest/`core.hooksPath`, retry succeeds, selected-root containment |
+| `install.profile-root.test.mjs` | Contract tests for the install-root resolver: precedence, containment boundary, external allowlist, and the install.mjs import smoke check |
+| `install-constants.mjs` | The named values `install.mjs` reads: `SKIPPED_SOURCE_ENTRY_NAMES` and `SKIPPED_SOURCE_FILE_EXTENSIONS` for the build artifacts the source walk leaves behind, `RUN_BACKUP_DIRECTORY_NAME_PATTERN` for the timestamp shape a run backup directory carries, `MANAGED_SKILLS_DIRECTORY_NAME` and `MANAGED_HOOKS_DIRECTORY_NAME` for the directory name each of those trees carries in a package source and under `~/.claude` — read by the copy loops, the hooks.json reads, the git-hook shims, the mypy configuration, and the prunes alike — `SETTINGS_FILE_NAME` for the settings file the merge, the retired-hook prune, and the uninstall purge share, and `MYPY_INI_FILE_NAME` for the home-directory file `install_mypy_ini.mjs` writes (also imported by `resolve-install-root.mjs`) |
 | `ever-shipped-skills.mjs` | Static `EVER_SHIPPED_SKILL_NAMES` set of every top-level skill directory name the package has shipped; the installer subtracts the current skill set from it to prune retired skills left under `~/.claude/skills` |
 | `expand_home_directory_tokens.mjs` | Expands residual `$HOME` / `${HOME}` / `~/` tokens in settings.json hook and statusLine commands to absolute home paths at install time (literal-safe for homes that contain `$`) |
 | `git_hooks_installer.mjs` | Installs or updates the `pre-commit`, `pre-push`, and `post-commit` Git hooks in the user's git config; writes hook scripts that delegate to the installed Python hooks |
 | `install_mypy_ini.mjs` | Writes `~/.mypy.ini` with settings that make mypy find the hooks package and enforce strict type checking |
 | `install.test.mjs` | Unit tests for `install.mjs` — covers conflict detection, interpreter detection, settings merging, the settings shapes the installer never wrote — those every hook walk hands back untouched, and the shipped-event value the merge replaces with a warning — the source-artifact skip in `collectFiles`, the case-only rename decision and the `copyTree` copy that acts on it, the retired-hook diff and settings prune, the stale-file prune: the manifest diff, path-key case folding, emptied-parent cleanup, and the warn-and-keep paths, and backup retention: the sweep a moved-content run drives, the empty root a run whose moves failed gives up, and the populated root retention keeps |
+| `install.profiles.test.mjs` | Profile target-selection and per-target ownership manifest contract tests (main-default, multi-profile, ambiguity/duplicate rejection, help text) |
+| `install.plan.test.mjs` | Read-only plan and preflight tests: zero-write plan construction, source-conflict and missing-Python fail-closed, settings check only when hooks install, tolerant broken-manifest, invalid managed root, mutation-kind list for E2 |
 | `install.prune.test.mjs` | End-to-end prune tests that run the real installer against a sandbox `HOME` — retired-skill, retired-hook, and stale-file moves into one timestamped backup, the settings entry a retired hook loses, the top-level paths every root's diff leaves alone, the manifest record a failed move keeps, the full-install and resolved-dependency gates, backup retention, and the uninstall: the `~/.mypy.ini` removal, the containment guard, and nested-directory cleanup |
 | `git_hooks_installer.test.mjs` | Tests for `git_hooks_installer.mjs` |
 | `install_mypy_ini.test.mjs` | Tests for `install_mypy_ini.mjs` |
@@ -67,9 +76,11 @@ A run that moves nothing sweeps nothing, so every recovery point the user holds
 
 ## Uninstall
 
-`--uninstall` reads the manifest and removes each file it records.
+`--uninstall` builds a read-only uninstall plan, captures a recovery snapshot, then removes each file the plan lists.
 
-Each record passes a containment guard first: the path resolves under `~/.claude`, or it names the `~/.mypy.ini` the install writes in the home directory. Every other record is skipped with a warning and counted. Skipping keeps one malformed record — hand-edited, or written by an installer that ran against a different home — from stranding the user with a half-removed install. The purge removes every legitimate record, clears the manifest, and reports the skipped count.
+Settings JSON is validated before any removal. A malformed or non-object `settings.json` fails closed with the managed files still on disk. Each manifest record passes a containment guard: the path resolves under `~/.claude`, or it names the `~/.mypy.ini` the install writes in the home directory. Every other record is skipped with a warning and counted. Skipping keeps one malformed record — hand-edited, or written by an installer that ran against a different home — from stranding the user with a half-removed install. The purge removes every legitimate record, clears the manifest, and reports the skipped count.
+
+The uninstall runs inside the same snapshot/restore journal as install: prior settings, manifest, managed files, and `core.hooksPath` restore when a later phase fails, so a retry starts from a complete ownership record. The journal is discarded only after a successful commit.
 
 Removing a file leaves its directory a candidate for cleanup. Once the file loop ends, the purge walks up from each such directory to the managed top-level directory the file sits under (`MANAGED_TOP_LEVEL_DIRECTORY_NAMES`), removing each directory it finds empty. That reaches a nested tree such as `skills/<name>/scripts/`. A record under no managed root gets no walk, so `~/.claude` itself is never a stop root and a directory the installer never wrote stays. A separate pass drops each managed top-level directory the purge empties.
 

package/bin/ever-shipped-skills.mjs

@@ -21,6 +21,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'auditing-claude-config',
     'autoconverge',
     'bdd-protocol',
+    'beat-sheet',
     'bg-agent',
     'bugteam',
     'caveman',
@@ -71,4 +72,5 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'update',
     'usage-pause',
     'verified-build',
+    'split-pr',
 ]);

package/bin/install-plan.mjs

@@ -0,0 +1,402 @@
+/**
+ * Read-only install and uninstall plans for claude-dev-env.
+ *
+ * Builds a frozen plan before any write. E2 consumes the install plan; F consumes
+ * the uninstall plan. Plan construction performs zero writes.
+ *
+ * ::
+ *
+ *     plan = buildInstallPlan({ packageRoot, managedRoot, ... })
+ *     // preflight failed: InstallPlanPreflightError, disk unchanged
+ *     // ok: frozen plan with pythonCommand, priorManifest, mutation kinds
+ *
+ *     uninstallPlan = buildUninstallPlan({ managedRoot, manifestFilePath, ... })
+ *     // malformed settings: fail before any removal
+ *
+ * Install manifest parse stays tolerant. Uninstall validates settings when present.
+ */
+
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { SETTINGS_FILE_NAME } from './install-constants.mjs';
+
+export const PREFLIGHT_ERROR_CODES = Object.freeze({
+    SOURCE_CONFLICTS: 'source_conflicts',
+    MISSING_PYTHON: 'missing_python',
+    MALFORMED_SETTINGS: 'malformed_settings',
+    INVALID_MANAGED_ROOT: 'invalid_managed_root',
+    MISSING_MANIFEST: 'missing_manifest',
+    MALFORMED_MANIFEST: 'malformed_manifest',
+});
+
+export const MISSING_PYTHON_ERROR_MESSAGE =
+    'ERROR: No usable Python 3 found. Install Python 3.8+ from python.org and ensure py, python3, or python is on PATH. On Windows the Microsoft Store python.exe alias is rejected because it cannot run hooks.';
+
+export const MALFORMED_SETTINGS_ERROR_MESSAGE =
+    'ERROR: settings.json is malformed JSON. Fix it and rerun.';
+
+export const SETTINGS_NOT_OBJECT_ERROR_MESSAGE =
+    'ERROR: settings.json holds a value other than a JSON object. Fix it and rerun.';
+
+export const MISSING_MANIFEST_ERROR_MESSAGE =
+    'No installation manifest found. Nothing to uninstall.';
+
+export const MALFORMED_MANIFEST_ERROR_MESSAGE =
+    'ERROR: installation manifest is malformed JSON. Fix it and rerun.';
+
+const MANIFEST_FILES_KEY = 'files';
+const MANIFEST_SKILLS_KEY = 'skills';
+const MANIFEST_MANAGED_PERMISSIONS_KEY = 'managedPermissions';
+
+/**
+ * Preflight failure that leaves the managed installation untouched.
+ */
+export class InstallPlanPreflightError extends Error {
+    /**
+     * @param {string} message
+     * @param {{ code: string, conflicts?: Array<{ statusCode: string, path: string }> }} details
+     */
+    constructor(message, details) {
+        super(message);
+        this.name = 'InstallPlanPreflightError';
+        this.code = details.code;
+        this.conflicts = details.conflicts || [];
+    }
+}
+
+/**
+ * Whether the selected groups install hook files and merge settings.
+ *
+ * @param {string[]|null} selectedGroups
+ * @param {Record<string, object>} installGroups
+ * @returns {boolean}
+ */
+export function planShouldInstallHooks(selectedGroups, installGroups) {
+    if (!selectedGroups) {
+        return true;
+    }
+    return selectedGroups
+        .map((eachName) => installGroups[eachName])
+        .filter(Boolean)
+        .some(
+            (eachGroup) => eachGroup.includeAllHooks
+                || (Array.isArray(eachGroup.includeHookFiles) && eachGroup.includeHookFiles.length > 0),
+        );
+}
+
+/**
+ * Read prior manifest lists without throwing on bad JSON.
+ *
+ * @param {string} manifestFilePath
+ * @param {{ existsSync?: typeof existsSync, readFileSync?: typeof readFileSync }} [io]
+ * @returns {{ files: string[]|null, skills: string[]|null }}
+ */
+function arrayFieldOrNull(record, fieldName) {
+    const fieldValue = record[fieldName];
+    return Array.isArray(fieldValue) ? fieldValue : null;
+}
+
+export function readPriorManifestArraysFromPath(manifestFilePath, io = {}) {
+    const exists = io.existsSync || existsSync;
+    const readFile = io.readFileSync || readFileSync;
+    const missingRecord = { files: null, skills: null };
+    if (!manifestFilePath || !exists(manifestFilePath)) {
+        return missingRecord;
+    }
+    try {
+        const priorManifest = JSON.parse(readFile(manifestFilePath, 'utf8'));
+        return {
+            files: arrayFieldOrNull(priorManifest, MANIFEST_FILES_KEY),
+            skills: arrayFieldOrNull(priorManifest, MANIFEST_SKILLS_KEY),
+        };
+    } catch {
+        return missingRecord;
+    }
+}
+
+/**
+ * Fail when managedRoot is empty or points at a non-directory path.
+ *
+ * @param {string} managedRoot
+ * @param {{ existsSync?: typeof existsSync, statSync?: typeof statSync }} [io]
+ * @returns {void}
+ */
+export function preflightManagedRoot(managedRoot, io = {}) {
+    const exists = io.existsSync || existsSync;
+    const stat = io.statSync || statSync;
+    if (typeof managedRoot !== 'string' || managedRoot.trim() === '') {
+        throw new InstallPlanPreflightError(
+            'ERROR: install managed root is empty or missing.',
+            { code: PREFLIGHT_ERROR_CODES.INVALID_MANAGED_ROOT },
+        );
+    }
+    if (!exists(managedRoot)) {
+        return;
+    }
+    let stats;
+    try {
+        stats = stat(managedRoot);
+    } catch {
+        throw new InstallPlanPreflightError(
+            `ERROR: install managed root is not readable: ${managedRoot}`,
+            { code: PREFLIGHT_ERROR_CODES.INVALID_MANAGED_ROOT },
+        );
+    }
+    if (!stats.isDirectory()) {
+        throw new InstallPlanPreflightError(
+            `ERROR: install managed root is not a directory: ${managedRoot}`,
+            { code: PREFLIGHT_ERROR_CODES.INVALID_MANAGED_ROOT },
+        );
+    }
+}
+
+/**
+ * Parse existing settings.json when the run will merge hooks.
+ *
+ * @param {string} settingsPath
+ * @param {boolean} shouldInstallHooks
+ * @param {{ existsSync?: typeof existsSync, readFileSync?: typeof readFileSync }} [io]
+ * @returns {void}
+ */
+export function preflightSettingsIfNeeded(settingsPath, shouldInstallHooks, io = {}) {
+    if (!shouldInstallHooks) {
+        return;
+    }
+    const exists = io.existsSync || existsSync;
+    const readFile = io.readFileSync || readFileSync;
+    if (!exists(settingsPath)) {
+        return;
+    }
+    const raw = readFile(settingsPath, 'utf8').trim();
+    if (!raw) {
+        return;
+    }
+    let settings;
+    try {
+        settings = JSON.parse(raw);
+    } catch {
+        throw new InstallPlanPreflightError(MALFORMED_SETTINGS_ERROR_MESSAGE, {
+            code: PREFLIGHT_ERROR_CODES.MALFORMED_SETTINGS,
+        });
+    }
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+        throw new InstallPlanPreflightError(SETTINGS_NOT_OBJECT_ERROR_MESSAGE, {
+            code: PREFLIGHT_ERROR_CODES.MALFORMED_SETTINGS,
+        });
+    }
+}
+
+/**
+ * Build a frozen installation plan after read-only preflight.
+ *
+ * @param {{
+ *   packageRoot: string,
+ *   managedRoot: string,
+ *   manifestFilePath: string,
+ *   targetIdentity: string,
+ *   selectedGroups: string[]|null,
+ *   isUpdateRefresh: boolean,
+ *   installGroups: Record<string, object>,
+ *   collectSourceConflicts: (packageRoot: string) => Array<{ statusCode: string, path: string }>,
+ *   detectPythonCommand: () => string|null,
+ *   packageName?: string,
+ *   io?: {
+ *     existsSync?: typeof existsSync,
+ *     readFileSync?: typeof readFileSync,
+ *     statSync?: typeof statSync,
+ *   },
+ * }} input
+ * @returns {Readonly<object>}
+ */
+export function buildInstallPlan(input) {
+    const io = input.io || {};
+    const exists = io.existsSync || existsSync;
+    const packageName = input.packageName || 'claude-dev-env';
+
+    preflightManagedRoot(input.managedRoot, io);
+
+    const priorManifest = readPriorManifestArraysFromPath(input.manifestFilePath, io);
+    const shouldInstallHooks = planShouldInstallHooks(input.selectedGroups, input.installGroups);
+    const settingsPath = join(input.managedRoot, SETTINGS_FILE_NAME);
+
+    const allConflicts = input.collectSourceConflicts(input.packageRoot);
+    if (allConflicts.length > 0) {
+        const conflictLines = allConflicts
+            .map((eachConflict) => `  ${eachConflict.statusCode} ${eachConflict.path}`)
+            .join('\n');
+        throw new InstallPlanPreflightError(
+            `\nERROR: ${packageName} source has unmerged conflicts under ${input.packageRoot}:\n\n`
+            + `${conflictLines}\n\n`
+            + 'Resolve the conflicts in the package source before running the installer.\n'
+            + 'Installing from a conflicted source can copy stale or broken files into ~/.claude/.\n',
+            {
+                code: PREFLIGHT_ERROR_CODES.SOURCE_CONFLICTS,
+                conflicts: allConflicts,
+            },
+        );
+    }
+
+    const pythonCommand = input.detectPythonCommand();
+    if (!pythonCommand) {
+        throw new InstallPlanPreflightError(MISSING_PYTHON_ERROR_MESSAGE, {
+            code: PREFLIGHT_ERROR_CODES.MISSING_PYTHON,
+        });
+    }
+
+    preflightSettingsIfNeeded(settingsPath, shouldInstallHooks, io);
+
+    const isUpdateRefresh = Boolean(input.isUpdateRefresh);
+    const shouldPurgeBeforeReinstall = isUpdateRefresh
+        && !input.selectedGroups
+        && exists(input.manifestFilePath);
+
+    return Object.freeze({
+        packageRoot: input.packageRoot,
+        managedRoot: input.managedRoot,
+        manifestFilePath: input.manifestFilePath,
+        targetIdentity: input.targetIdentity,
+        selectedGroups: input.selectedGroups,
+        isUpdateRefresh,
+        shouldPurgeBeforeReinstall,
+        pythonCommand,
+        shouldInstallHooks,
+        priorManifest: Object.freeze({
+            files: priorManifest.files,
+            skills: priorManifest.skills,
+        }),
+        settingsPath,
+        packageName,
+    });
+}
+
+/**
+ * High-level mutation kinds the executor applies for this plan (E2 surface).
+ *
+ * @param {{
+ *   shouldPurgeBeforeReinstall: boolean,
+ *   shouldInstallHooks: boolean,
+ *   selectedGroups: string[]|null,
+ * }} plan
+ * @returns {ReadonlyArray<string>}
+ */
+export function describeInstallMutations(plan) {
+    /** @type {string[]} */
+    const allMutations = [];
+    if (plan.shouldPurgeBeforeReinstall) {
+        allMutations.push('purge_managed_installation');
+    }
+    allMutations.push('ensure_managed_root', 'copy_content_trees', 'copy_skills');
+    if (plan.shouldInstallHooks) {
+        allMutations.push(
+            'copy_hook_files',
+            'merge_hooks_settings',
+            'install_git_hooks',
+            'install_mypy_ini',
+        );
+    }
+    allMutations.push('copy_claude_hub');
+    if (!plan.selectedGroups) {
+        allMutations.push('prune_retired_and_stale');
+    }
+    allMutations.push('write_manifest');
+    return Object.freeze(allMutations);
+}
+
+/**
+ * Build a frozen uninstall plan after read-only preflight.
+ *
+ * Validates settings.json when present so a malformed file fails before any
+ * managed file is removed. Classifies each manifest path through the caller's
+ * removable-record predicate.
+ *
+ * ::
+ *
+ *     plan = buildUninstallPlan({ managedRoot, manifestFilePath, isRemovableRecord })
+ *     // malformed settings → InstallPlanPreflightError, disk unchanged
+ *     // ok: frozen removableFiles / skippedFiles for the executor
+ *
+ * @param {{
+ *   managedRoot: string,
+ *   manifestFilePath: string,
+ *   requireManifest: boolean,
+ *   isRemovableRecord: (absolutePath: string) => boolean,
+ *   io?: {
+ *     existsSync?: typeof existsSync,
+ *     readFileSync?: typeof readFileSync,
+ *   },
+ * }} input
+ * @returns {Readonly<object>}
+ */
+export function buildUninstallPlan(input) {
+    const io = input.io || {};
+    const exists = io.existsSync || existsSync;
+    const readFile = io.readFileSync || readFileSync;
+    const requireManifest = Boolean(input.requireManifest);
+    const settingsPath = join(input.managedRoot, SETTINGS_FILE_NAME);
+
+    if (!input.manifestFilePath || !exists(input.manifestFilePath)) {
+        if (requireManifest) {
+            throw new InstallPlanPreflightError(MISSING_MANIFEST_ERROR_MESSAGE, {
+                code: PREFLIGHT_ERROR_CODES.MISSING_MANIFEST,
+            });
+        }
+        return Object.freeze({
+            managedRoot: input.managedRoot,
+            manifestFilePath: input.manifestFilePath,
+            settingsPath,
+            manifestExisted: false,
+            removableFiles: Object.freeze([]),
+            skippedFiles: Object.freeze([]),
+            allManifestFiles: Object.freeze([]),
+            managedPermissionDenyEntries: Object.freeze([]),
+            isNoOp: true,
+        });
+    }
+
+    let manifest;
+    try {
+        manifest = JSON.parse(readFile(input.manifestFilePath, 'utf8'));
+    } catch {
+        throw new InstallPlanPreflightError(MALFORMED_MANIFEST_ERROR_MESSAGE, {
+            code: PREFLIGHT_ERROR_CODES.MALFORMED_MANIFEST,
+        });
+    }
+
+    preflightSettingsIfNeeded(settingsPath, true, io);
+
+    const isManifestObject = manifest && typeof manifest === 'object' && !Array.isArray(manifest);
+    const rawFiles = isManifestObject ? manifest[MANIFEST_FILES_KEY] : null;
+    const allManifestFiles = Array.isArray(rawFiles)
+        ? rawFiles.filter((eachPath) => typeof eachPath === 'string' && eachPath.trim() !== '')
+        : [];
+    const rawManagedDeny = isManifestObject
+        ? manifest[MANIFEST_MANAGED_PERMISSIONS_KEY]?.deny
+        : null;
+    const managedPermissionDenyEntries = Array.isArray(rawManagedDeny)
+        ? rawManagedDeny.filter((eachEntry) => typeof eachEntry === 'string' && eachEntry.trim() !== '')
+        : [];
+
+    /** @type {string[]} */
+    const removableFiles = [];
+    /** @type {string[]} */
+    const skippedFiles = [];
+    for (const eachPath of allManifestFiles) {
+        if (input.isRemovableRecord(eachPath)) {
+            removableFiles.push(eachPath);
+        } else {
+            skippedFiles.push(eachPath);
+        }
+    }
+
+    return Object.freeze({
+        managedRoot: input.managedRoot,
+        manifestFilePath: input.manifestFilePath,
+        settingsPath,
+        manifestExisted: true,
+        removableFiles: Object.freeze(removableFiles),
+        skippedFiles: Object.freeze(skippedFiles),
+        allManifestFiles: Object.freeze(allManifestFiles),
+        managedPermissionDenyEntries: Object.freeze(managedPermissionDenyEntries),
+        isNoOp: false,
+    });
+}