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

package/src/time.ts

@@ -2,16 +2,32 @@ import { RuntimeError } from './error.ts';
 import { castTo } from './types.ts';
 
 const TIME_UNIT_TO_TEMPORAL_UNIT = {
-  y: 'years', year: 'years', years: 'years',
-  M: 'months', month: 'months', months: 'months',
-  w: 'weeks', week: 'weeks', weeks: 'weeks',
-  d: 'days', day: 'days', days: 'days',
-  h: 'hours', hour: 'hours', hours: 'hours',
-  m: 'minutes', minute: 'minutes', minutes: 'minutes',
-  s: 'seconds', second: 'seconds', seconds: 'seconds',
-  ms: 'milliseconds', millisecond: 'milliseconds', milliseconds: 'milliseconds'
+  y: 'years',
+  year: 'years',
+  years: 'years',
+  M: 'months',
+  month: 'months',
+  months: 'months',
+  w: 'weeks',
+  week: 'weeks',
+  weeks: 'weeks',
+  d: 'days',
+  day: 'days',
+  days: 'days',
+  h: 'hours',
+  hour: 'hours',
+  hours: 'hours',
+  m: 'minutes',
+  minute: 'minutes',
+  minutes: 'minutes',
+  s: 'seconds',
+  second: 'seconds',
+  seconds: 'seconds',
+  ms: 'milliseconds',
+  millisecond: 'milliseconds',
+  milliseconds: 'milliseconds'
 } as const;
-type TemporalUnit = typeof TIME_UNIT_TO_TEMPORAL_UNIT[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
+type TemporalUnit = (typeof TIME_UNIT_TO_TEMPORAL_UNIT)[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
 
 export type TimeSpan = `${number}${keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT}`;
 export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
@@ -19,7 +35,6 @@ export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
 const TIME_PATTERN = /^(?<amount>-?[0-9]+)(?<unit>(?:year|month|week|day|hour|minute|second|millisecond)s?|y|M|w|d|h|m|s|ms)$/;
 
 export class TimeUtil {
-
   /**
    * Test to see if a string is valid for relative time
    */
@@ -50,20 +65,40 @@ export class TimeUtil {
     }
 
     switch (unit) {
-      case 'years': { unit = 'hours'; value = value * 365 * 24; break; }
-      case 'months': { value = value * 30 * 24; unit = 'hours'; break; }
-      case 'weeks': { value = value * 7 * 24; unit = 'hours'; break; }
-      case 'days': { value = value * 24; unit = 'hours'; break; }
+      case 'years': {
+        unit = 'hours';
+        value = value * 365 * 24;
+        break;
+      }
+      case 'months': {
+        value = value * 30 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'weeks': {
+        value = value * 7 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'days': {
+        value = value * 24;
+        unit = 'hours';
+        break;
+      }
     }
 
     const duration = Temporal.Duration.from({ [unit]: value });
     if (outputUnit) {
       const resolved = TIME_UNIT_TO_TEMPORAL_UNIT[outputUnit];
       switch (resolved) {
-        case 'years': return Math.trunc(duration.total('hours') / (365 * 24));
-        case 'months': return Math.trunc(duration.total('hours') / (30 * 24));
-        case 'weeks': return Math.trunc(duration.total('hours') / (7 * 24));
-        default: return Math.trunc(duration.total(resolved));
+        case 'years':
+          return Math.trunc(duration.total('hours') / (365 * 24));
+        case 'months':
+          return Math.trunc(duration.total('hours') / (30 * 24));
+        case 'weeks':
+          return Math.trunc(duration.total('hours') / (7 * 24));
+        default:
+          return Math.trunc(duration.total(resolved));
       }
     } else {
       return duration;
@@ -94,4 +129,4 @@ export class TimeUtil {
       return `${toFixed(seconds)}s`;
     }
   }
-}
+}

package/src/trv.d.ts

@@ -2,7 +2,7 @@ import { type ManifestModuleRole } from '@travetto/manifest';
 import { type TimeSpan } from './time.ts';
 type Role = Exclude<ManifestModuleRole, 'compile'>;
 
-declare module "@travetto/runtime" {
+declare module '@travetto/runtime' {
   interface EnvData {
     /** 
      * The node environment we are running in

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 };
@@ -12,7 +12,6 @@ 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 AsyncIterableMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
-export type ClassTDecorator<T extends Class = Class> = (target: T) => T | void;
 
 export type NumericPrimitive = number | bigint;
 export type Primitive = NumericPrimitive | boolean | string;
@@ -21,19 +20,33 @@ 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 const TypedObject: {
   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>;
@@ -41,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;
 }
 
@@ -55,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];
 }
 
@@ -80,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,20 +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)
     });
 
-    return this.runWithRetry(async ({ signal }) => {
-      await client.waitForState(['compile-end', 'watch-start'], undefined, signal);
+    // pre-check
+    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 })) {
@@ -106,4 +115,4 @@ export class WatchUtil {
       }
     }, options);
   }
-}
+}

package/support/patch.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+
+if (process.env.NODE_ENV !== 'production') {
+  process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
+  process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
+  Error.stackTraceLimit = 50;
+}
+
+// polyfills
+if (!globalThis.Temporal) {
+  // For anyone that doesn't have it
+  void import('temporal-polyfill-lite/global');
+}
+
+Map.prototype.getOrInsert ??= function (key, value) {
+  if (!this.has(key)) {
+    this.set(key, value);
+  }
+  return this.get(key);
+};
+
+Map.prototype.getOrInsertComputed ??= function (key, compute) {
+  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
+const [majorVersion, minorVersion] = process.version.match(/\d+/g).map(text => parseInt(text, 10));
+if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
+  const og = fs.stat;
+  Object.defineProperty(fs, 'stat', {
+    value: (...args) => {
+      const out = og.call(fs, ...args);
+      if (typeof args[1] === 'object' && args[1].throwIfNoEntry === false) {
+        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;
   }
-}
+}