@travetto/runtime 8.0.0-alpha.19 → 8.0.0-alpha.20

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { Readable } from 'node:stream';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// biome-ignore lint/suspicious/noExplicitAny: This is the any reference we use explicitly
 export type Any = any;
 
 export type AnyMap = { [key: string]: Any };
@@ -20,30 +20,32 @@ export type NumericLikeIntrinsic = Date | NumericPrimitive;
 export type IntrinsicType = Primitive | Date | ArrayBuffer | Uint8Array | Uint16Array | Uint32Array | Readable | Buffer | Blob | File;
 
 export type DeepPartial<T> = {
-  [P in keyof T]?: (T[P] extends (IntrinsicType | undefined) ? (T[P] | undefined) :
-    (T[P] extends Any[] ? (DeepPartial<T[P][number]> | null | undefined)[] : DeepPartial<T[P]>));
+  [P in keyof T]?: T[P] extends IntrinsicType | undefined
+    ? T[P] | undefined
+    : T[P] extends Any[]
+      ? (DeepPartial<T[P][number]> | null | undefined)[]
+      : DeepPartial<T[P]>;
 };
 
 export type ValidFields<T, I> = {
-  [K in keyof T]:
-  (T[K] extends (Primitive | I | undefined) ? K :
-    (T[K] extends (Function | undefined) ? never :
-      K))
+  [K in keyof T]: T[K] extends Primitive | I | undefined ? K : T[K] extends Function | undefined ? never : K;
 }[keyof T];
 
 export type RetainIntrinsicFields<T> = Pick<T, ValidFields<T, IntrinsicType>>;
 
-export type KeyPaths<T, PrimitiveType = IntrinsicType | IntrinsicType[], PREFIX extends string = '', SEP extends string = '.'> =
-  { [K in keyof T]:
-    (K extends string ? (
-      (T[K] extends (IntrinsicType[] | IntrinsicType | undefined) ?
-        (T[K] extends PrimitiveType ? `${PREFIX}${K}` : never) : (
-          (T[K] extends Any[] ?
-            KeyPaths<T[K][number], PrimitiveType, `${K}${SEP}`, SEP> :
-            (T[K] extends object ? KeyPaths<T[K], PrimitiveType, `${K}${SEP}`, SEP> : never))
-        )
-      )) : never)
-  }[keyof T];
+export type KeyPaths<T, PrimitiveType = IntrinsicType | IntrinsicType[], PREFIX extends string = '', SEP extends string = '.'> = {
+  [K in keyof T]: K extends string
+    ? T[K] extends IntrinsicType[] | IntrinsicType | undefined
+      ? T[K] extends PrimitiveType
+        ? `${PREFIX}${K}`
+        : never
+      : T[K] extends Any[]
+        ? KeyPaths<T[K][number], PrimitiveType, `${K}${SEP}`, SEP>
+        : T[K] extends object
+          ? KeyPaths<T[K], PrimitiveType, `${K}${SEP}`, SEP>
+          : never
+    : never;
+}[keyof T];
 
 export const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T & string>(value: T): K[];
@@ -52,11 +54,9 @@ export const TypedObject: {
   assign<T extends {}, U extends T>(target: T, ...sources: U[]): U;
 } & ObjectConstructor = Object;
 
-export const safeAssign = <T extends {}, U extends {}>(target: T, ...sources: U[]): T & U =>
-  Object.assign(target, ...sources);
+export const safeAssign = <T extends {}, U extends {}>(target: T, ...sources: U[]): T & U => Object.assign(target, ...sources);
 
 export function castTo<T>(input: unknown): T {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return input as T;
 }
 
@@ -66,16 +66,20 @@ export const asFull = <T>(input: Partial<T>): T => castTo(input);
 export const asConstructable = <Z = unknown>(input: Class | unknown): { constructor: Class<Z> } => castTo(input);
 
 export function classConstruct<T>(cls: Class<T>, args: unknown[] = []): ClassInstance<T> {
-  const cons: { new(..._args: Any[]): T } = castTo(cls);
+  const cons: { new (..._args: Any[]): T } = castTo(cls);
   return castTo(new cons(...args));
 }
 
