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

package/src/runtime/{c4-project.ts → c4-project.js}

@@ -83,11 +83,11 @@ class Refused extends Error {}
  * Returns the arguments AND how many characters the call occupied, so the caller can resume scanning
  * after the closing paren rather than assuming the macro owned the rest of its line.
  */
-function splitArgs(text: string): { args: string[]; consumed: number; closed: boolean } {
-  const args: string[] = [];
+function splitArgs(text        )                                                        {
+  const args           = [];
   let buf = '';
   let depth = 0;
-  let quote: string | null = null;
+  let quote                = null;
   let consumed = text.length;
   let closed = false;
   for (let i = 0; i < text.length; i += 1) {
@@ -127,9 +127,9 @@ function splitArgs(text: string): { args: string[]; consumed: number; closed: bo
  * line-level transform running ahead of quote state has silently rewritten a label, so the transform
  * moved in here rather than being fixed again where it stood.
  */
-function stripComments(raw: string, state: { inBlock: boolean; openedAt: number }, lineno: number): { text: string; continues: boolean } {
+function stripComments(raw        , state                                        , lineno        )                                       {
   let out = '';
-  let quote: string | null = null;
+  let quote                = null;
   let i = 0;
   let continues = false;
   while (i < raw.length) {
@@ -161,7 +161,7 @@ function stripComments(raw: string, state: { inBlock: boolean; openedAt: number
 
 /** Mermaid delimits a node label with double quotes; an unescaped one inside ends it early and the
  *  rest of the fence stops parsing. `&quot;` is the entity Mermaid documents for this. */
-function escapeLabel(text: any): string {
+function escapeLabel(text     )         {
   return String(text).replace(/"/g, '&quot;');
 }
 
@@ -185,11 +185,11 @@ function escapeLabel(text: any): string {
 const ALIAS = /^[A-Za-z0-9_]+([.-][A-Za-z0-9_]+)*$/;
 
 /** Every refusal carries the file and line, so the one place that formats it owns both. */
-function refuse(ctx: any, lineno: number, message: string): never {
+function refuse(ctx     , lineno        , message        )        {
   throw new Refused(`${ctx.sourcePath}:${lineno}: ${message}`);
 }
 
-function requireAlias(ctx: any, alias: string, lineno: number, role: string): void {
+function requireAlias(ctx     , alias        , lineno        , role        )       {
   if (!ALIAS.test(alias)) {
     refuse(ctx, lineno, `${role} '${alias}' is not a usable node id. Mermaid fails the whole diagram `
       + 'on one it cannot lex, and silently reads one carrying `--` or `-.-` as a LINK instead, '
@@ -197,7 +197,7 @@ function requireAlias(ctx: any, alias: string, lineno: number, role: string): vo
   }
 }
 
-function acceptElement(ctx: any, name: string, args: string[], lineno: number): void {
+function acceptElement(ctx     , name        , args          , lineno        )       {
   if (args.length < 2) refuse(ctx, lineno, `${name} needs an alias and a label`);
   requireAlias(ctx, args[0], lineno, 'alias');
   if (ctx.nodes.has(args[0])) {
@@ -211,7 +211,7 @@ function acceptElement(ctx: any, name: string, args: string[], lineno: number):
 // A boundary opened inside another is that one's CHILD, not a second root. Pushing every boundary
 // onto one flat list rendered the outer one as an empty subgraph and hoisted the inner one to the
 // top level -- dropping a containment the source states and Mermaid supports.
-function acceptBoundary(ctx: any, name: string, args: string[], lineno: number): void {
+function acceptBoundary(ctx     , name        , args          , lineno        )       {
   if (args.length < 2) refuse(ctx, lineno, `${name} needs an alias and a label`);
   requireAlias(ctx, args[0], lineno, 'boundary alias');
   const b = { alias: args[0], label: args[1], members: [], children: [] };
@@ -219,14 +219,14 @@ function acceptBoundary(ctx: any, name: string, args: string[], lineno: number):
   ctx.stack.push(b);
 }
 
-function acceptRelation(ctx: any, name: string, args: string[], lineno: number): void {
+function acceptRelation(ctx     , name        , args          , lineno        )       {
   if (args.length < 2) refuse(ctx, lineno, `${name} needs a source and a target`);
   requireAlias(ctx, args[0], lineno, 'relation source');
   requireAlias(ctx, args[1], lineno, 'relation target');
   ctx.edges.push({ from: args[0], to: args[1], label: args[2] || '', bi: name.startsWith('BiRel') });
 }
 
-function accept(ctx: any, name: string, args: string[], lineno: number): void {
+function accept(ctx     , name        , args          , lineno        )       {
   if (SKIPPED.has(name)) return;
   if (ELEMENTS.has(name)) acceptElement(ctx, name, args, lineno);
   else if (BOUNDARIES.has(name)) acceptBoundary(ctx, name, args, lineno);
@@ -234,7 +234,7 @@ function accept(ctx: any, name: string, args: string[], lineno: number): void {
   else {
     refuse(ctx, lineno, `unrecognized macro '${name}'. The projector refuses rather than skipping `
       + 'it, because a skipped macro would silently shrink the diagram. Add it to the recognized '
-      + 'set in src/runtime/c4-project.ts if the bundled library defines it.');
+      + 'set in src/runtime/c4-project.js if the bundled library defines it.');
   }
 }
 
@@ -246,10 +246,10 @@ function accept(ctx: any, name: string, args: string[], lineno: number): void {
  * is what joins them. A trailing backslash inside a quoted label is therefore not a continuation,
  * and the call it leaves unterminated refuses in the scan rather than absorbing the next line.
  */
-function toLogicalLines(text: string, state: { inBlock: boolean; openedAt: number }): Array<{ raw: string; lineno: number }> {
+function toLogicalLines(text        , state                                        )                                         {
   const rawLines = text.split('\n');
-  const logical: Array<{ raw: string; lineno: number }> = [];
-  let pending: { raw: string; lineno: number } | null = null;
+  const logical                                         = [];
+  let pending                                         = null;
   for (let n = 0; n < rawLines.length; n += 1) {
     const stripped = stripComments(rawLines[n], state, n + 1);
     if (pending === null) pending = { raw: stripped.text, lineno: n + 1 };
@@ -263,7 +263,7 @@ function toLogicalLines(text: string, state: { inBlock: boolean; openedAt: numbe
 }
 
 /** Read every construct one logical line carries, in order. */
-function scanLine(ctx: any, line: string, lineno: number): void {
+function scanLine(ctx     , line        , lineno        )       {
   if (!line || /^[#@!]/.test(line)) return;
   // A line is scanned for constructs only when it BEGINS with one. Scanning every offset of every
   // line turned any free text containing `word (` into a macro candidate, so `title My Diagram
@@ -283,7 +283,7 @@ function scanLine(ctx: any, line: string, lineno: number): void {
       // `Rel(a)` must be ignored the way prose is everywhere else.
       const rest = line.slice(i);
       const hit = [...rest.matchAll(/([A-Za-z_][A-Za-z0-9_]*)\s*\(/g)]
-        .find(([, n]: any) => ELEMENTS.has(n) || BOUNDARIES.has(n) || RELATIONS.has(n));
+        .find(([, n]     ) => ELEMENTS.has(n) || BOUNDARIES.has(n) || RELATIONS.has(n));
       const dropped = hit && !/[A-Za-z0-9]/.test(rest.slice(0, hit.index)) ? hit[1] : null;
       if (dropped) {
         refuse(ctx, lineno, `${dropped}(...) follows text on this line that is not a construct, `
@@ -302,7 +302,7 @@ function scanLine(ctx: any, line: string, lineno: number): void {
   }
 }
 
-function parse(text: string, sourcePath: string): { nodes: Map<string, string>; edges: any[]; boundaries: any[] } {
+function parse(text        , sourcePath        )                                                                  {
   const ctx = { sourcePath, nodes: new Map(), edges: [], boundaries: [], stack: [] };
   const state = { inBlock: false, openedAt: 0 };
   for (const entry of toLogicalLines(text, state)) scanLine(ctx, entry.raw.trim(), entry.lineno);
@@ -315,9 +315,9 @@ function parse(text: string, sourcePath: string): { nodes: Map<string, string>;
   return { nodes: ctx.nodes, edges: ctx.edges, boundaries: ctx.boundaries };
 }
 
-function emit({ nodes, edges, boundaries }: { nodes: Map<string, string>; edges: any[]; boundaries: any[] }, sourceRel: string, digest: string): string {
-  const grouped = new Set<string>();
-  const collect = (list: any[]): void => {
+function emit({ nodes, edges, boundaries }                                                                 , sourceRel        , digest        )         {
+  const grouped = new Set        ();
+  const collect = (list       )       => {
     for (const b of list) {
       for (const a of b.members) grouped.add(a);
       collect(b.children);
@@ -330,7 +330,7 @@ function emit({ nodes, edges, boundaries }: { nodes: Map<string, string>; edges:
     '```mermaid',
     'flowchart TB',
   ];
-  const renderBoundary = (b: any, indent: string): void => {
+  const renderBoundary = (b     , indent        )       => {
     out.push(`${indent}subgraph ${b.alias}["${escapeLabel(b.label)}"]`);
     for (const a of b.members) out.push(`${indent}    ${a}["${escapeLabel(nodes.get(a) ?? a)}"]`);
     for (const child of b.children) renderBoundary(child, `${indent}    `);
@@ -348,7 +348,7 @@ function emit({ nodes, edges, boundaries }: { nodes: Map<string, string>; edges:
   return `${out.join('\n')}\n`;
 }
 
-function project(text: string, sourceRel: string = '<source>'): { block: string; digest: string } {
+function project(text        , sourceRel         = '<source>')                                    {
   const digest = crypto.createHash('sha256').update(text, 'utf8').digest('hex').slice(0, 12);
   return { block: emit(parse(text, sourceRel), sourceRel, digest), digest };
 }
@@ -360,11 +360,11 @@ module.exports = {
 if (require.main === module) {
   const file = process.argv[2];
   if (!file) { process.stderr.write('usage: c4-project.ts <file.puml>\n'); process.exit(2); }
-  let text: string;
+  let text        ;
   try { text = fs.readFileSync(file, 'utf8'); }
-  catch (err: any) { process.stderr.write(`c4-project: cannot read ${file}: ${err.message}\n`); process.exit(2); }
+  catch (err     ) { process.stderr.write(`c4-project: cannot read ${file}: ${err.message}\n`); process.exit(2); }
   try { process.stdout.write(project(text, file).block); }
-  catch (err: any) {
+  catch (err     ) {
     if (err instanceof Refused) { process.stderr.write(`c4-project: ${err.message}\n`); process.exit(1); }
     throw err;
   }

package/src/runtime/{capability-router.ts → capability-router.js}

@@ -5,39 +5,39 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
-const { validateCapabilityProviders } = require('../registry/index.ts');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+const { validateCapabilityProviders } = require('../registry/index.js');
 
 // Mirrors bin/doflow.js's own REPO_ROOT computation, relative to this file's location, so
 // handleRouteCommand resolves the same repo root it did before relocation. (D8)
 
 /** POSIX single-quote escaping, for the DISPLAY string only — execution always uses the argv
  * vector, never a shell string, so retrieved data can never become shell syntax (review R5). */
-function shellQuote(word: any): string {
+function shellQuote(word     )         {
   const text = String(word);
   if (text !== '' && /^[A-Za-z0-9_@%+=:,.\/-]+$/.test(text)) return text;
   return `'${text.replace(/'/g, `'\\''`)}'`;
 }
 
-function parseYamlFile(filePath: string, fsImpl: any = fs): any {
+function parseYamlFile(filePath        , fsImpl      = fs)      {
   try {
     const text = fsImpl.readFileSync(filePath, 'utf8');
     return JSON.parse(text);
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`Failed to parse registry file '${filePath}': ${error.message}`);
   }
 }
 
 class CapabilityRouter {
-  fsImpl: any;
-  repoRoot: string;
-  projectRoot: string;
-  registryDir: string;
-  binaryChecker: ((binary: string) => boolean) | null;
-  binaryCache: Map<string, boolean>;
-  capabilities!: Record<string, any>;
-  routes!: Record<string, any>;
+  fsImpl     ;
+  repoRoot        ;
+  projectRoot        ;
+  registryDir        ;
+  binaryChecker                                      ;
+  binaryCache                      ;
+  capabilities                      ;
+  routes                      ;
 
   /**
    * @param {Object} [options]
@@ -48,7 +48,7 @@ class CapabilityRouter {
    * @param {Object} [options.fsImpl]
    * @param {Function} [options.binaryChecker]
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.fsImpl = options.fsImpl || fs;
     this.repoRoot = options.repoRoot || REPO_ROOT;
     // Two roots, deliberately distinct (review A3, surfaced by R5's tests): `repoRoot` locates the
@@ -68,7 +68,7 @@ class CapabilityRouter {
     }
   }
 
-  loadRegistries(): void {
+  loadRegistries()       {
     const capsPath = path.join(this.registryDir, 'capabilities.json');
     const routesPath = path.join(this.registryDir, 'routes.json');
     
@@ -78,7 +78,7 @@ class CapabilityRouter {
     this.capabilities = capsData.capabilities || {};
     // A provider without a valid `sourceMode` cannot be told apart from an index-backed one, so the
     // file is refused whole rather than loaded with a guess (068).
-    const providerErrors: string[] = [];
+    const providerErrors           = [];
     validateCapabilityProviders(this.capabilities, providerErrors);
     if (providerErrors.length > 0) {
       throw new Error(`Invalid registry file '${capsPath}':\n- ${providerErrors.join('\n- ')}`);
@@ -91,13 +91,13 @@ class CapabilityRouter {
    * @param {string} binary
    * @returns {boolean}
    */
-  isBinaryAvailable(binary: string): boolean {
+  isBinaryAvailable(binary        )          {
     if (!binary) return false;
     if (this.binaryChecker) {
       return this.binaryChecker(binary);
     }
     if (this.binaryCache.has(binary)) {
-      return this.binaryCache.get(binary) as boolean;
+      return this.binaryCache.get(binary)           ;
     }
     try {
       const isWin = process.platform === 'win32';
@@ -116,7 +116,7 @@ class CapabilityRouter {
    * @param {Array<string>} checkCommand
    * @returns {{ ok: boolean, output?: string, error?: string }}
    */
-  executeSmokeCheck(checkCommand: any): { ok: boolean; output?: string; error?: string } {
+  executeSmokeCheck(checkCommand     )                                                   {
     if (!Array.isArray(checkCommand) || checkCommand.length === 0) {
       return { ok: true };
     }
@@ -128,7 +128,7 @@ class CapabilityRouter {
         stdio: ['ignore', 'pipe', 'pipe'],
       });
       return { ok: true, output: stdout.trim() };
-    } catch (error: any) {
+    } catch (error     ) {
       return { ok: false, error: error.message };
     }
   }
@@ -139,13 +139,13 @@ class CapabilityRouter {
    * @param {boolean} [deepCheck=false]
    * @returns {{ status: 'HEALTHY'|'UNAVAILABLE', details?: string }}
    */
-  evaluateProviderHealth(provider: any, deepCheck: boolean = false): any {
+  evaluateProviderHealth(provider     , deepCheck          = false)      {
     if (!provider) return { status: 'UNAVAILABLE', details: 'No provider declared' };
 
     // Declared / installed / responsive are DISTINCT facts (review R5): `facts` reports each one
     // as true, false, or null-for-not-measured, so "healthy" can never silently mean only
     // "declared in the registry". The summary `status` stays for existing callers.
-    const facts: { declared: boolean; installed: boolean | null; responsive: boolean | null } = { declared: true, installed: null, responsive: null };
+    const facts                                                                               = { declared: true, installed: null, responsive: null };
 
     // `native.test` has no binary — its installedness is whether this project's manifests declare
     // a test command at all. Reporting HEALTHY without that check routed verify-runtime-behavior
@@ -205,16 +205,16 @@ class CapabilityRouter {
    * @param {boolean} [options.deepCheck=false]
    * @returns {{ capabilityId: string, provider: Object|null, status: string, fallbackProviders: Array<Object> }}
    */
-  resolveCapability(capabilityId: string, { deepCheck = false }: { deepCheck?: boolean } = {}): any {
+  resolveCapability(capabilityId        , { deepCheck = false }                          = {})      {
     const capability = this.capabilities[capabilityId];
     if (!capability) {
       throw new Error(`Unknown capability '${capabilityId}'`);
     }
 
     const providers = capability.providers || [];
-    let selectedProvider: any = null;
+    let selectedProvider      = null;
     let selectedStatus = 'UNAVAILABLE';
-    const fallbackProviders: any[] = [];
+    const fallbackProviders        = [];
 
     for (let i = 0; i < providers.length; i++) {
       const prov = providers[i];
@@ -255,16 +255,16 @@ class CapabilityRouter {
    * @param {Object} params
    * @returns {Object}
    */
-  formatExecution(intent: string, provider: any, params: any = {}): any {
+  formatExecution(intent        , provider     , params      = {})      {
     const query = params.query || params.symbol || params.concept || '';
     const targetPath = params.path || '.';
     // The MCP tool name comes from the provider's registry descriptor (`mcp: {server, tool}`), so a
     // new MCP-backed provider needs no code change here. A caller may pass a bare `{ id }`, so fall
     // back to the registry entry with that id.
     const mcp = provider.mcp
-      || Object.values(this.capabilities).flatMap((cap: any) => cap.providers || []).find((p: any) => p.id === provider.id && p.mcp)?.mcp;
+      || Object.values(this.capabilities).flatMap((cap     ) => cap.providers || []).find((p     ) => p.id === provider.id && p.mcp)?.mcp;
     const mcpTool = mcp ? { mcpTool: `mcp__${mcp.server}__${mcp.tool}` } : {};
-    const withDisplay = (result: any) => ({ ...mcpTool, ...result, ...(result.argv ? { cliCommand: result.argv.map(shellQuote).join(' ') } : {}) });
+    const withDisplay = (result     ) => ({ ...mcpTool, ...result, ...(result.argv ? { cliCommand: result.argv.map(shellQuote).join(' ') } : {}) });
 
     if (provider.id === 'semble.search') {
       const content = params.content || 'code';
@@ -338,9 +338,9 @@ class CapabilityRouter {
   /** The project's own test entrypoint, read from its manifests by the shared command detector —
    * the same detector `doflow verify` uses, so the two agree. Returns null when no manifest
    * declares one: a wrong guess here becomes a command the model runs. */
-  detectTestCommand(): string | null {
+  detectTestCommand()                {
     try {
-      const { detectCommands } = require('./command-detect.ts');
+      const { detectCommands } = require('./command-detect.js');
       const detected = detectCommands({ projectRoot: this.projectRoot });
       return detected.commands?.test?.command || null;
     } catch {
@@ -355,7 +355,7 @@ class CapabilityRouter {
    * @param {Object} [options={}]
    * @returns {Object} RetrievalPlan
    */
-  resolveIntent(intentId: string, params: any = {}, { deepCheck = false }: { deepCheck?: boolean } = {}): any {
+  resolveIntent(intentId        , params      = {}, { deepCheck = false }                          = {})      {
     const route = this.routes[intentId];
     if (!route) {
       throw new Error(`Unknown route/intent '${intentId}'`);
@@ -372,7 +372,7 @@ class CapabilityRouter {
         selectedProvider: primaryResolution.provider,
         status: primaryResolution.status,
         execution: this.formatExecution(intentId, primaryResolution.provider, params),
-        fallbackChain: (route.fallback || []).map((fbCap: string) => ({
+        fallbackChain: (route.fallback || []).map((fbCap        ) => ({
           capability: fbCap,
           resolved: this.resolveCapability(fbCap, { deepCheck }),
         })),
@@ -408,7 +408,7 @@ class CapabilityRouter {
       selectedProvider: null,
       status: 'UNAVAILABLE',
       execution: null,
-      fallbackChain: (route.fallback || []).map((cap: string) => ({ capability: cap, status: 'UNAVAILABLE' })),
+      fallbackChain: (route.fallback || []).map((cap        ) => ({ capability: cap, status: 'UNAVAILABLE' })),
     };
   }
 
@@ -417,8 +417,8 @@ class CapabilityRouter {
    * @param {boolean} [deepCheck=false]
    * @returns {Array<Object>}
    */
-  getAllCapabilitiesHealth(deepCheck: boolean = false): any[] {
-    const report: any[] = [];
+  getAllCapabilitiesHealth(deepCheck          = false)        {
+    const report        = [];
     for (const [capId, cap] of Object.entries(this.capabilities)) {
       const resolution = this.resolveCapability(capId, { deepCheck });
       report.push({
@@ -448,16 +448,16 @@ class CapabilityRouter {
  * @param {string} [options.projectRoot]
  * @returns {number} exit code
  */
-function handleRouteCommand({ intent, query, check = false, json = false, projectRoot }: any = {}): number {
+function handleRouteCommand({ intent, query, check = false, json = false, projectRoot }      = {})         {
   const router = new CapabilityRouter({ repoRoot: REPO_ROOT, projectRoot });
   if (typeof intent !== 'string' || intent.trim() === '') {
     return usageError('route', `--intent is required. Declared intents: ${Object.keys(router.routes).join(', ')}`, json);
   }
 
-  let resolution: any;
+  let resolution     ;
   try {
     resolution = router.resolveIntent(intent, { query, path: projectRoot || '.' }, { deepCheck: check });
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('route', `${error.message}. Declared intents: ${Object.keys(router.routes).join(', ')}`, json, error);
   }
 

package/src/runtime/{checkouts.ts → checkouts.js}

@@ -5,7 +5,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
-const { BASE_FILE } = require('./worktree.ts');
+const { BASE_FILE } = require('./worktree.js');
 
 // The checkouts of one repository: the main working tree and its linked worktrees.
 //
@@ -15,9 +15,9 @@ const { BASE_FILE } = require('./worktree.ts');
 // source that names every checkout, and it is asked once per process.
 
 /** realpath(cwd) -> listCheckouts result. */
-const cache = new Map<string, any>();
+const cache = new Map             ();
 
-function realOrNull(p: string, fsImpl: any): string | null {
+function realOrNull(p        , fsImpl     )                {
   try {
     return fsImpl.realpathSync(p);
   } catch {
@@ -25,7 +25,7 @@ function realOrNull(p: string, fsImpl: any): string | null {
   }
 }
 
-function failed(reason: string, detail: string): any {
+function failed(reason        , detail        )      {
   return {
     ok: false, reason, detail, current: null, main: null, mainReason: null, others: [], isLinked: false, sandbox: false,
   };
@@ -46,17 +46,17 @@ function failed(reason: string, detail: string): any {
  * @returns {{ok: boolean, reason: string|null, detail: string|null, current: string|null, main: string|null,
  *   mainReason: string|null, others: Array<string>, isLinked: boolean, sandbox: boolean}}
  */
-function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }: { cwd: string; exec?: any; fsImpl?: any }): any {
+function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }                                           )      {
   const realCwd = realOrNull(cwd, fsImpl) || path.resolve(cwd);
   if (cache.has(realCwd)) return cache.get(realCwd);
 
-  let res: any;
+  let res     ;
   try {
     res = exec('git', ['-C', realCwd, 'worktree', 'list', '--porcelain'], { encoding: 'utf8', timeout: 10000 });
-  } catch (error: any) {
+  } catch (error     ) {
     res = { error };
   }
-  let result: any;
+  let result     ;
   if (res && res.error) {
     result = res.error.code === 'ENOENT'
       ? failed('git-unavailable', String(res.error.message || '').trim().slice(0, 200))
@@ -71,8 +71,8 @@ function listCheckouts({ cwd, exec = spawnSync, fsImpl = fs }: { cwd: string; ex
   return result;
 }
 
-function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
-  const entries: Array<{ real: string | null; bare: boolean; sandbox: boolean }> = [];
+function fromPorcelain(stdout        , realCwd        , fsImpl     )      {
+  const entries                                                                  = [];
   for (const block of stdout.split(/\n\s*\n/)) {
     const lines = block.split('\n').filter(Boolean);
     if (lines.length === 0 || !lines[0].startsWith('worktree ')) continue;
@@ -84,7 +84,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
     });
   }
 
-  let current: any = null;
+  let current      = null;
   for (const e of entries) {
     if (e.real === null || e.bare) continue;
     if ((realCwd === e.real || realCwd.startsWith(e.real + path.sep)) && (current === null || e.real.length > current.real.length)) {
@@ -93,8 +93,8 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
   }
   const sandbox = Boolean(current && current.sandbox);
   const first = entries[0];
-  let main: string | null = null;
-  let mainReason: string | null = null;
+  let main                = null;
+  let mainReason                = null;
   if (sandbox) mainReason = 'sandbox';
   else if (first && first.bare) mainReason = 'bare';
   else if (!first || first.real === null) mainReason = 'missing';
@@ -102,7 +102,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
 
   const others = sandbox ? [] : entries
     .filter((e) => e.real !== null && !e.bare && !e.sandbox && e !== current)
-    .map((e) => e.real as string);
+    .map((e) => e.real          );
   const currentPath = current ? current.real : null;
   return {
     ok: true,
@@ -118,7 +118,7 @@ function fromPorcelain(stdout: string, realCwd: string, fsImpl: any): any {
 }
 
 /** Forgets every memoized `listCheckouts` result (tests that rebuild a repository in place). */
-function clearCheckoutCache(): void {
+function clearCheckoutCache()       {
   cache.clear();
 }
 
@@ -138,8 +138,8 @@ function clearCheckoutCache(): void {
  * @returns {{status: 'found'|'missing'|'ambiguous', file: string|null, root: string|null,
  *   origin: 'current'|'other'|null, candidates: Array<string>}}
  */
-function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }: { stateRoot: string; relPath: any; exec?: any; fsImpl?: any }): any {
-  const at = (root: string, isCurrent: boolean): string | null => {
+function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }                                                               )      {
+  const at = (root        , isCurrent         )                => {
     const rel = typeof relPath === 'function' ? relPath(root, isCurrent) : relPath;
     for (const candidate of Array.isArray(rel) ? rel : [rel]) {
       if (typeof candidate !== 'string' || candidate === '') continue;
@@ -148,21 +148,21 @@ function findStateFile({ stateRoot, relPath, exec = spawnSync, fsImpl = fs }: {
     }
     return null;
   };
-  const missing = { status: 'missing', file: null, root: null, origin: null, candidates: [] as string[] };
+  const missing = { status: 'missing', file: null, root: null, origin: null, candidates: []             };
 
   const here = at(stateRoot, true);
   if (here) return { status: 'found', file: here, root: stateRoot, origin: 'current', candidates: [] };
 
   const checkouts = listCheckouts({ cwd: stateRoot, exec, fsImpl });
   if (!checkouts.ok || checkouts.sandbox) return missing;
-  const matches: Array<{ file: string; root: string }> = [];
-  for (const root of checkouts.others as string[]) {
+  const matches                                        = [];
+  for (const root of checkouts.others            ) {
     const file = at(root, false);
     if (file) matches.push({ file, root });
   }
   if (matches.length === 0) return missing;
   if (matches.length > 1) {
-    return { status: 'ambiguous', file: null, root: null, origin: null, candidates: matches.map((m: { file: string }) => m.file) };
+    return { status: 'ambiguous', file: null, root: null, origin: null, candidates: matches.map((m                  ) => m.file) };
   }
   return { status: 'found', file: matches[0].file, root: matches[0].root, origin: 'other', candidates: [] };
 }