@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.4

package/src/helper/{prompt.ts → prompt.js}

@@ -3,7 +3,7 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/prompt.ts')` keeps working while the rest of the tree is still `.js`.
+// caller's `require('../helper/prompt.js')` keeps working while the rest of the tree is still `.js`.
 const fs = require('node:fs');
 
 /**
@@ -15,12 +15,12 @@ const fs = require('node:fs');
  * done when stdin is actually a TTY (a human might still type) and bounded by a deadline (a fd
  * that will genuinely never produce data must still fail closed, not hang forever).
  */
-function readSyncBlocking(fd: number, buf: Buffer): number {
+function readSyncBlocking(fd        , buf        )         {
   const deadline = Date.now() + 5 * 60 * 1000;
   for (;;) {
     try {
       return fs.readSync(fd, buf, 0, buf.length, null);
-    } catch (e: any) {
+    } catch (e     ) {
       if (!process.stdin.isTTY || e.code !== 'EAGAIN' || Date.now() > deadline) throw e;
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
     }
@@ -28,7 +28,7 @@ function readSyncBlocking(fd: number, buf: Buffer): number {
 }
 
 /** true if confirmed (via --force or an explicit y/Y reply) */
-function confirm(message: string, force: boolean): boolean {
+function confirm(message        , force         )          {
   if (force) {
     console.error(`[INFO]  ${message} [auto-confirmed via --force]`);
     return true;
@@ -46,7 +46,7 @@ function confirm(message: string, force: boolean): boolean {
 }
 
 /** Free-text stdin read (e.g. "which backup id?"), matching sync.sh's `read -r reply`. */
-function promptLine(message: string): string {
+function promptLine(message        )         {
   process.stdout.write(message);
   const buf = Buffer.alloc(1024);
   let bytesRead = 0;

package/src/helper/{repo-root.ts → repo-root.js}

@@ -21,9 +21,9 @@ const path = require('node:path');
  *
  * TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
  * native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
- * caller's `require('../helper/repo-root.ts')` keeps working while the rest of the tree is still
+ * caller's `require('../helper/repo-root.js')` keeps working while the rest of the tree is still
  * `.js`. As the highest-fan-out helper, this is the last T1 leaf converted.
  */
-const REPO_ROOT: string = path.resolve(__dirname, '..', '..');
+const REPO_ROOT         = path.resolve(__dirname, '..', '..');
 
 module.exports = { REPO_ROOT };

package/src/helper/{settings-merge.ts → settings-merge.js}

@@ -15,36 +15,36 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/settings-merge.ts')` keeps working while the tree is still `.js`.
+// caller's `require('../helper/settings-merge.js')` keeps working while the tree is still `.js`.
 
-interface HookCommand { command?: unknown }
-interface HookEntry { matcher?: unknown; hooks?: HookCommand[] }
-type Settings = Record<string, any>;
+                                           
+                                                                
+                                    
 
 /** A hook entry's identity is its (matcher, commands) pair — NOT the commands alone. One script is
  * legitimately registered under several matchers for the same event (post-edit-lint.sh runs on
  * both `Edit` and `Write`), so comparing commands only makes those entries indistinguishable and
  * silently collapses them to one during a merge. Position is not usable: it is not stable across
  * a re-render. */
-function hookCommands(entry: HookEntry | null | undefined): string[] {
-  return (entry?.hooks || []).map((hook) => hook?.command).filter((command): command is string => typeof command === 'string');
+function hookCommands(entry                              )           {
+  return (entry?.hooks || []).map((hook) => hook?.command).filter((command)                    => typeof command === 'string');
 }
 
-function sameHookEntry(a: HookEntry | null | undefined, b: HookEntry | null | undefined): boolean {
+function sameHookEntry(a                              , b                              )          {
   if ((a?.matcher ?? null) !== (b?.matcher ?? null)) return false;
   const left = hookCommands(a);
   const right = hookCommands(b);
   return left.length === right.length && left.every((command, index) => command === right[index]);
 }
 
-function isPlainObject(value: any): value is Record<string, any> {
+function isPlainObject(value     )                               {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
 /** Union of managed hook entries into whatever is already registered for an event. Foreign
  * entries keep their relative order and stay first, so a third-party guard that was already
  * intercepting a tool keeps intercepting it. */
-function mergeHookEvent(existing: HookEntry[] | undefined, managed: HookEntry[] | undefined): HookEntry[] {
+function mergeHookEvent(existing                         , managed                         )              {
   const result = Array.isArray(existing) ? existing.slice() : [];
   for (const entry of managed || []) {
     if (!result.some((present) => sameHookEntry(present, entry))) result.push(entry);
@@ -52,9 +52,9 @@ function mergeHookEvent(existing: HookEntry[] | undefined, managed: HookEntry[]
   return result;
 }
 
-function mergeHooks(existing: any, managed: any): Record<string, HookEntry[]> {
+function mergeHooks(existing     , managed     )                              {
   const result = isPlainObject(existing) ? { ...existing } : {};
-  for (const [event, entries] of Object.entries<any>(managed || {})) {
+  for (const [event, entries] of Object.entries     (managed || {})) {
     result[event] = mergeHookEvent(result[event], entries);
   }
   return result;
@@ -70,10 +70,10 @@ function mergeHooks(existing: any, managed: any): Record<string, HookEntry[]> {
  *     install is exactly the surprise this module exists to prevent. Managed keys the file does
  *     not have yet are still added, so a fresh install is unchanged.
  */
-function mergeSettings(existing: any, managed: any): Settings {
+function mergeSettings(existing     , managed     )           {
   if (!isPlainObject(existing)) return managed;
-  const result: Settings = { ...existing };
-  for (const [key, value] of Object.entries<any>(managed || {})) {
+  const result           = { ...existing };
+  for (const [key, value] of Object.entries     (managed || {})) {
     if (key === 'hooks') { result.hooks = mergeHooks(existing.hooks, value); continue; }
     if (!Object.hasOwn(result, key)) { result[key] = value; continue; }
     if (isPlainObject(result[key]) && isPlainObject(value)) result[key] = mergeSettings(result[key], value);
@@ -85,15 +85,15 @@ function mergeSettings(existing: any, managed: any): Settings {
 /** Verification predicate replacing byte-equality: DoFlow's own keys must be present, and every
  * managed hook entry must still be registered. A foreign key, a user-tuned `model`, or an extra
  * hook entry are all legitimate and must NOT read as drift. */
-function settingsContains(current: any, managed: any): boolean {
+function settingsContains(current     , managed     )          {
   if (!isPlainObject(current)) return false;
-  for (const [key, value] of Object.entries<any>(managed || {})) {
+  for (const [key, value] of Object.entries     (managed || {})) {
     if (key === 'hooks') {
-      for (const [event, entries] of Object.entries<any>(value || {})) {
+      for (const [event, entries] of Object.entries     (value || {})) {
         const present = current.hooks?.[event];
         if (!Array.isArray(present)) return false;
         for (const entry of entries || []) {
-          if (!present.some((candidate: HookEntry) => sameHookEntry(candidate, entry))) return false;
+          if (!present.some((candidate           ) => sameHookEntry(candidate, entry))) return false;
         }
       }
       continue;
@@ -108,15 +108,15 @@ function settingsContains(current: any, managed: any): boolean {
  * rmSync'd the whole file, which on a shared settings.json would delete the user's entire
  * own configuration along with DoFlow's contribution. Returns null only when nothing
  * meaningful remains, letting the caller delete a file DoFlow genuinely created. */
-function stripManagedSettings(current: any, managed: any): Settings | null {
+function stripManagedSettings(current     , managed     )                  {
   if (!isPlainObject(current)) return null;
-  const result: Settings = { ...current };
+  const result           = { ...current };
   const managedHooks = managed?.hooks;
   if (isPlainObject(result.hooks) && isPlainObject(managedHooks)) {
-    const hooks: Record<string, HookEntry[]> = {};
-    for (const [event, entries] of Object.entries<any>(result.hooks)) {
+    const hooks                              = {};
+    for (const [event, entries] of Object.entries     (result.hooks)) {
       const remaining = (entries || []).filter(
-        (entry: HookEntry) => !(managedHooks[event] || []).some((owned: HookEntry) => sameHookEntry(owned, entry)),
+        (entry           ) => !(managedHooks[event] || []).some((owned           ) => sameHookEntry(owned, entry)),
       );
       if (remaining.length) hooks[event] = remaining;
     }
@@ -126,7 +126,7 @@ function stripManagedSettings(current: any, managed: any): Settings | null {
   // nothing has touched it since. A key the user changed no longer matches and is left alone.
   // Without this, a file DoFlow created outright (keybindings.json, which has no hooks at all)
   // would survive `remove` fully intact and read as a resource that refused to go away.
-  for (const [key, value] of Object.entries<any>(managed || {})) {
+  for (const [key, value] of Object.entries     (managed || {})) {
     if (key === 'hooks') continue;
     if (Object.hasOwn(result, key) && JSON.stringify(result[key]) === JSON.stringify(value)) delete result[key];
   }
@@ -138,12 +138,12 @@ function stripManagedSettings(current: any, managed: any): Settings | null {
  * non-hook managed keys are ordinary settings that survive a remove and are indistinguishable
  * from the user's own, so they cannot signal DoFlow's presence. Lets verification tell "removed"
  * (none of ours left) apart from "damaged" (some of ours left, some missing). */
-function settingsContainsAny(current: any, managed: any): boolean {
+function settingsContainsAny(current     , managed     )          {
   if (!isPlainObject(current)) return false;
-  for (const [event, entries] of Object.entries<any>(managed?.hooks || {})) {
+  for (const [event, entries] of Object.entries     (managed?.hooks || {})) {
     const present = current.hooks?.[event];
     if (!Array.isArray(present)) continue;
-    if ((entries || []).some((entry: HookEntry) => present.some((candidate: HookEntry) => sameHookEntry(candidate, entry)))) return true;
+    if ((entries || []).some((entry           ) => present.some((candidate           ) => sameHookEntry(candidate, entry)))) return true;
   }
   return false;
 }

package/src/helper/{settings-scope.ts → settings-scope.js}

@@ -1,6 +1,6 @@
 'use strict';
 // settings-scope.js — GLOBAL_HOOK_PREFIX/PROJECT_HOOK_PREFIX are the shared constants the Claude
-// adapter's settings-asset renderer (src/adapters/claude/index.ts#settingsContent) uses to rewrite
+// adapter's settings-asset renderer (src/adapters/claude/index.js#settingsContent) uses to rewrite
 // a project-scoped settings.json's hook `command` paths from the global-only `~/.claude/hooks/`
 // form to Claude Code's documented ${CLAUDE_PROJECT_DIR}/.claude/hooks/ placeholder — see
 // https://code.claude.com/docs/en/hooks. chmodHooksExecutable is a defensive final pass: an
@@ -10,7 +10,7 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/settings-scope.ts')` keeps working while the tree is still `.js`.
+// caller's `require('../helper/settings-scope.js')` keeps working while the tree is still `.js`.
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -19,7 +19,7 @@ const PROJECT_HOOK_PREFIX = '${CLAUDE_PROJECT_DIR}/.claude/hooks/';
 
 /** Adds ugo+x (relative — preserves existing bits), not an absolute mode — a hook file copied in
  * at 664/775 must stay that way, only gaining +x. */
-function chmodHooksExecutable(claudeDir: string): void {
+function chmodHooksExecutable(claudeDir        )       {
   const hooksDir = path.join(claudeDir, 'hooks');
   if (!fs.existsSync(hooksDir)) return;
   for (const f of fs.readdirSync(hooksDir)) {

package/src/helper/{toml.ts → toml.js}

@@ -8,37 +8,37 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/toml.ts')` keeps working while the rest of the tree is still `.js`.
+// caller's `require('../helper/toml.js')` keeps working while the rest of the tree is still `.js`.
 
-type TomlScalar = string | number | boolean;
+                                            
 
-interface TomlEntry {
-  value: TomlScalar;
-  line: number;
-  table: string;
-}
+                     
+                    
+               
+                
+ 
 
-interface TomlHeader {
-  line: number;
-  table: string;
-}
+                      
+               
+                
+ 
 
-interface ParsedToml {
-  lines: string[];
-  entries: Map<string, TomlEntry>;
-  headers: TomlHeader[];
-}
+                      
+                  
+                                  
+                        
+ 
 
-type TableViolationKind = 'duplicate-table' | 'table-and-value';
+                                                                
 
-interface TableViolation {
-  kind: TableViolationKind;
-  table: string;
-  line: number;
-}
+                          
+                           
+                
+               
+ 
 
-function stripComment(line: string): string {
-  let quote: string | null = null;
+function stripComment(line        )         {
+  let quote                = null;
   let escape = false;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
@@ -52,8 +52,8 @@ function stripComment(line: string): string {
   return line;
 }
 
-function splitAssignment(line: string): [string, string] | null {
-  let quote: string | null = null;
+function splitAssignment(line        )                          {
+  let quote                = null;
   let escape = false;
   let depth = 0;
   for (let i = 0; i < line.length; i++) {
@@ -72,8 +72,8 @@ function splitAssignment(line: string): [string, string] | null {
   return null;
 }
 
-function balanced(value: string): boolean {
-  let quote: string | null = null;
+function balanced(value        )          {
+  let quote                = null;
   let escape = false;
   let depth = 0;
   for (const char of value) {
@@ -91,7 +91,7 @@ function balanced(value: string): boolean {
   return !quote && depth === 0;
 }
 
-function parseValue(raw: string): TomlScalar {
+function parseValue(raw        )             {
   const value = raw.trim();
   if (!value || !balanced(value)) throw new Error('invalid TOML value');
   if (value === 'true') return true;
@@ -116,14 +116,14 @@ const BARE_KEY = /^[A-Za-z0-9_-]+$/;
  *
  * A dot *inside* a quoted segment is legal TOML (`"gpt-5.5" = 4`) and is preserved — see
  * flattenKeyPath for how it is kept from colliding with a genuine path separator. */
-function parseKeyPath(raw: string): string[] | null {
-  const segments: string[] = [];
+function parseKeyPath(raw        )                  {
+  const segments           = [];
   let i = 0;
   const skipSpace = () => { while (i < raw.length && (raw[i] === ' ' || raw[i] === '\t')) i += 1; };
   skipSpace();
   if (i >= raw.length) return null;
   while (i < raw.length) {
-    let segment: string;
+    let segment        ;
     const quote = raw[i];
     if (quote === '"' || quote === "'") {
       i += 1;
@@ -158,18 +158,18 @@ function parseKeyPath(raw: string): string[] | null {
  * `["a.b"]` and `[a.b]` collide and a surgical edit could rewrite the wrong line. Managed
  * identities (normaliseDesired) are bare-key-only, so their flattened form is unchanged and
  * lookups against them still match. */
-function flattenKeyPath(segments: string[]): string {
+function flattenKeyPath(segments          )         {
   return segments.map((segment) => segment.replace(/\\/g, '\\\\').replace(/\./g, '\\.')).join('.');
 }
 
 /** A conservative TOML scanner. It validates the subset needed to safely locate scalar keys;
  * unsupported multi-line syntax fails closed rather than risking a destructive rewrite. `headers`
  * lists each table header line in file order, so a caller never re-detects headers itself. */
-function parseToml(text: string): ParsedToml {
+function parseToml(text        )             {
   const lines = text.split(/\r?\n/);
-  let table: string[] = [];
-  const entries = new Map<string, TomlEntry>();
-  const headers: TomlHeader[] = [];
+  let table           = [];
+  const entries = new Map                   ();
+  const headers               = [];
   for (let index = 0; index < lines.length; index++) {
     const clean = stripComment(lines[index]).trim();
     if (!clean) continue;
@@ -188,7 +188,7 @@ function parseToml(text: string): ParsedToml {
     if (!assignment) throw new Error(`Malformed TOML assignment on line ${index + 1}`);
     const keyPath = parseKeyPath(assignment[0].trim());
     if (!keyPath) throw new Error(`Unsupported TOML key on line ${index + 1}`);
-    let value: TomlScalar;
+    let value            ;
     try { value = parseValue(assignment[1]); } catch { throw new Error(`Malformed TOML value on line ${index + 1}`); }
     const fullKey = flattenKeyPath([...table, ...keyPath]);
     if (entries.has(fullKey)) throw new Error(`Duplicate TOML key '${fullKey}'`);
@@ -202,33 +202,33 @@ function parseToml(text: string): ParsedToml {
  * keys already defined it; `table-and-value` when one path is both a key's value and a table (by a
  * header, or implied by a longer dotted key). `line` is the 1-based line of the second definition.
  * Throws what parseToml throws. */
-function tableViolations(text: string): TableViolation[] {
+function tableViolations(text        )                   {
   parseToml(text);
   const lines = text.split(/\r?\n/);
-  const violations: TableViolation[] = [];
-  const opened = new Set<string>();
-  const dotted = new Set<string>();
-  const tables = new Set<string>();
-  const values = new Set<string>();
-  const asTable = (segments: string[], line: number) => {
+  const violations                   = [];
+  const opened = new Set        ();
+  const dotted = new Set        ();
+  const tables = new Set        ();
+  const values = new Set        ();
+  const asTable = (segments          , line        ) => {
     const flat = flattenKeyPath(segments);
     if (values.has(flat)) violations.push({ kind: 'table-and-value', table: flat, line });
     tables.add(flat);
   };
-  let table: string[] = [];
+  let table           = [];
   for (let index = 0; index < lines.length; index++) {
     const clean = stripComment(lines[index]).trim();
     if (!clean) continue;
     const tableMatch = clean.match(/^\[(.+)\]$/);
     if (tableMatch) {
-      table = parseKeyPath(tableMatch[1].trim())!;
+      table = parseKeyPath(tableMatch[1].trim()) ;
       const flat = flattenKeyPath(table);
       if (opened.has(flat) || dotted.has(flat)) violations.push({ kind: 'duplicate-table', table: flat, line: index + 1 });
       opened.add(flat);
       for (let length = 1; length <= table.length; length++) asTable(table.slice(0, length), index + 1);
       continue;
     }
-    const keyPath = parseKeyPath(splitAssignment(clean)![0].trim())!;
+    const keyPath = parseKeyPath(splitAssignment(clean) [0].trim()) ;
     for (let length = 1; length < keyPath.length; length++) {
       const segments = [...table, ...keyPath.slice(0, length)];
       dotted.add(flattenKeyPath(segments));

package/src/install/{backup-set.ts → backup-set.js}

@@ -11,25 +11,25 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../install/backup-set.ts')` keeps working while the tree is still `.js`. The
+// caller's `require('../install/backup-set.js')` keeps working while the tree is still `.js`. The
 // `./backup` require carries `.ts` because backup migrated in the same slice.
 const fs = require('node:fs');
 const path = require('node:path');
-const { BackupError, scopeRelative } = require('./backup.ts');
+const { BackupError, scopeRelative } = require('./backup.js');
 
 const REASON_ORDER = ['change', 'companion', 'relocated-from', 'tombstone', 'snapshot', 'record'];
 
-function byCodePoint(a: string, b: string): number {
+function byCodePoint(a        , b        )         {
   if (a === b) return 0;
   return a < b ? -1 : 1;
 }
 
 /** What a set entry is on disk now, following links. */
-function statEntry(file: string, fsImpl: any): { kind: string; size: number | null; mode: number | null } {
+function statEntry(file        , fsImpl     )                                                             {
   let stat;
   try {
     stat = fsImpl.statSync(file);
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return { kind: 'absent', size: null, mode: null };
     throw new BackupError(`could not read ${file}: ${err.code || err.message}`);
   }
@@ -37,19 +37,19 @@ function statEntry(file: string, fsImpl: any): { kind: string; size: number | nu
   return { kind: 'other', size: null, mode: null };
 }
 
-function isAtOrUnder(file: string, root: string): boolean {
+function isAtOrUnder(file        , root        )          {
   const resolved = path.resolve(root);
   return file === resolved || file.startsWith(resolved.endsWith(path.sep) ? resolved : resolved + path.sep);
 }
 
 /** Candidates (absolute path -> harnesses and reasons) into a BackupSet, after the exclusions.
  * A path in `records` is kept even under an excluded root. */
-function toBackupSet(candidates: Map<string, any>, { scope, scopeRoot, exclude, excluded, records = [], fsImpl }: any): any {
+function toBackupSet(candidates                  , { scope, scopeRoot, exclude, excluded, records = [], fsImpl }     )      {
   const root = path.resolve(scopeRoot);
-  const kept = new Set(records.map((file: string) => path.resolve(file)));
+  const kept = new Set(records.map((file        ) => path.resolve(file)));
   const entries = [];
   for (const file of [...candidates.keys()].sort(byCodePoint)) {
-    if (!kept.has(file) && exclude.some((x: string) => isAtOrUnder(file, x))) {
+    if (!kept.has(file) && exclude.some((x        ) => isAtOrUnder(file, x))) {
       excluded.push({ path: file, reason: 'doflow-state' });
       continue;
     }
@@ -67,15 +67,15 @@ function toBackupSet(candidates: Map<string, any>, { scope, scopeRoot, exclude,
     scope,
     scopeRoot: root,
     entries,
-    excluded: excluded.sort((a: any, b: any) => byCodePoint(a.path, b.path)),
+    excluded: excluded.sort((a     , b     ) => byCodePoint(a.path, b.path)),
     count: entries.length,
     existing: files.length,
     absent: entries.filter((e) => e.kind === 'absent').length,
-    bytes: files.reduce((sum, e) => sum + (e.size as number), 0),
+    bytes: files.reduce((sum, e) => sum + (e.size          ), 0),
   };
 }
 
-function addCandidate(candidates: Map<string, any>, file: string, harness: string | null, reason: string): void {
+function addCandidate(candidates                  , file        , harness               , reason        )       {
   const key = path.resolve(file);
   if (!candidates.has(key)) candidates.set(key, { harnesses: new Set(), reasons: new Set() });
   const item = candidates.get(key);
@@ -92,13 +92,13 @@ function addCandidate(candidates: Map<string, any>, file: string, harness: strin
  * it writes back (backup.ts mergeRestoredLedger). They join only a set that holds some file already,
  * so a run that backs up nothing still backs up nothing.
  */
-function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }: any): any {
+function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }     )      {
   const candidates = new Map();
   const mcpOnly = new Map();
   const resources = plan.ledger?.resources ?? [];
   const tombstones = plan.ledger?.tombstones ?? [];
   // A retained or released change gives up a ledger row and touches no file.
-  const changes = plan.changes.filter((change: any) => change.retained !== true && change.release !== true);
+  const changes = plan.changes.filter((change     ) => change.retained !== true && change.release !== true);
 
   for (const change of changes) {
     const target = path.resolve(change.target);
@@ -121,7 +121,7 @@ function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [],
     }
   }
 
-  const owned = new Set(resources.filter((r: any) => typeof r.target === 'string').map((r: any) => path.resolve(r.target)));
+  const owned = new Set(resources.filter((r     ) => typeof r.target === 'string').map((r     ) => path.resolve(r.target)));
   for (const tombstone of tombstones) {
     if (tombstone.sweptAt || typeof tombstone.fromTarget !== 'string') continue;
     if (owned.has(path.resolve(tombstone.fromTarget)) || !fsImpl.existsSync(tombstone.fromTarget)) continue;
@@ -137,7 +137,7 @@ function backupSetFromPlan({ plan, scope, scopeRoot, exclude = [], records = [],
 
 /** A BackupSet of the given absolute paths, for the pre-rollback snapshot. `records` as for
  * backupSetFromPlan: a restored ledger is snapshotted too, so the snapshot rolls back as a whole. */
-function backupSetFromPaths({ items, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }: any): any {
+function backupSetFromPaths({ items, scope, scopeRoot, exclude = [], records = [], fsImpl = fs }     )      {
   const candidates = new Map();
   for (const item of items) {
     if (item.harnesses.length === 0) addCandidate(candidates, item.path, null, 'snapshot');