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

package/src/helper/{harness-paths.ts → harness-paths.js}

@@ -28,33 +28,33 @@
 //
 // 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/harness-paths.ts')` keeps working while the tree is still `.js`. The
+// caller's `require('../helper/harness-paths.js')` keeps working while the tree is still `.js`. The
 // `./repo-root` require stays bare while repo-root is still `.js`.
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('./repo-root.ts');
+const { REPO_ROOT } = require('./repo-root.js');
 
 const PATH_BASES = new Set(['root', 'home']);
 const SURFACE_NAME = /^[a-z][a-zA-Z0-9]*$/;
 const SEGMENT = /^(?!\.\.$)[^\\/]+$/;
 const SCOPES = ['project', 'user'];
 
-interface PathRule {
-  base?: string;
-  segments?: string[];
-}
+                    
+                
+                      
+ 
 
-interface ResolveInputs {
-  scope?: string;
-  scopeRoot?: string;
-  homeDir?: string;
-}
+                         
+                 
+                     
+                   
+ 
 
-function issue(errors: string[], location: string, message: string): void { errors.push(`${location}: ${message}`); }
+function issue(errors          , location        , message        )       { errors.push(`${location}: ${message}`); }
 
 /** Validate one {base, segments} rule. Returns errors via the pushed array. */
