@travetto/runtime 7.0.0-rc.1 → 7.0.0-rc.2

package/README.md

@@ -51,11 +51,11 @@ class $Runtime {
   /** Main source path */
   get mainSourcePath(): string;
   /** Produce a workspace relative path */
-  workspaceRelative(...rel: string[]): string;
+  workspaceRelative(...parts: string[]): string;
   /** Strip off the workspace path from a file */
   stripWorkspacePath(full: string): string;
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
-  toolPath(...rel: string[]): string;
+  toolPath(...parts: string[]): string;
   /** Resolve single module path */
   modulePath(modulePath: string, overrides?: Record<string, string>): string;
   /** Resolve resource paths */
@@ -145,9 +145,9 @@ export class EnvProp<T> {
   /** Remove value */
   clear(): void;
   /** Export value */
-  export(val?: T | undefined | null): Record<string, string>;
+  export(value?: T | undefined | null): Record<string, string>;
   /** Read value as string */
-  get val(): string | undefined;
+  get value(): string | undefined;
   /** Read value as list */
   get list(): string[] | undefined;
   /** Read value as object */
@@ -204,8 +204,8 @@ export function work() {
 
   try {
     1 / 0;
-  } catch (err) {
-    console.error('Divide by zero', { error: err });
+  } catch (error) {
+    console.error('Divide by zero', { error });
   }
   console.debug('End Work');
 }
@@ -225,12 +225,12 @@ function work() {
     try {
         1 / 0;
     }
-    catch (err) {
-        Δconsole.log({ level: "error", import: mod_1, line: 7, scope: "work", args: ['Divide by zero', { error: err }] });
+    catch (error) {
+        Δconsole.log({ level: "error", import: mod_1, line: 7, scope: "work", args: ['Divide by zero', { error }] });
     }
     Δconsole.log({ level: "debug", import: mod_1, line: 9, scope: "work", args: ['End Work'] });
 }
-Δfunction.registerFunction(work, mod_1, { hash: 1030247697, lines: [1, 10, 2] });
+Δfunction.registerFunction(work, mod_1, { hash: 159357293, lines: [1, 10, 2] });
 ```
 
 #### Filtering Debug
@@ -271,7 +271,7 @@ Common utilities used throughout the framework. Currently [Util](https://github.
 
 **Code: Sample makeTemplate Usage**
 ```typescript
-const tpl = makeTemplate((name: 'age'|'name', val) => `**${name}: ${val}**`); 
+const tpl = makeTemplate((name: 'age'|'name', value) => `**${name}: ${value}**`); 
 tpl`{{age:20}} {{name: 'bob'}}</>;
 // produces
 '**age: 20** **name: bob**'
@@ -287,7 +287,7 @@ export class TimeUtil {
    * Test to see if a string is valid for relative time
    * @param val
    */
-  static isTimeSpan(val: string): val is TimeSpan;
+  static isTimeSpan(value: string): value is TimeSpan;
   /**
    * Returns time units convert to ms
    * @param amount Number of units to extend

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "Runtime for travetto applications.",
   "keywords": [
     "console-manager",
@@ -25,12 +25,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.0-rc.0",
+    "@travetto/manifest": "^7.0.0-rc.1",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/transformer": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/binary.ts

@@ -24,27 +24,27 @@ export class BinaryUtil {
   /** Is ReadableStream */
   static isReadableStream = hasFunction<ReadableStream>('pipeTo');
   /** Is Async Iterable */
-  static isAsyncIterable = (v: unknown): v is AsyncIterable<unknown> =>
-    !!v && (typeof v === 'object' || typeof v === 'function') && Symbol.asyncIterator in v;
+  static isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> =>
+    !!value && (typeof value === 'object' || typeof value === 'function') && Symbol.asyncIterator in value;
 
   /**
-   * Is src a binary type
+   * Is value a binary type
    */
-  static isBinaryType(src: unknown): boolean {
-    return src instanceof Blob || Buffer.isBuffer(src) || this.isReadable(src) ||
-      this.isArrayBuffer(src) || this.isReadableStream(src) || this.isAsyncIterable(src);
+  static isBinaryType(value: unknown): boolean {
+    return value instanceof Blob || Buffer.isBuffer(value) || this.isReadable(value) ||
+      this.isArrayBuffer(value) || this.isReadableStream(value) || this.isAsyncIterable(value);
   }
 
   /**
-   * Generate a proper sha512 hash from a src value
-   * @param src The seed value to build the hash from
-   * @param len The optional length of the hash to generate
+   * Generate a proper sha512 hash from an input value
+   * @param input The seed value to build the hash from
+   * @param length The optional length of the hash to generate
    */
-  static hash(src: string, len: number = -1): string {
+  static hash(input: string, length: number = -1): string {
     const hash = crypto.createHash('sha512');
-    hash.update(src);
+    hash.update(input);
     const digest = hash.digest('hex');
-    return len > 0 ? digest.substring(0, len) : digest;
+    return length > 0 ? digest.substring(0, length) : digest;
   }
 
   /**
@@ -88,7 +88,7 @@ export class BinaryUtil {
   static readableBlob(input: () => (Readable | Promise<Readable>), metadata: BlobMeta = {}): Blob | File {
     const go = (): Readable => {
       const stream = new PassThrough();
-      Promise.resolve(input()).then(v => v.pipe(stream), (err) => stream.destroy(err));
+      Promise.resolve(input()).then(readable => readable.pipe(stream), (error) => stream.destroy(error));
       return stream;
     };
 
@@ -102,7 +102,7 @@ export class BinaryUtil {
       stream: { value: () => ReadableStream.from(go()) },
       arrayBuffer: { value: () => toArrayBuffer(go()) },
       text: { value: () => toText(go()) },
-      bytes: { value: () => toArrayBuffer(go()).then(v => new Uint8Array(v)) },
+      bytes: { value: () => toArrayBuffer(go()).then(buffer => new Uint8Array(buffer)) },
       [BlobMetaSymbol]: { value: metadata }
     });
   }

package/src/console.ts

@@ -27,10 +27,10 @@ export interface ConsoleEvent {
  * @concrete
  */
 export interface ConsoleListener {
-  log(ev: ConsoleEvent): void;
+  log(event: ConsoleEvent): void;
 }
 
-const DEBUG_OG = { formatArgs: debug.formatArgs, log: debug.log };
+const DEBUG_HANDLE = { formatArgs: debug.formatArgs, log: debug.log };
 
 /**
  * Provides a general abstraction against the console.* methods to allow for easier capture and redirection.
@@ -50,7 +50,7 @@ class $ConsoleManager implements ConsoleListener {
   /**
    * List of logging filters
    */
-  #filters: Partial<Record<ConsoleEvent['level'], (x: ConsoleEvent) => boolean>> = {};
+  #filters: Partial<Record<ConsoleEvent['level'], (event: ConsoleEvent) => boolean>> = {};
 
   constructor(listener: ConsoleListener) {
     this.set(listener);
@@ -66,8 +66,8 @@ class $ConsoleManager implements ConsoleListener {
   filter(level: ConsoleEvent['level'], filter?: boolean | ((ctx: ConsoleEvent) => boolean)): void {
     if (filter !== undefined) {
       if (typeof filter === 'boolean') {
-        const v = filter;
-        filter = (): boolean => v;
+        const filterValue = filter;
+        filter = (): boolean => filterValue;
       }
       this.#filters[level] = filter;
     } else {
@@ -90,8 +90,8 @@ class $ConsoleManager implements ConsoleListener {
         args: [util.format(...args)], line: 0, timestamp: new Date()
       });
     } else {
-      debug.formatArgs = DEBUG_OG.formatArgs;
-      debug.log = DEBUG_OG.log;
+      debug.formatArgs = DEBUG_HANDLE.formatArgs;
+      debug.log = DEBUG_HANDLE.log;
     }
   }
 
@@ -111,18 +111,18 @@ class $ConsoleManager implements ConsoleListener {
   /**
    * Handle direct call in lieu of the console.* commands
    */
-  log(ev: ConsoleEvent & { import?: [string, string] }): void {
-    const outEv = {
-      ...ev,
+  log(event: ConsoleEvent & { import?: [string, string] }): void {
+    const result = {
+      ...event,
       timestamp: new Date(),
-      module: ev.module ?? ev.import?.[0],
-      modulePath: ev.modulePath ?? ev.import?.[1]
+      module: event.module ?? event.import?.[0],
+      modulePath: event.modulePath ?? event.import?.[1]
     };
 
-    if (this.#filters[outEv.level] && !this.#filters[outEv.level]!(outEv)) {
+    if (this.#filters[result.level] && !this.#filters[result.level]!(result)) {
       return; // Do nothing
     } else {
-      return this.#listener.log(outEv);
+      return this.#listener.log(result);
     }
   }
 
@@ -141,5 +141,5 @@ class $ConsoleManager implements ConsoleListener {
   }
 }
 
-export const ConsoleManager = new $ConsoleManager({ log(ev): void { console![ev.level](...ev.args); } });
+export const ConsoleManager = new $ConsoleManager({ log(event): void { console![event.level](...event.args); } });
 export const log = ConsoleManager.log.bind(ConsoleManager);

package/src/context.ts

@@ -28,7 +28,7 @@ class $Runtime {
 
   /** Get env name, with support for the default env */
   get env(): string | undefined {
-    return Env.TRV_ENV.val || (!this.production ? this.#idx.manifest.workspace.defaultEnv : undefined);
+    return Env.TRV_ENV.value || (!this.production ? this.#idx.manifest.workspace.defaultEnv : undefined);
   }
 
   /** Are we in development mode */
@@ -43,8 +43,8 @@ class $Runtime {
 
   /** Get debug value */
   get debug(): false | string {
-    const val = Env.DEBUG.val ?? '';
-    return (!val && this.production) || Env.DEBUG.isFalse ? false : val;
+    const value = Env.DEBUG.value ?? '';
+    return (!value && this.production) || Env.DEBUG.isFalse ? false : value;
   }
 
   /** Manifest main */
@@ -68,8 +68,8 @@ class $Runtime {
   }
 
   /** Produce a workspace relative path */
-  workspaceRelative(...rel: string[]): string {
-    return path.resolve(this.workspace.path, ...rel);
+  workspaceRelative(...parts: string[]): string {
+    return path.resolve(this.workspace.path, ...parts);
   }
 
   /** Strip off the workspace path from a file */
@@ -78,23 +78,23 @@ class $Runtime {
   }
 
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
-  toolPath(...rel: string[]): string {
-    rel = rel.flatMap(x => x === '@' ? ['node_modules', this.#idx.manifest.main.name] : [x]);
-    return path.resolve(this.workspace.path, this.#idx.manifest.build.toolFolder, ...rel);
+  toolPath(...parts: string[]): string {
+    parts = parts.flatMap(part => part === '@' ? ['node_modules', this.#idx.manifest.main.name] : [part]);
+    return path.resolve(this.workspace.path, this.#idx.manifest.build.toolFolder, ...parts);
   }
 
   /** Resolve single module path */
   modulePath(modulePath: string, overrides?: Record<string, string>): string {
     const combined = { ...this.#resourceOverrides, ...overrides };
     const [base, sub] = (combined[modulePath] ?? modulePath)
-      .replace(/^([^#]*)(#|$)/g, (_, v, r) => `${this.#moduleAliases[v] ?? v}${r}`)
+      .replace(/^([^#]*)(#|$)/g, (_, module, relativePath) => `${this.#moduleAliases[module] ?? module}${relativePath}`)
       .split('#');
     return path.resolve(this.#idx.getModule(base)?.sourcePath ?? base, sub ?? '.');
   }
 
   /** Resolve resource paths */
   resourcePaths(paths: string[] = []): string[] {
-    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(v => this.modulePath(v)))];
+    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(module => this.modulePath(module)))];
   }
 
   /** Get source for function */
@@ -121,7 +121,7 @@ class $Runtime {
       return fs.readFile(imp, 'utf8').then(JSON.parse);
     }
 
-    if (!ManifestModuleUtil.SOURCE_EXT_RE.test(imp)) {
+    if (!ManifestModuleUtil.SOURCE_EXT_REGEX.test(imp)) {
       if (imp.startsWith('@')) {
         if (/[/].*?[/]/.test(imp)) {
           imp = `${imp}.ts`;
@@ -132,16 +132,16 @@ class $Runtime {
     }
 
     imp = ManifestModuleUtil.withOutputExtension(imp);
-    const res = await import(imp);
-    if (res?.default?.default) {
+    const imported = await import(imp);
+    if (imported?.default?.default) {
       // Unpack default.default, typescript does this in a way that requires recreating the whole object
-      const def = res?.default?.default;
+      const def = imported?.default?.default;
       return Object.defineProperties(castTo({}), {
-        ...Object.getOwnPropertyDescriptors(res),
+        ...Object.getOwnPropertyDescriptors(imported),
         default: { get: () => def, configurable: false }
       });
     }
-    return res;
+    return imported;
   }
 }
 

package/src/env.ts

@@ -9,12 +9,12 @@ export class EnvProp<T> {
   readonly key: string;
   constructor(key: string) { this.key = key; }
 
-  /** Set value according to prop type */
-  set(val: T | undefined | null): void {
-    if (val === undefined || val === null) {
+  /** Set value according to type */
+  set(value: T | undefined | null): void {
+    if (value === undefined || value === null) {
       delete process.env[this.key];
     } else {
-      process.env[this.key] = Array.isArray(val) ? `${val.join(',')}` : `${val}`;
+      process.env[this.key] = Array.isArray(value) ? `${value.join(',')}` : `${value}`;
     }
   }
 
@@ -24,36 +24,36 @@ export class EnvProp<T> {
   }
 
   /** Export value */
-  export(val?: T | undefined | null): Record<string, string> {
+  export(value?: T | undefined | null): Record<string, string> {
     let out: string;
     if (arguments.length === 0) { // If nothing passed in
-      out = `${this.val}`;
-    } else if (val === undefined || val === null) {
+      out = `${this.value}`;
+    } else if (value === undefined || value === null) {
       out = '';
-    } else if (Array.isArray(val)) {
-      out = val.join(',');
-    } else if (typeof val === 'object') {
-      out = Object.entries(val).map(([k, v]) => `${k}=${v}`).join(',');
+    } else if (Array.isArray(value)) {
+      out = value.join(',');
+    } else if (typeof value === 'object') {
+      out = Object.entries(value).map(([key, keyValue]) => `${key}=${keyValue}`).join(',');
     } else {
-      out = `${val}`;
+      out = `${value}`;
     }
     return { [this.key]: out };
   }
 
   /** Read value as string */
-  get val(): string | undefined { return process.env[this.key] || undefined; }
+  get value(): string | undefined { return process.env[this.key] || undefined; }
 
   /** Read value as list */
   get list(): string[] | undefined {
-    const val = this.val;
-    return (val === undefined || val === '') ?
-      undefined : val.split(/[, ]+/g).map(x => x.trim()).filter(x => !!x);
+    const value = this.value;
+    return (value === undefined || value === '') ?
+      undefined : value.split(/[, ]+/g).map(item => item.trim()).filter(item => !!item);
   }
 
   /** Read value as object */
   get object(): Record<string, string> | undefined {
     const items = this.list;
-    return items ? Object.fromEntries(items.map(x => x.split(/[:=]/g))) : undefined;
+    return items ? Object.fromEntries(items.map(item => item.split(/[:=]/g))) : undefined;
   }
 
   /** Add values to list */
@@ -63,35 +63,35 @@ export class EnvProp<T> {
 
   /** Read value as int  */
   get int(): number | undefined {
-    const vi = parseInt(this.val ?? '', 10);
-    return Number.isNaN(vi) ? undefined : vi;
+    const parsed = parseInt(this.value ?? '', 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
   }
 
   /** Read value as boolean */
   get bool(): boolean | undefined {
-    const val = this.val;
-    return (val === undefined || val === '') ? undefined : IS_TRUE.test(val);
+    const value = this.value;
+    return (value === undefined || value === '') ? undefined : IS_TRUE.test(value);
   }
 
   /** Determine if the underlying value is truthy */
   get isTrue(): boolean {
-    return IS_TRUE.test(this.val ?? '');
+    return IS_TRUE.test(this.value ?? '');
   }
 
   /** Determine if the underlying value is falsy */
   get isFalse(): boolean {
-    return IS_FALSE.test(this.val ?? '');
+    return IS_FALSE.test(this.value ?? '');
   }
 
   /** Determine if the underlying value is set */
   get isSet(): boolean {
-    const val = this.val;
-    return val !== undefined && val !== '';
+    const value = this.value;
+    return value !== undefined && value !== '';
   }
 }
 
 type AllType = {
-  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'val' | 'set' | 'clear' | 'isSet' |
+  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'value' | 'set' | 'clear' | 'isSet' |
     (EnvData[K] extends unknown[] ? 'list' | 'add' : never) |
     (Extract<EnvData[K], object> extends never ? never : 'object') |
     (Extract<EnvData[K], number> extends never ? never : 'int') |
@@ -101,10 +101,10 @@ type AllType = {
 
 function delegate<T extends object>(base: T): AllType & T {
   return new Proxy(castTo(base), {
-    get(target, prop): unknown {
-      return typeof prop !== 'string' ? undefined :
-        (prop in base ? base[castKey(prop)] :
-          target[castKey<typeof target>(prop)] ??= castTo(new EnvProp(prop))
+    get(target, property): unknown {
+      return typeof property !== 'string' ? undefined :
+        (property in base ? base[castKey(property)] :
+          target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property))
         );
     }
   });

package/src/error.ts

@@ -28,14 +28,14 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
   static defaultCategory?: ErrorCategory;
 
   /** Convert from JSON object */
-  static fromJSON(e: unknown): AppError | undefined {
-    if (!!e && typeof e === 'object' &&
-      ('message' in e && typeof e.message === 'string') &&
-      ('category' in e && typeof e.category === 'string') &&
-      ('type' in e && typeof e.type === 'string') &&
-      ('at' in e && typeof e.at === 'string')
+  static fromJSON(error: unknown): AppError | undefined {
+    if (!!error && typeof error === 'object' &&
+      ('message' in error && typeof error.message === 'string') &&
+      ('category' in error && typeof error.category === 'string') &&
+      ('type' in error && typeof error.type === 'string') &&
+      ('at' in error && typeof error.at === 'string')
     ) {
-      return new AppError(e.message, castTo<AppErrorOptions<Record<string, unknown>>>(e));
+      return new AppError(error.message, castTo<AppErrorOptions<Record<string, unknown>>>(error));
     }
   }
 
@@ -50,21 +50,21 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
    * @param message The error message
    */
   constructor(
-    ...[message, opts]:
+    ...[message, options]:
       T extends undefined ? ([string] | [string, AppErrorOptions<T>]) : [string, AppErrorOptions<T>]
   ) {
-    super(message, opts?.cause ? { cause: opts.cause } : undefined);
-    this.type = opts?.type ?? this.constructor.name;
-    this.details = opts?.details!;
-    this.category = opts?.category ?? castTo<typeof AppError>(this.constructor).defaultCategory ?? 'general';
-    this.at = new Date(opts?.at ?? Date.now()).toISOString();
+    super(message, options?.cause ? { cause: options.cause } : undefined);
+    this.type = options?.type ?? this.constructor.name;
+    this.details = options?.details!;
+    this.category = options?.category ?? castTo<typeof AppError>(this.constructor).defaultCategory ?? 'general';
+    this.at = new Date(options?.at ?? Date.now()).toISOString();
   }
 
   /**
    * Serializes an error to a basic object
    */
   toJSON(): AppErrorOptions<T> & { message: string } {
-    const res: AppErrorOptions<unknown> = {
+    const options: AppErrorOptions<unknown> = {
       category: this.category,
       ...(this.cause ? { cause: `${this.cause}` } : undefined),
       type: this.type,
@@ -73,6 +73,6 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
     };
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return { message: this.message, ...res as AppErrorOptions<T> };
+    return { message: this.message, ...options as AppErrorOptions<T> };
   }
 }

package/src/exec.ts

@@ -64,18 +64,18 @@ export class ExecUtil {
     }
 
     for (; ;) {
-      const proc = run();
-      const interrupt = (): void => { proc.kill('SIGINT'); };
-      const toMessage = (v: unknown): void => { proc.send?.(v!); };
+      const subProcess = run();
+      const interrupt = (): void => { subProcess.kill('SIGINT'); };
+      const toMessage = (value: unknown): void => { subProcess.send?.(value!); };
 
       // Proxy kill requests
       process.on('message', toMessage);
       if (relayInterrupt) {
         process.on('SIGINT', interrupt);
       }
-      proc.on('message', v => process.send?.(v));
+      subProcess.on('message', value => process.send?.(value));
 
-      const result = await this.getResult(proc, { catch: true });
+      const result = await this.getResult(subProcess, { catch: true });
       if (result.code !== this.RESTART_EXIT_CODE) {
         return result;
       } else {
@@ -101,15 +101,15 @@ export class ExecUtil {
    * represents the entire execution.  On successful completion the promise will resolve, and
    * on failed completion the promise will reject.
    *
-   * @param proc The process to enhance
+   * @param subProcess The process to enhance
    * @param options The options to use to enhance the process
    */
-  static getResult(proc: ChildProcess): Promise<ExecutionResult<string>>;
-  static getResult(proc: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
-  static getResult(proc: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<Buffer>>;
-  static getResult<T extends string | Buffer>(proc: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
-    const _proc: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = proc;
-    const result = _proc[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
+  static getResult(subProcess: ChildProcess): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<Buffer>>;
+  static getResult<T extends string | Buffer>(subProcess: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
+    const typed: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = subProcess;
+    const result = typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: Buffer[] = [];
       const stderr: Buffer[] = [];
       let done = false;
@@ -136,25 +136,25 @@ export class ExecUtil {
         );
       };
 
-      proc.stdout?.on('data', (d: string | Buffer) => stdout.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
-      proc.stderr?.on('data', (d: string | Buffer) => stderr.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
+      subProcess.stdout?.on('data', (data: string | Buffer) => stdout.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
+      subProcess.stderr?.on('data', (data: string | Buffer) => stderr.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
 
-      proc.on('error', (err: Error) =>
-        finish({ code: 1, message: err.message, valid: false }));
+      subProcess.on('error', (error: Error) =>
+        finish({ code: 1, message: error.message, valid: false }));
 
-      proc.on('close', (code: number) =>
+      subProcess.on('close', (code: number) =>
         finish({ code, valid: code === null || code === 0 }));
 
-      if (proc.exitCode !== null) { // We are already done
-        finish({ code: proc.exitCode, valid: proc.exitCode === 0 });
+      if (subProcess.exitCode !== null) { // We are already done
+        finish({ code: subProcess.exitCode, valid: subProcess.exitCode === 0 });
       }
     });
 
-    return castTo(options.catch ? result : result.then(v => {
-      if (v.valid) {
-        return v;
+    return castTo(options.catch ? result : result.then(executionResult => {
+      if (executionResult.valid) {
+        return executionResult;
       } else {
-        throw new Error(v.message);
+        throw new Error(executionResult.message);
       }
     }));
   }

package/src/queue.ts

@@ -54,9 +54,9 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
   /**
    * Throw an error from the queue, rejecting and terminating immediately
    */
-  async throw(e?: Error): Promise<IteratorResult<X>> {
+  async throw(error?: Error): Promise<IteratorResult<X>> {
     this.#done = true;
-    this.#ready.reject(e);
+    this.#ready.reject(error);
     return { value: undefined, done: this.#done };
   }
 }

package/src/resources.ts

@@ -15,9 +15,9 @@ class $RuntimeResources extends FileLoader {
   }
 
   override get searchPaths(): readonly string[] {
-    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.val || this.#mod !== Env.TRV_MODULE.val) {
-      this.#env = Env.TRV_RESOURCES.val!;
-      this.#mod = Env.TRV_MODULE.val!;
+    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.value || this.#mod !== Env.TRV_MODULE.value) {
+      this.#env = Env.TRV_RESOURCES.value!;
+      this.#mod = Env.TRV_MODULE.value!;
       this.#computed = Runtime.resourcePaths();
     }
     return this.#computed;

package/src/shutdown.ts

@@ -40,7 +40,7 @@ export class ShutdownManager {
     this.#ensureExitListeners();
     this.#handlers.push({ handler, scope });
     return () => {
-      const idx = this.#handlers.findIndex(x => x.handler === handler);
+      const idx = this.#handlers.findIndex(item => item.handler === handler);
       if (idx >= 0) {
         this.#handlers.splice(idx, 1);
       }
@@ -61,7 +61,7 @@ export class ShutdownManager {
 
     await Util.queueMacroTask(); // Force the event loop to wait one cycle
 
-    const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.val) ?? 2000;
+    const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.value) ?? 2000;
     const items = this.#handlers.splice(0, this.#handlers.length);
     console.debug('Graceful shutdown: started', { source, timeout, count: items.length });
     const handlers = Promise.all(items.map(async ({ scope, handler }) => {
@@ -73,8 +73,8 @@ export class ShutdownManager {
         if (scope) {
           console.debug('Stopped', { scope });
         }
-      } catch (err) {
-        console.error('Error stopping', { err, scope });
+      } catch (error) {
+        console.error('Error stopping', { error, scope });
       }
     }));
 

package/src/time.ts

@@ -22,8 +22,8 @@ export class TimeUtil {
    * Test to see if a string is valid for relative time
    * @param val
    */
-  static isTimeSpan(val: string): val is TimeSpan {
-    return TIME_PATTERN.test(val);
+  static isTimeSpan(value: string): value is TimeSpan {
+    return TIME_PATTERN.test(value);
   }
 
   /**
@@ -36,12 +36,12 @@ export class TimeUtil {
       return amount.getTime();
     } else if (typeof amount === 'string') {
       const groups: { amount?: string, unit?: TimeUnit } = amount.match(TIME_PATTERN)?.groups ?? {};
-      const amountStr = groups.amount ?? `${amount}`;
+      const amountString = groups.amount ?? `${amount}`;
       unit = groups.unit ?? unit ?? 'ms';
       if (!TIME_UNITS[unit]) {
         return NaN;
       }
-      amount = amountStr.includes('.') ? parseFloat(amountStr) : parseInt(amountStr, 10);
+      amount = amountString.includes('.') ? parseFloat(amountString) : parseInt(amountString, 10);
     }
     return amount * TIME_UNITS[unit ?? 'ms'];
   }
@@ -69,11 +69,11 @@ export class TimeUtil {
     if (value === undefined) {
       return value;
     }
-    const val = (typeof value === 'string' && /\d{1,30}[a-z]$/i.test(value)) ?
+    const result = (typeof value === 'string' && /\d{1,30}[a-z]$/i.test(value)) ?
       (this.isTimeSpan(value) ? this.asMillis(value) : undefined) :
       (typeof value === 'string' ? parseInt(value, 10) :
         (value instanceof Date ? value.getTime() : value));
-    return Number.isNaN(val) ? undefined : val;
+    return Number.isNaN(result) ? undefined : result;
   }
 
   /**
@@ -90,11 +90,11 @@ export class TimeUtil {
    * @param time Time in milliseconds
    */
   static asClock(time: number): string {
-    const s = Math.trunc(time / 1000);
+    const seconds = Math.trunc(time / 1000);
     return [
-      s > 3600 ? `${Math.trunc(s / 3600).toString().padStart(2, '0')}h` : '',
-      s > 60 ? `${Math.trunc((s % 3600) / 60).toString().padStart(2, '0')}m` : '',
-      `${(s % 60).toString().padStart(2, '0')}s`
-    ].filter(x => !!x).slice(0, 2).join(' ');
+      seconds > 3600 ? `${Math.trunc(seconds / 3600).toString().padStart(2, '0')}h` : '',
+      seconds > 60 ? `${Math.trunc((seconds % 3600) / 60).toString().padStart(2, '0')}m` : '',
+      `${(seconds % 60).toString().padStart(2, '0')}s`
+    ].filter(part => !!part).slice(0, 2).join(' ');
   }
 }

package/src/types.ts

@@ -14,7 +14,7 @@ export type TypedFunction<R = Any, V = unknown> = (this: V, ...args: Any[]) => R
 
 export type MethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<R, V>>;
 export type AsyncMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<Promise<R>, V>>;
-export type AsyncItrMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
+export type AsyncIterableMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
 export type ClassTDecorator<T extends Class = Class> = (target: T) => T | void;
 
 export type Primitive = number | bigint | boolean | string | Date;
@@ -34,7 +34,7 @@ type ValidPrimitiveFields<T, Z = undefined> = {
 export type RetainPrimitiveFields<T, Z = undefined> = Pick<T, ValidPrimitiveFields<T, Z>>;
 
 export const TypedObject: {
-  keys<T = unknown, K extends keyof T = keyof T & string>(o: T): K[];
+  keys<T = unknown, K extends keyof T = keyof T & string>(value: T): K[];
   fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
   entries<K extends Record<symbol | string, unknown>>(record: K): [keyof K, K[keyof K]][];
 } & ObjectConstructor = Object;
@@ -56,8 +56,8 @@ export function classConstruct<T>(cls: Class<T>, args: unknown[] = []): ClassIns
   return castTo(new cons(...args));
 }
 
-export const hasFunction = <T>(key: keyof T) => (o: unknown): o is T =>
-  typeof o === 'object' && o !== null && typeof o[castKey(key)] === 'function';
+export const hasFunction = <T>(key: keyof T) => (value: unknown): value is T =>
+  typeof value === 'object' && value !== null && typeof value[castKey(key)] === 'function';
 
 export const hasToJSON = hasFunction<{ toJSON(): object }>('toJSON');
 
@@ -65,13 +65,6 @@ export function toConcrete<T extends unknown>(): Class<T> {
   return arguments[0];
 }
 
-export function getAllEntries<V>(obj: Record<string | symbol, V>): [string | symbol, V][] {
-  return [
-    ...Object.keys(obj),
-    ...Object.getOwnPropertySymbols(obj)
-  ].map(k => [k, obj[k]] as const);
-}
-
 /**
  * Find parent class for a given class object
  */
@@ -83,7 +76,8 @@ export function getParentClass(cls: Class): Class | undefined {
 /**
  * Get the class from an instance or class
  */
-export const getClass = <T = unknown>(x: ClassInstance | Class): Class<T> => 'Ⲑid' in x ? castTo(x) : asConstructable<T>(x).constructor;
+export const getClass = <T = unknown>(value: ClassInstance | Class): Class<T> =>
+  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;
 
 /**
  * Range of bytes, inclusive

package/src/util.ts

@@ -4,7 +4,7 @@ import timers from 'node:timers/promises';
 import { castTo, hasToJSON } from './types.ts';
 import { AppError } from './error.ts';
 
-type MapFn<T, U> = (val: T, i: number) => U | Promise<U>;
+type MapFn<T, U> = (value: T, i: number) => U | Promise<U>;
 
 /**
  * Grab bag of common utilities
@@ -38,35 +38,35 @@ export class Util {
 
   /**
    * Generate a random UUID
-   * @param len The length of the uuid to generate
+   * @param length The length of the uuid to generate
    */
-  static uuid(len: number = 32): string {
-    const bytes = crypto.randomBytes(Math.ceil(len / 2));
-    if (len === 32) { // Make valid uuid-v4
+  static uuid(length: number = 32): string {
+    const bytes = crypto.randomBytes(Math.ceil(length / 2));
+    if (length === 32) { // Make valid uuid-v4
       // eslint-disable-next-line no-bitwise
       bytes[6] = (bytes[6] & 0x0f) | 0x40;
       // eslint-disable-next-line no-bitwise
       bytes[8] = (bytes[8] & 0x3f) | 0x80;
     }
-    return bytes.toString('hex').substring(0, len);
+    return bytes.toString('hex').substring(0, length);
   }
 
   /**
    * Map an async iterable with various mapping functions
    */
-  static mapAsyncItr<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
-  static mapAsyncItr<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
-  static mapAsyncItr<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
-  static async * mapAsyncItr<T>(source: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
+  static mapAsyncIterable<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
+  static mapAsyncIterable<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
+  static mapAsyncIterable<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
+  static async * mapAsyncIterable<T>(input: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
     let idx = -1;
-    for await (const el of source) {
-      if (el !== undefined) {
+    for await (const item of input) {
+      if (item !== undefined) {
         idx += 1;
-        let m = el;
+        let result = item;
         for (const fn of fns) {
-          m = castTo(await fn(m, idx));
+          result = castTo(await fn(result, idx));
         }
-        yield m;
+        yield result;
       }
     }
   }
@@ -103,9 +103,9 @@ export class Util {
     cacheKey?: (...keyInput: K) => string
   ): (...input: K) => boolean {
 
-    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(x => x.trim()));
+    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(rule => rule.trim()));
     const convertedRules = rawRules.map(rule => this.#allowDenyRuleInput(rule, convert));
-    const unmatchedValue = !convertedRules.some(r => r.positive);
+    const unmatchedValue = !convertedRules.some(rule => rule.positive);
 
     if (convertedRules.length) {
       if (cacheKey) {
@@ -127,8 +127,8 @@ export class Util {
     if (value === undefined) {
       return;
     }
-    const res = JSON.stringify(value);
-    return Buffer.from(res, 'utf8').toString('base64');
+    const text = JSON.stringify(value);
+    return Buffer.from(text, 'utf8').toString('base64');
   }
 
   /**
@@ -155,20 +155,20 @@ export class Util {
    * Serialize to JSON
    */
   static serializeToJSON<T>(out: T): string {
-    return JSON.stringify(out, function (k, v) {
-      const ov = this[k];
-      if (ov && ov instanceof Error) {
+    return JSON.stringify(out, function (key, value) {
+      const objectValue = this[key];
+      if (objectValue && objectValue instanceof Error) {
         return {
           $: true,
-          ...hasToJSON(ov) ? ov.toJSON() : ov,
-          name: ov.name,
-          message: ov.message,
-          stack: ov.stack,
+          ...hasToJSON(objectValue) ? objectValue.toJSON() : objectValue,
+          name: objectValue.name,
+          message: objectValue.message,
+          stack: objectValue.stack,
         };
-      } else if (typeof v === 'bigint') {
-        return `${v.toString()}$n`;
+      } else if (typeof value === 'bigint') {
+        return `${value.toString()}$n`;
       } else {
-        return v;
+        return value;
       }
     });
   }
@@ -177,42 +177,42 @@ export class Util {
    * Deserialize from JSON
    */
   static deserializeFromJson<T = unknown>(input: string): T {
-    return JSON.parse(input, function (k, v) {
-      if (v && typeof v === 'object' && '$' in v) {
-        const err = AppError.fromJSON(v) ?? new Error();
-        if (!(err instanceof AppError)) {
-          const { $: _, ...rest } = v;
-          Object.assign(err, rest);
+    return JSON.parse(input, function (key, value) {
+      if (value && typeof value === 'object' && '$' in value) {
+        const error = AppError.fromJSON(value) ?? new Error();
+        if (!(error instanceof AppError)) {
+          const { $: _, ...rest } = value;
+          Object.assign(error, rest);
         }
-        err.message = v.message;
-        err.stack = v.stack;
-        err.name = v.name;
-        return err;
-      } else if (typeof v === 'string' && /^\d+[$]n$/.test(v)) {
-        return BigInt(v.split('$')[0]);
+        error.message = value.message;
+        error.stack = value.stack;
+        error.name = value.name;
+        return error;
+      } else if (typeof value === 'string' && /^\d+[$]n$/.test(value)) {
+        return BigInt(value.split('$')[0]);
       } else {
-        return v;
+        return value;
       }
     });
   }
 
   /**
    * Retry an operation, with a custom conflict handler
-   * @param op The operation to retry
+   * @param operation The operation to retry
    * @param isHandledConflict Function to determine if the error is a handled conflict
    * @param maxTries Maximum number of retries
    */
   static async acquireWithRetry<T>(
-    op: () => T | Promise<T>,
-    prepareRetry: (err: unknown, count: number) => (void | undefined | boolean | Promise<(void | undefined | boolean)>),
+    operation: () => T | Promise<T>,
+    prepareRetry: (error: unknown, count: number) => (void | undefined | boolean | Promise<(void | undefined | boolean)>),
     maxTries = 5,
   ): Promise<T> {
     for (let i = 0; i < maxTries; i++) {
       try {
-        return await op();
-      } catch (err) {
-        if (i === maxTries - 1 || await prepareRetry(err, i) === false) {
-          throw err; // Stop retrying if we reached max tries or prepareRetry returns false
+        return await operation();
+      } catch (error) {
+        if (i === maxTries - 1 || await prepareRetry(error, i) === false) {
+          throw error; // Stop retrying if we reached max tries or prepareRetry returns false
         }
       }
     }

package/src/watch.ts

@@ -5,7 +5,7 @@ import { Util } from './util.ts';
 
 export type WatchEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
 
-export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: AbortSignal }): AsyncIterable<WatchEvent> {
+export async function* watchCompiler(config?: { restartOnExit?: boolean, signal?: AbortSignal }): AsyncIterable<WatchEvent> {
   // Load at runtime
   const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
 
@@ -16,22 +16,22 @@ export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: A
     info(message, ...args): void { console.error('info', message, ...args); },
   });
 
-  const ctrl = new AbortController();
-  const remove = ShutdownManager.onGracefulShutdown(async () => ctrl.abort());
+  const controller = new AbortController();
+  const remove = ShutdownManager.onGracefulShutdown(async () => controller.abort());
 
-  await client.waitForState(['compile-end', 'watch-start'], undefined, ctrl.signal);
+  await client.waitForState(['compile-end', 'watch-start'], undefined, controller.signal);
 
   if (!await client.isWatching()) { // If we get here, without a watch
     while (!await client.isWatching()) { // Wait until watch starts
       await Util.nonBlockingTimeout(1000 * 60);
     }
   } else {
-    yield* client.fetchEvents('change', { signal: ctrl.signal, enforceIteration: true });
+    yield* client.fetchEvents('change', { signal: controller.signal, enforceIteration: true });
   }
 
   remove();
 
-  if (cfg?.restartOnExit) {
+  if (config?.restartOnExit) {
     // We are done, request restart
     await ShutdownManager.gracefulShutdown('@travetto/runtime:watchCompiler');
     process.exit(ExecUtil.RESTART_EXIT_CODE);

package/support/transformer/metadata.ts

@@ -43,14 +43,14 @@ export class MetadataRegistrationUtil {
    */
   static registerFunction(state: TransformerState & MetadataInfo,
     node: ts.FunctionDeclaration | ts.FunctionExpression,
-    src?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
+    source?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
   ): void {
     // If we have a class like function
     state[RegisterImportSymbol] ??= state.importFile(this.REGISTER_IMPORT);
 
-    const tag = this.tag(state, src ?? node);
+    const tag = this.tag(state, source ?? node);
     const meta = state.factory.createCallExpression(
-      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      state.createAccess(state[RegisterImportSymbol].identifier, this.REGISTER_FN),
       [],
       [
         state.createIdentifier(node.name!.text),
@@ -74,7 +74,7 @@ export class MetadataRegistrationUtil {
     const name = node.name?.escapedText.toString() ?? '';
 
     const meta = state.factory.createCallExpression(
-      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      state.createAccess(state[RegisterImportSymbol].identifier, this.REGISTER_FN),
       [],
       [
         state.createIdentifier(name),

package/support/transformer.concrete-type.ts

@@ -18,7 +18,7 @@ export class ConcreteTransformer {
   static #createConcreteFunction(state: TransformerState, name: string | ts.Identifier): ts.FunctionDeclaration {
     const final = typeof name === 'string' ? name : name.getText();
 
-    const dec = state.factory.createFunctionDeclaration(
+    const declaration = state.factory.createFunctionDeclaration(
       // eslint-disable-next-line no-bitwise
       state.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export | ts.ModifierFlags.Const),
       undefined, `${final}$Concrete`, [], [], undefined,
@@ -26,13 +26,13 @@ export class ConcreteTransformer {
     );
 
     state.addStatements([
-      dec,
+      declaration,
       state.factory.createExpressionStatement(
         state.factory.createCallExpression(
           state.createAccess('Object', 'defineProperty'),
           undefined,
           [
-            dec.name!,
+            declaration.name!,
             state.fromLiteral('name'),
             state.fromLiteral({ value: final })
           ]
@@ -40,7 +40,7 @@ export class ConcreteTransformer {
       )
     ]);
 
-    return dec;
+    return declaration;
   }
 
   /**

package/support/transformer.console-log.ts

@@ -83,26 +83,26 @@ export class ConsoleLogTransformer {
 
     const chain = node.expression;
     const name = chain.name;
-    const prop = chain.expression;
+    const expr = chain.expression;
 
-    if (!ts.isIdentifier(prop) || prop.escapedText !== 'console' || !ts.isIdentifier(name)) {
+    if (!ts.isIdentifier(expr) || expr.escapedText !== 'console' || !ts.isIdentifier(name)) {
       return node;
     }
 
     const level = name.escapedText!;
 
     if (VALID_LEVELS[level]) {
-      const ident = state.imported ??= state.importFile(CONSOLE_IMPORT).ident;
+      const identifier = state.imported ??= state.importFile(CONSOLE_IMPORT).identifier;
       return state.factory.updateCallExpression(
         node,
-        state.createAccess(ident, 'log'),
+        state.createAccess(identifier, 'log'),
         node.typeArguments,
         [
           LiteralUtil.fromLiteral(state.factory, {
             level: state.factory.createStringLiteral(VALID_LEVELS[level]),
             import: state.getModuleIdentifier(),
             line: state.source.getLineAndCharacterOfPosition(node.getStart(state.source)).line + 1,
-            scope: state.scope?.map(x => x.name).join(':'),
+            scope: state.scope?.map(part => part.name).join(':'),
             args: node.arguments.slice(0)
           }),
         ]

package/support/transformer.debug-method.ts

@@ -19,7 +19,7 @@ export class DebugEntryTransformer {
   @OnMethod('DebugBreak')
   static debugOnEntry(state: TransformerState & DebugState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (!state[DebugSymbol]) {
-      const imp = state.importFile('@travetto/runtime/src/debug.ts').ident;
+      const imp = state.importFile('@travetto/runtime/src/debug.ts').identifier;
       state[DebugSymbol] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
     }
 

package/support/transformer.function-metadata.ts

@@ -52,9 +52,9 @@ export class RegisterTransformer {
       return node;
     }
 
-    const { [MethodsSymbol]: m, [ClassSymbol]: c } = state;
+    const { [MethodsSymbol]: method, [ClassSymbol]: cls } = state;
     delete state[ClassSymbol];
-    return MetadataRegistrationUtil.registerClass(state, node, c!, m);
+    return MetadataRegistrationUtil.registerClass(state, node, cls!, method);
   }
 
   /**

package/support/transformer.rewrite-path-import.ts

@@ -5,6 +5,9 @@ import { TransformerState, OnFile } from '@travetto/transformer';
 const PATH_REGEX = /^['"](node:)?path['"]$/;
 const PATH_IMPORT = '@travetto/manifest/src/path.ts';
 
+const isImport = (node: ts.Node): node is ts.ImportDeclaration =>
+  ts.isImportDeclaration(node) && PATH_REGEX.test(node.moduleSpecifier?.getText() ?? '');
+
 /**
  * Rewriting path imports to use manifest's path
  */
@@ -15,18 +18,17 @@ export class PathImportTransformer {
    */
   @OnFile()
   static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
-    const stmt = node.statements.find((x): x is ts.ImportDeclaration =>
-      ts.isImportDeclaration(x) && PATH_REGEX.test(x.moduleSpecifier?.getText() ?? ''));
-    if (stmt) {
+    const statement = node.statements.find(isImport);
+    if (statement) {
       const updated = state.factory.updateImportDeclaration(
-        stmt,
-        stmt.modifiers,
-        stmt.importClause,
+        statement,
+        statement.modifiers,
+        statement.importClause,
         state.factory.createStringLiteral(PATH_IMPORT),
-        stmt.attributes
+        statement.attributes
       );
-      return state.factory.updateSourceFile(node, node.statements.map(x =>
-        x === stmt ? updated : x
+      return state.factory.updateSourceFile(node, node.statements.map(item =>
+        item === statement ? updated : item
       ));
     }
     return node;