-export const hasFunction = <T>(key: keyof T) => (value: unknown): value is T =>
-  typeof value === 'object' && value !== null && typeof value[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');
 
+// biome-ignore lint/complexity/noUselessTypeConstraint: Unknown behaves slightly differently when being used for an inferred type
 export function toConcrete<T extends unknown>(): Class<T> {
+  // biome-ignore lint/complexity/noArguments: We want to use arguments here
   return arguments[0];
 }
 
@@ -91,4 +95,4 @@ export function getParentClass(cls: Class): Class | undefined {
  * Get the class from an instance or class
  */
 export const getClass = <T = unknown>(value: ClassInstance | Class): Class<T> =>
-  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;
+  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;

package/src/util.ts

@@ -1,20 +1,21 @@
 import timers from 'node:timers/promises';
+
 import { path } from '@travetto/manifest';
 
 import { castTo } from './types.ts';
 
 type MapFn<T, U> = (value: T, i: number) => U | Promise<U>;
-type StackFrame = { message: string, filename: string, line: number, column: number };
+type StackFrame = { message: string; filename: string; line: number; column: number };
 
-const STACK_POSITION_PATTERN = /[(]\s{0,5}(?<filename>[^()]{1,1000}[.]([cm]?[jt]s))([:](?<line>\d{1,10}))?([:](?<column>\d{1,10}))?\s{0,5}[)]/;
+const STACK_POSITION_PATTERN =
+  /[(]\s{0,5}(?<filename>[^()]{1,1000}[.]([cm]?[jt]s))([:](?<line>\d{1,10}))?([:](?<column>\d{1,10}))?\s{0,5}[)]/;
 
 /**
  * Grab bag of common utilities
  */
 export class Util {
-
   static #match<T, K extends unknown[]>(
-    rules: { value: T, positive: boolean }[],
+    rules: { value: T; positive: boolean }[],
     compare: (rule: T, ...compareInput: K) => boolean,
     unmatchedValue: boolean,
     ...input: K
@@ -28,14 +29,14 @@ export class Util {
   }
 
   static #allowDenyRuleInput<T>(
-    rule: (string | T | [value: T, positive: boolean] | [value: T]),
+    rule: string | T | [value: T, positive: boolean] | [value: T],
     convert: (inputRule: string) => T
-  ): { value: T, positive: boolean } {
-    return typeof rule === 'string' ?
-      { value: convert(rule.replace(/^!/, '')), positive: !rule.startsWith('!') } :
-      Array.isArray(rule) ?
-        { value: rule[0], positive: rule[1] ?? true } :
-        { value: rule, positive: true };
+  ): { value: T; positive: boolean } {
+    return typeof rule === 'string'
+      ? { value: convert(rule.replace(/^!/, '')), positive: !rule.startsWith('!') }
+      : Array.isArray(rule)
+        ? { value: rule[0], positive: rule[1] ?? true }
+        : { value: rule, positive: true };
   }
 
   /**
@@ -44,10 +45,9 @@ export class Util {
    */
   static uuid(length: number = 32): string {
     const bytes = crypto.getRandomValues(new Uint8Array(Math.ceil(length / 2)));
-    if (length === 32) { // Make valid uuid-v4
-      // eslint-disable-next-line no-bitwise
+    if (length === 32) {
+      // Make valid uuid-v4
       bytes[6] = (bytes[6] & 0x0f) | 0x40;
-      // eslint-disable-next-line no-bitwise
       bytes[8] = (bytes[8] & 0x3f) | 0x80;
     }
     return bytes.toHex().substring(0, length);
@@ -59,7 +59,7 @@ export class Util {
   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> {
+  static async *mapAsyncIterable<T>(input: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
     let idx = -1;
     for await (const item of input) {
       if (item !== undefined) {
@@ -77,14 +77,14 @@ export class Util {
    * Non-blocking timeout
    */
   static nonBlockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: false }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: false }).catch(() => {});
   }
 
   /**
    * Blocking timeout
    */
   static blockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: true }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: true }).catch(() => {});
   }
 
   /**
@@ -104,16 +104,14 @@ export class Util {
     compare: (rule: T, ...compareInput: K) => boolean,
     cacheKey?: (...keyInput: K) => string
   ): (...input: K) => boolean {
-
-    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(rule => rule.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(rule => rule.positive);
 
     if (convertedRules.length) {
       if (cacheKey) {
         const cache: Record<string, boolean> = {};
-        return (...input: K) =>
-          cache[cacheKey(...input)] ??= this.#match(convertedRules, compare, unmatchedValue, ...input);
+        return (...input: K) => (cache[cacheKey(...input)] ??= this.#match(convertedRules, compare, unmatchedValue, ...input));
       } else {
         return (...input: K) => this.#match(convertedRules, compare, unmatchedValue, ...input);
       }
@@ -133,7 +131,7 @@ export class Util {
       .split('\n')
       .map(frameText => {
         const match = STACK_POSITION_PATTERN.exec(frameText);
-        if (!match || !match.groups) {
+        if (!match?.groups) {
           return undefined;
         }
         const { filename, line, column } = match.groups;

package/src/watch.ts

@@ -1,10 +1,10 @@
 import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler';
 
 import { RuntimeError } from './error.ts';
-import { Util } from './util.ts';
 import { RuntimeIndex } from './manifest-index.ts';
 import { ShutdownManager, type ShutdownReason } from './shutdown.ts';
 import { castTo } from './types.ts';
+import { Util } from './util.ts';
 
 type RetryRunState = {
   iteration: number;
@@ -17,25 +17,25 @@ type RetryRunConfig = {
   maxRetries: number;
   maxRetryWindow: number;
   signal?: AbortSignal;
-  onRetry: (state: RetryRunState, config: RetryRunConfig) => (unknown | Promise<unknown>);
+  onRetry: (state: RetryRunState, config: RetryRunConfig) => unknown | Promise<unknown>;
 };
 
 /**
  * Utilities for watching resources
  */
 export class WatchUtil {
-
   /** Compute the delay before restarting */
   static computeRestartDelay(state: RetryRunState, config: RetryRunConfig): number {
-    return state.result === 'error'
-      ? config.maxRetryWindow / (config.maxRetries + 1)
-      : 10;
+    return state.result === 'error' ? config.maxRetryWindow / (config.maxRetries + 1) : 10;
   }
 
   /**
    * Run with restart capability
    */
-  static async runWithRetry(run: (state: RetryRunState & { signal: AbortSignal }) => Promise<ShutdownReason>, options?: Partial<RetryRunConfig>): Promise<void> {
+  static async runWithRetry(
+    run: (state: RetryRunState & { signal: AbortSignal }) => Promise<ShutdownReason>,
+    options?: Partial<RetryRunConfig>
+  ): Promise<void> {
     let retryExhausted = false;
 
     const state: RetryRunState = {
@@ -48,10 +48,9 @@ export class WatchUtil {
       maxRetryWindow: 10 * 1000,
       maxRetries: 10,
       onRetry: () => Util.nonBlockingTimeout(this.computeRestartDelay(state, config)),
-      ...options,
+      ...options
     };
 
-
     outer: while (!ShutdownManager.signal.aborted && !retryExhausted) {
       if (state.iteration > 0) {
         await config.onRetry(state, config);
@@ -59,15 +58,18 @@ export class WatchUtil {
 
       state.result = await run({ ...state, signal: ShutdownManager.signal }).catch(() => 'error' as const);
       switch (state.result) {
-        case 'quit': break outer;
-        case 'error': state.errorIterations += 1; break;
+        case 'quit':
+          break outer;
+        case 'error':
+          state.errorIterations += 1;
+          break;
         case 'restart': {
           state.startTime = Date.now();
           state.errorIterations = 0;
         }
       }
 
-      retryExhausted = (state.errorIterations >= config.maxRetries) || (Date.now() - state.startTime >= config.maxRetryWindow);
+      retryExhausted = state.errorIterations >= config.maxRetries || Date.now() - state.startTime >= config.maxRetryWindow;
       state.iteration += 1;
     }
 
@@ -81,25 +83,27 @@ export class WatchUtil {
     type: K,
     onChange: (input: T) => unknown,
     filter?: (input: T) => boolean,
-    options?: Partial<RetryRunConfig>,
+    options?: Partial<RetryRunConfig>
   ): Promise<void> {
     const { CompilerClient } = await import('@travetto/compiler/src/server/client.ts');
     const client = new CompilerClient(RuntimeIndex.manifest, {
       debug: (...args: unknown[]): void => console.debug(...args),
       info: (...args: unknown[]): void => console.info(...args),
       warn: (...args: unknown[]): void => console.warn(...args),
-      error: (...args: unknown[]): void => console.error(...args),
+      error: (...args: unknown[]): void => console.error(...args)
     });
 
     // pre-check
-    if (!await client.isWatching()) { // If we get here, without a watch
+    if (!(await client.isWatching())) {
+      // If we get here, without a watch
       throw new RuntimeError('Compile Server is not running');
     }
 
     void this.runWithRetry(async ({ signal }) => {
       await client.waitForState(['watch-start'], undefined, signal);
 
-      if (!await client.isWatching()) { // If we get here, without a watch
+      if (!(await client.isWatching())) {
+        // If we get here, without a watch
         return 'error';
       } else {
         for await (const event of client.fetchEvents(type, { signal, enforceIteration: true })) {
@@ -111,4 +115,4 @@ export class WatchUtil {
       }
     }, options);
   }
-}
+}

package/support/patch.js

@@ -7,16 +7,23 @@ if (process.env.NODE_ENV !== 'production') {
 }
 
 // polyfills
-if (!globalThis.Temporal) { // For anyone that doesn't have it
+if (!globalThis.Temporal) {
+  // For anyone that doesn't have it
   void import('temporal-polyfill-lite/global');
 }
 
 Map.prototype.getOrInsert ??= function (key, value) {
-  return (this.has(key) || this.set(key, value), this.get(key));
+  if (!this.has(key)) {
+    this.set(key, value);
+  }
+  return this.get(key);
 };
 
 Map.prototype.getOrInsertComputed ??= function (key, compute) {
-  return (this.has(key) || this.set(key, compute()), this.get(key));
+  if (!this.has(key)) {
+    this.set(key, compute());
+  }
+  return this.get(key);
 };
 
 // Allow for the throwIfNoEntry if on a version of node that is less than 25.7
@@ -27,7 +34,7 @@ if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
     value: (...args) => {
       const out = og.call(fs, ...args);
       if (typeof args[1] === 'object' && args[1].throwIfNoEntry === false) {
-        return out.catch(() => { });
+        return out.catch(() => {});
       }
       return out;
     }

package/support/transformer/metadata.ts

@@ -1,7 +1,8 @@
 import ts from 'typescript';
 
 import { CoreUtil, type Import, SystemUtil, type TransformerState } from '@travetto/transformer';
-import { type FunctionMetadataTag } from '../../src/function.ts';
+
+import type { FunctionMetadataTag } from '../../src/function.ts';
 
 const RegisterImportSymbol = Symbol();
 
@@ -13,7 +14,6 @@ interface MetadataInfo {
  * Utils for registering function/class metadata at compile time
  */
 export class MetadataRegistrationUtil {
-
   static REGISTER_IMPORT = '@travetto/runtime/src/function.ts';
   static REGISTER_FN = 'registerFunction';
 
@@ -41,7 +41,8 @@ export class MetadataRegistrationUtil {
   /**
    * Register metadata on a function
    */
-  static registerFunction(state: TransformerState & MetadataInfo,
+  static registerFunction(
+    state: TransformerState & MetadataInfo,
     node: ts.FunctionDeclaration | ts.FunctionExpression,
     source?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
   ): void {
@@ -52,11 +53,7 @@ export class MetadataRegistrationUtil {
     const metadata = state.factory.createCallExpression(
       state.createAccess(state[RegisterImportSymbol].identifier, this.REGISTER_FN),
       [],
-      [
-        state.createIdentifier(node.name!.text),
-        state.getModuleIdentifier(),
-        state.fromLiteral(tag),
-      ]
+      [state.createIdentifier(node.name!.text), state.getModuleIdentifier(), state.fromLiteral(tag)]
     );
     state.addStatements([state.factory.createExpressionStatement(metadata)]);
   }
@@ -65,10 +62,11 @@ export class MetadataRegistrationUtil {
    * Register metadata on a class
    */
   static registerClass(
-    state: TransformerState & MetadataInfo, node: ts.ClassDeclaration,
-    cls: FunctionMetadataTag, methods?: Record<string, FunctionMetadataTag>
+    state: TransformerState & MetadataInfo,
+    node: ts.ClassDeclaration,
+    cls: FunctionMetadataTag,
+    methods?: Record<string, FunctionMetadataTag>
   ): ts.ClassDeclaration {
-
     state[RegisterImportSymbol] ??= state.importFile(this.REGISTER_IMPORT);
 
     const name = node.name?.escapedText.toString() ?? '';
@@ -81,24 +79,13 @@ export class MetadataRegistrationUtil {
         state.getModuleIdentifier(),
         state.fromLiteral(cls),
         state.extendObjectLiteral(methods ?? {}),
-        state.fromLiteral(CoreUtil.isAbstract(node)),
+        state.fromLiteral(CoreUtil.isAbstract(node))
       ]
     );
 
-    return state.factory.updateClassDeclaration(
-      node,
-      node.modifiers,
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      [
-        state.factory.createClassStaticBlockDeclaration(
-          state.factory.createBlock([
-            state.factory.createExpressionStatement(metadata)
-          ])
-        ),
-        ...node.members
-      ]
-    );
+    return state.factory.updateClassDeclaration(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, [
+      state.factory.createClassStaticBlockDeclaration(state.factory.createBlock([state.factory.createExpressionStatement(metadata)])),
+      ...node.members
+    ]);
   }
-}
+}

package/support/transformer.concrete-type.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { type TransformerState, TransformerHandler } from '@travetto/transformer';
+import { TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 import { MetadataRegistrationUtil } from './transformer/metadata.ts';
 
@@ -10,7 +10,6 @@ const SRC = '@travetto/runtime/src/types.ts';
  * Providing support for concrete types
  */
 export class ConcreteTransformer {
-
   static {
     TransformerHandler(this, this.onInterface, 'before', 'interface');
     TransformerHandler(this, this.onTypeAlias, 'before', 'type');
@@ -25,24 +24,23 @@ export class ConcreteTransformer {
     const final = typeof name === 'string' ? name : name.getText();
 
     const declaration = state.factory.createFunctionDeclaration(
-      // eslint-disable-next-line no-bitwise
       state.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export | ts.ModifierFlags.Const),
-      undefined, `${final}$Concrete`, [], [], undefined,
+      undefined,
+      `${final}$Concrete`,
+      [],
+      [],
+      undefined,
       state.factory.createBlock([])
     );
 
     state.addStatements([
       declaration,
       state.factory.createExpressionStatement(
-        state.factory.createCallExpression(
-          state.createAccess('Object', 'defineProperty'),
-          undefined,
-          [
-            declaration.name!,
-            state.fromLiteral('name'),
-            state.fromLiteral({ value: final })
-          ]
-        )
+        state.factory.createCallExpression(state.createAccess('Object', 'defineProperty'), undefined, [
+          declaration.name!,
+          state.fromLiteral('name'),
+          state.fromLiteral({ value: final })
+        ])
       )
     ]);
 
@@ -72,19 +70,19 @@ export class ConcreteTransformer {
   }
 
   static onToConcreteCall(state: TransformerState, node: ts.CallExpression): typeof node {
-    if (ts.isIdentifier(node.expression) && node.expression.text === 'toConcrete' && node.typeArguments?.length && node.arguments.length === 0) {
+    if (
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === 'toConcrete' &&
+      node.typeArguments?.length &&
+      node.arguments.length === 0
+    ) {
       const type = state.resolveType(node.expression);
       if ('importName' in type && type.importName === SRC) {
         const [target] = node.typeArguments;
-        return state.factory.updateCallExpression(
-          node,
-          node.expression,
-          node.typeArguments,
-          [state.getConcreteType(target)]
-        );
+        return state.factory.updateCallExpression(node, node.expression, node.typeArguments, [state.getConcreteType(target)]);
       }
     }
 
     return node;
   }
-}
+}

package/support/transformer.console-log.ts

@@ -1,11 +1,11 @@
 import ts from 'typescript';
 
-import { type TransformerState, LiteralUtil, TransformerHandler } from '@travetto/transformer';
+import { LiteralUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 const CONSOLE_IMPORT = '@travetto/runtime/src/console.ts';
 
 type CustomState = TransformerState & {
-  scope: { type: 'method' | 'class' | 'function', name: string }[];
+  scope: { type: 'method' | 'class' | 'function'; name: string }[];
   imported?: ts.Identifier;
 };
 
@@ -21,7 +21,6 @@ const VALID_LEVELS: Record<string, string> = {
  * Logging support with code-location aware messages.
  */
 export class ConsoleLogTransformer {
-
   static {
     TransformerHandler(this, this.startClassForLog, 'before', 'class');
     TransformerHandler(this, this.leaveClassForLog, 'after', 'class');
@@ -91,23 +90,18 @@ export class ConsoleLogTransformer {
     const level = name.escapedText!;
 
     if (VALID_LEVELS[level]) {
-      const identifier = state.imported ??= state.importFile(CONSOLE_IMPORT).identifier;
-      return state.factory.updateCallExpression(
-        node,
-        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(part => part.name).join(':'),
-            args: node.arguments.slice(0)
-          }),
-        ]
-      );
+      const identifier = (state.imported ??= state.importFile(CONSOLE_IMPORT).identifier);
+      return state.factory.updateCallExpression(node, 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(part => part.name).join(':'),
+          args: node.arguments.slice(0)
+        })
+      ]);
     } else {
       return node;
     }
   }
-}
+}

package/support/transformer.debug-method.ts

@@ -1,6 +1,6 @@
 import type ts from 'typescript';
 
-import { type TransformerState, CoreUtil, TransformerHandler } from '@travetto/transformer';
+import { CoreUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 const DebugSymbol = Symbol();
 
@@ -15,7 +15,6 @@ interface DebugState {
  * Add debugger-optional statement to methods that should be debuggable
  */
 export class DebugEntryTransformer {
-
   static {
     TransformerHandler(this, this.debugOnEntry, 'before', 'method', ['DebugBreak']);
   }
@@ -26,7 +25,8 @@ export class DebugEntryTransformer {
       state[DebugSymbol] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
     }
 
-    return state.factory.updateMethodDeclaration(node,
+    return state.factory.updateMethodDeclaration(
+      node,
       node.modifiers,
       node.asteriskToken,
       node.name,
@@ -34,11 +34,15 @@ export class DebugEntryTransformer {
       node.typeParameters,
       node.parameters,
       node.type,
-      node.body ? state.factory.updateBlock(node.body, [
-        state.factory.createIfStatement(state[DebugSymbol]!,
-          state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))),
-        ...node.body.statements
-      ]) : node.body
+      node.body
+        ? state.factory.updateBlock(node.body, [
+            state.factory.createIfStatement(
+              state[DebugSymbol]!,
+              state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))
+            ),
+            ...node.body.statements
+          ])
+        : node.body
     );
   }
-}
+}

package/support/transformer.dynamic-import.ts

@@ -6,7 +6,6 @@ import { TransformerHandler, type TransformerState } from '@travetto/transformer
  * Dynamic Import Transformer
  */
 export class DynamicImportTransformer {
-
   static {
     TransformerHandler(this, this.onCall, 'before', 'call');
   }
@@ -25,4 +24,4 @@ export class DynamicImportTransformer {
     }
     return node;
   }
-}
+}