-function validateRule(rule: any, location: string, errors: string[]): void {
+function validateRule(rule     , location        , errors          )       {
   if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
     issue(errors, location, 'must be an object'); return;
   }
@@ -63,7 +63,7 @@ function validateRule(rule: any, location: string, errors: string[]): void {
   }
   if (!PATH_BASES.has(rule.base)) issue(errors, location, `base must be one of ${[...PATH_BASES].join(', ')}`);
   const segments = rule.segments;
-  if (!Array.isArray(segments) || segments.some((segment: any) => typeof segment !== 'string' || !SEGMENT.test(segment))) {
+  if (!Array.isArray(segments) || segments.some((segment     ) => typeof segment !== 'string' || !SEGMENT.test(segment))) {
     issue(errors, location, "segments must be an array of plain single path segments (no '/', no '\\', no '..')");
   }
 }
@@ -71,12 +71,12 @@ function validateRule(rule: any, location: string, errors: string[]): void {
 /** Validate one harness's whole paths section. Unknown keys and malformed rules are rejected
  * loudly: a typo'd declaration must fail the registry load, not silently fall back to whatever
  * the adapter used to hardcode. Returns an array of error messages (empty when valid). */
-function validatePathsSection(section: any, location: string): string[] {
-  const errors: string[] = [];
+function validatePathsSection(section     , location        )           {
+  const errors           = [];
   if (!section || typeof section !== 'object' || Array.isArray(section)) {
     return [`${location}: must be an object`];
   }
-  for (const [name, value] of Object.entries<any>(section)) {
+  for (const [name, value] of Object.entries     (section)) {
     const at = `${location}.${name}`;
     if (!SURFACE_NAME.test(name)) { issue(errors, at, `surface name '${name}' must be camelCase`); continue; }
     if (!value || typeof value !== 'object' || Array.isArray(value)) { issue(errors, at, 'must be an object'); continue; }
@@ -98,7 +98,7 @@ function validatePathsSection(section: any, location: string): string[] {
 }
 
 /** Resolve one rule to an absolute path. */
-function resolveRule(rule: PathRule, { root, home }: { root: string; home: string }): string {
+function resolveRule(rule          , { root, home }                                )         {
   const base = rule.base === 'home' ? home : root;
   return path.join(base, ...(rule.segments || []));
 }
@@ -109,12 +109,12 @@ function resolveRule(rule: PathRule, { root, home }: { root: string; home: strin
  * Returns { <surface>: absolutePath | null } — null when the scope has no rule for a surface —
  * plus `root`, the scope's install root itself (an input, not a declaration).
  */
-function resolveHarnessPaths(section: any, { scope, scopeRoot, homeDir }: ResolveInputs = {}): Record<string, string | null> {
+function resolveHarnessPaths(section     , { scope, scopeRoot, homeDir }                = {})                                {
   const userScope = scope === 'user' || scope === 'global';
   const home = path.resolve(homeDir || scopeRoot);
   const root = userScope ? home : path.resolve(scopeRoot);
-  const resolved: Record<string, string | null> = { root };
-  for (const [name, value] of Object.entries<any>(section || {})) {
+  const resolved                                = { root };
+  for (const [name, value] of Object.entries     (section || {})) {
     const rule = (value.base !== undefined || value.segments !== undefined)
       ? value
       : (value[userScope ? 'user' : 'project'] ?? null);
@@ -123,16 +123,16 @@ function resolveHarnessPaths(section: any, { scope, scopeRoot, homeDir }: Resolv
   return resolved;
 }
 
-let declaredCache: { repoRoot: string; paths: Record<string, any> } | undefined;
+let declaredCache                                                              ;
 /** Every harness's declared paths section, keyed by harness id, read straight from
  * core/registry/harnesses.json (memoized per process — the file ships inside the package).
  * Adapters default their factories to this, so a factory called with no arguments and the CLI
  * wiring in src/cli/shared.js#buildAdapterRegistry consume byte-identical declarations. */
-function declaredHarnessPaths(repoRoot: string = REPO_ROOT): Record<string, any> {
+function declaredHarnessPaths(repoRoot         = REPO_ROOT)                      {
   if (declaredCache && declaredCache.repoRoot === path.resolve(repoRoot)) return declaredCache.paths;
   const file = path.join(path.resolve(repoRoot), 'core', 'registry', 'harnesses.json');
   const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-  const paths = Object.fromEntries((parsed.harnesses || []).map((harness: any) => [harness.id, harness.paths ?? {}]));
+  const paths = Object.fromEntries((parsed.harnesses || []).map((harness     ) => [harness.id, harness.paths ?? {}]));
   declaredCache = { repoRoot: path.resolve(repoRoot), paths };
   return paths;
 }

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

@@ -5,7 +5,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/marker-merge.ts')` keeps working while the tree is still `.js`.
+// caller's `require('../helper/marker-merge.js')` keeps working while the tree is still `.js`.
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -17,14 +17,14 @@ const MARKER_END = '<!-- doflow:end -->';
  * Merge `srcAbs`'s content into `dstAbs` inside a doflow-owned marker span,
  * preserving any of `dstAbs`'s own content outside that span byte-for-byte.
  */
-function mergeMarkedSection(srcAbs: string, dstAbs: string, { dryRun = false }: { dryRun?: boolean } = {}): { changed: boolean } {
+function mergeMarkedSection(srcAbs        , dstAbs        , { dryRun = false }                       = {})                       {
   const srcContent = fs.readFileSync(srcAbs, 'utf8').replace(/\s+$/, '');
   const section = `${MARKER_START}\n${srcContent}\n${MARKER_END}\n`;
 
   // Read once, reused both for parsing and for the final no-op comparison below.
   const existing = fs.existsSync(dstAbs) ? fs.readFileSync(dstAbs, 'utf8') : null;
 
-  let newContent: string;
+  let newContent        ;
   if (existing === null) {
     newContent = section;
   } else {
@@ -90,7 +90,7 @@ function mergeMarkedSection(srcAbs: string, dstAbs: string, { dryRun = false }:
  * @returns whether a managed span was found and stripped (false if the file doesn't
  *          exist or has no doflow markers — both are no-ops, not errors)
  */
-function removeMarkedSection(file: string): boolean {
+function removeMarkedSection(file        )          {
   if (!fs.existsSync(file)) return false;
   const existing = fs.readFileSync(file, 'utf8');
   const start = existing.indexOf(MARKER_START);

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));