@travetto/runtime 8.0.0-alpha.9 → 8.0.1

package/src/context.ts

@@ -1,17 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { type ManifestIndex, type ManifestContext, ManifestModuleUtil } from '@travetto/manifest';
+import { type ManifestContext, type ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
 
 import { Env } from './env.ts';
-import { RuntimeIndex } from './manifest-index.ts';
 import { describeFunction } from './function.ts';
-import type { Role } from './trv';
 import { JSONUtil } from './json.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import type { Role } from './trv.ts';
 
 /** Constrained version of {@type ManifestContext} */
 class $Runtime {
-
   #idx: ManifestIndex;
   #resourceOverrides?: Record<string, string>;
 
@@ -23,14 +22,13 @@ class $Runtime {
   get #moduleAliases(): Record<string, string> {
     return {
       '@': this.#idx.mainModule.sourcePath,
-      '@@': this.#idx.manifest.workspace.path,
+      '@@': this.#idx.manifest.workspace.path
     };
   }
 
   /** The role we are running as */
   get role(): Role {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return Env.TRV_ROLE.value as Role ?? 'std';
+    return (Env.TRV_ROLE.value as Role) ?? 'std';
   }
 
   /** Are we in production mode */
@@ -45,7 +43,7 @@ class $Runtime {
 
   /** Get debug value */
   get debug(): false | string {
-    return Env.DEBUG.isFalse ? false : (Env.DEBUG.value || false);
+    return Env.DEBUG.isFalse ? false : Env.DEBUG.value || false;
   }
 
   /** Manifest main */
@@ -80,7 +78,7 @@ class $Runtime {
 
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
   toolPath(...parts: string[]): string {
-    parts = parts.flatMap(part => part === '@' ? ['node_modules', this.#idx.manifest.main.name] : [part]);
+    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);
   }
 
@@ -95,12 +93,14 @@ class $Runtime {
 
   /** Resolve resource paths */
   resourcePaths(paths: string[] = []): string[] {
-    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(module => this.modulePath(module)))];
+    return [
+      ...new Set([...paths, ...(Env.TRV_RESOURCES.list ?? []), '@#resources', '@@#resources'].map(module => this.modulePath(module)))
+    ];
   }
 
   /** Get source for function */
   getSourceFile(handle: Function): string {
-    return this.#idx.getFromImport(this.getImport(handle))?.sourceFile!;
+    return this.#idx.getFromImport(this.getImport(handle))?.sourceFile ?? undefined!;
   }
 
   /** Get import for function */
@@ -146,11 +146,14 @@ class $Runtime {
       }
     }
     switch (this.workspace.manager) {
-      case 'npm': return `npm install ${production ? '' : '--save-dev '}${pkg}`;
-      case 'yarn': return `yarn add ${production ? '' : '--dev '}${pkg}`;
-      case 'pnpm': return `pnpm add ${production ? '' : '--dev '}${pkg}`;
+      case 'npm':
+        return `npm install ${production ? '' : '--save-dev '}${pkg}`;
+      case 'yarn':
+        return `yarn add ${production ? '' : '--dev '}${pkg}`;
+      case 'pnpm':
+        return `pnpm add ${production ? '' : '--dev '}${pkg}`;
     }
   }
 }
 
-export const Runtime = new $Runtime(RuntimeIndex, Env.TRV_RESOURCE_OVERRIDES.object);
+export const Runtime = new $Runtime(RuntimeIndex, Env.TRV_RESOURCE_OVERRIDES.object);

package/src/debug.ts

@@ -7,7 +7,6 @@ import type { ClassInstance } from './types.ts';
  */
 export function DebugBreak(): MethodDecorator {
   return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => descriptor;
-
 }
 
 /**
@@ -15,4 +14,4 @@ export function DebugBreak(): MethodDecorator {
  */
 export function tryDebugger(): boolean {
   return Env.TRV_DEBUG_BREAK.isTrue;
-}
+}

package/src/env.ts

@@ -3,11 +3,13 @@ import { castKey, castTo } from './types.ts';
 const IS_TRUE = /^(true|yes|on|1)$/i;
 const IS_FALSE = /^(false|no|off|0)$/i;
 
-export interface EnvData { }
+export interface EnvData {}
 
 export class EnvProp<T> {
   readonly key: string;
-  constructor(key: string) { this.key = key; }
+  constructor(key: string) {
+    this.key = key;
+  }
 
   /** Set value according to type */
   set(value: T | undefined | null): void {
@@ -26,14 +28,18 @@ export class EnvProp<T> {
   /** Export value */
   export(value?: T | undefined | null): Record<string, string> {
     let out: string;
-    if (arguments.length === 0) { // If nothing passed in
+    // biome-ignore lint/complexity/noArguments: We want to use arguments here to detect if nothing was truly passed
+    if (arguments.length === 0) {
+      // If nothing passed in
       out = `${this.value}`;
     } else if (value === undefined || value === null) {
       out = '';
     } else if (Array.isArray(value)) {
       out = value.join(',');
     } else if (typeof value === 'object') {
-      out = Object.entries(value).map(([key, keyValue]) => `${key}=${keyValue}`).join(',');
+      out = Object.entries(value)
+        .map(([key, keyValue]) => `${key}=${keyValue}`)
+        .join(',');
     } else {
       out = `${value}`;
     }
@@ -41,13 +47,19 @@ export class EnvProp<T> {
   }
 
   /** Read value as string */
-  get value(): 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 value = this.value;
-    return (value === undefined || value === '') ?
-      undefined : value.split(/[, ]+/g).map(item => item.trim()).filter(item => !!item);
+    return value === undefined || value === ''
+      ? undefined
+      : value
+          .split(/[, ]+/g)
+          .map(item => item.trim())
+          .filter(item => !!item);
   }
 
   /** Read value as object */
@@ -58,7 +70,7 @@ export class EnvProp<T> {
 
   /** Add values to list */
   add(...items: string[]): void {
-    process.env[this.key] = [... new Set([...this.list ?? [], ...items])].join(',');
+    process.env[this.key] = [...new Set([...(this.list ?? []), ...items])].join(',');
   }
 
   /** Read value as int  */
@@ -70,7 +82,7 @@ export class EnvProp<T> {
   /** Read value as boolean */
   get bool(): boolean | undefined {
     const value = this.value;
-    return (value === undefined || value === '') ? undefined : IS_TRUE.test(value);
+    return value === undefined || value === '' ? undefined : IS_TRUE.test(value);
   }
 
   /** Determine if the underlying value is truthy */
@@ -91,24 +103,32 @@ export class EnvProp<T> {
 }
 
 type EnvDataCombinedType = {
-  [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') |
-    (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
-  >
+  [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')
+    | (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
+  >;
 };
 
 function delegate<T extends object>(base: T): EnvDataCombinedType & T {
   return new Proxy(castTo(base), {
     get(target, property): unknown {
-      return typeof property !== 'string' ? undefined :
-        (property in base ? base[castKey(property)] :
-          target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property))
-        );
+      return typeof property !== 'string'
+        ? undefined
+        : property in base
+          ? base[castKey(property)]
+          : (target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property)));
     }
   });
 }
 
 /** Basic utils for reading known environment variables */
-export const Env = delegate({});
+export const Env = delegate({});

package/src/error.ts

@@ -1,13 +1,6 @@
 import { castTo } from './types.ts';
 
-export type ErrorCategory =
-  'general' |
-  'notfound' |
-  'data' |
-  'permissions' |
-  'authentication' |
-  'timeout' |
-  'unavailable';
+export type ErrorCategory = 'general' | 'notfound' | 'data' | 'permissions' | 'authentication' | 'timeout' | 'unavailable';
 
 export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T extends undefined ? { details?: T } : { details: T });
 
@@ -15,7 +8,6 @@ export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T
  * Framework error class, with the aim of being extensible
  */
 export class RuntimeError<T = Record<string, unknown> | undefined> extends Error {
-
   static defaultCategory: ErrorCategory = 'general';
 
   type: string;
@@ -28,14 +20,11 @@ export class RuntimeError<T = Record<string, unknown> | undefined> extends Error
    *
    * @param message The error message
    */
-  constructor(
-    ...[message, options]:
-      T extends undefined ? ([string] | [string, RuntimeErrorOptions<T>]) : [string, RuntimeErrorOptions<T>]
-  ) {
+  constructor(...[message, options]: T extends undefined ? [string] | [string, RuntimeErrorOptions<T>] : [string, RuntimeErrorOptions<T>]) {
     super(message, options?.cause ? { cause: options.cause } : undefined);
     this.type = options?.type ?? this.constructor.name;
-    this.details = options?.details!;
+    this.details = options?.details ?? undefined!;
     this.category = options?.category ?? castTo<typeof RuntimeError>(this.constructor).defaultCategory ?? 'general';
     this.at = new Date(options?.at ?? Date.now());
   }
-}
+}

package/src/exec.ts

@@ -1,9 +1,9 @@
-import { type ChildProcess, spawn, type SpawnOptions } from 'node:child_process';
+import { type ChildProcess, type SpawnOptions, spawn } from 'node:child_process';
 
-import { castTo } from './types.ts';
-import { RuntimeIndex } from './manifest-index.ts';
-import { BinaryUtil, type BinaryArray } from './binary.ts';
+import { type BinaryArray, BinaryUtil } from './binary.ts';
 import { CodecUtil } from './codec.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import { castTo } from './types.ts';
 
 const ResultSymbol = Symbol();
 
@@ -39,6 +39,17 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  * Standard utilities for managing executions
  */
 export class ExecUtil {
+  /** Read stream as string from a result */
+  static toString(result: ExecutionResult<BinaryArray | string>, stream: 'stdout' | 'stderr' | 'any'): string {
+    if (stream === 'any') {
+      return this.toString(result, 'stderr') || this.toString(result, 'stdout');
+    }
+    const value = result[stream];
+    if (typeof value === 'string') {
+      return value.trim();
+    }
+    return CodecUtil.toUTF8String(value).trim();
+  }
 
   /**
    * Take a child process, and some additional options, and produce a promise that
@@ -49,11 +60,14 @@ export class ExecUtil {
    * @param options The options to use to enhance the process
    */
   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<BinaryArray>>;
-  static getResult<T extends string | BinaryArray>(subProcess: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary?: false }): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary: true }): Promise<ExecutionResult<BinaryArray>>;
+  static getResult<T extends string | BinaryArray>(
+    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 result = (typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: BinaryArray[] = [];
       const stderr: BinaryArray[] = [];
       let done = false;
@@ -65,7 +79,7 @@ export class ExecUtil {
 
         const buffers = {
           stdout: BinaryUtil.combineBinaryArrays(stdout),
-          stderr: BinaryUtil.combineBinaryArrays(stderr),
+          stderr: BinaryUtil.combineBinaryArrays(stderr)
         };
 
         const final = {
@@ -74,37 +88,37 @@ export class ExecUtil {
           ...finalResult
         };
 
-        resolve(!final.valid ?
-          { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } :
-          final
-        );
+        resolve(!final.valid ? { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } : final);
       };
 
       subProcess.stdout?.on('data', data => stdout.push(CodecUtil.readChunk(data, subProcess.stdout?.readableEncoding)));
       subProcess.stderr?.on('data', data => stderr.push(CodecUtil.readChunk(data, subProcess.stderr?.readableEncoding)));
 
-      subProcess.on('error', (error: Error) =>
-        finish({ code: 1, message: error.message, valid: false }));
+      subProcess.on('error', (error: Error) => finish({ code: 1, message: error.message, valid: false }));
 
-      subProcess.on('close', (code: number) =>
-        finish({ code, valid: code === null || code === 0 }));
+      subProcess.on('close', (code: number) => finish({ code, valid: code === null || code === 0 }));
 
-      if (subProcess.exitCode !== null) { // We are already done
+      if (subProcess.exitCode !== null) {
+        // We are already done
         finish({ code: subProcess.exitCode, valid: subProcess.exitCode === 0 });
       }
-    });
-
-    return castTo(options.catch ? result : result.then(executionResult => {
-      if (executionResult.valid) {
-        return executionResult;
-      } else {
-        throw new Error(executionResult.message);
-      }
     }));
+
+    return castTo(
+      options.catch
+        ? result
+        : result.then(executionResult => {
+            if (executionResult.valid) {
+              return executionResult;
+            } else {
+              throw new Error(executionResult.message);
+            }
+          })
+    );
   }
 
   /** Spawn a package command */
   static spawnPackageCommand(cmd: string, args: string[], config: SpawnOptions = {}): ChildProcess {
     return spawn(process.argv0, [RuntimeIndex.resolvePackageCommand(cmd), ...args], config);
   }
-}
+}

package/src/file-loader.ts

@@ -2,14 +2,13 @@ import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import { type BinaryArray, type BinaryStream, BinaryUtil } from './binary.ts';
 import { RuntimeError } from './error.ts';
-import { BinaryUtil, type BinaryArray, type BinaryStream } from './binary.ts';
 
 /**
  * File loader that will search for files across the provided search paths
  */
 export class FileLoader {
-
   #searchPaths: readonly string[];
 
   constructor(paths: string[]) {
@@ -72,4 +71,4 @@ export class FileLoader {
     const buffer = BinaryUtil.binaryArrayToBuffer(await this.readBinaryArray(relativePath));
     return new File([buffer], path.basename(relativePath));
   }
-}
+}

package/src/function.ts

@@ -1,6 +1,6 @@
 import { ManifestModuleUtil } from '@travetto/manifest';
 
-export type FunctionMetadataTag = { hash: number, lines: [start: number, end: number, bodyStart?: number] };
+export type FunctionMetadataTag = { hash: number; lines: [start: number, end: number, bodyStart?: number] };
 export type FunctionMetadata = FunctionMetadataTag & {
   id: string;
   import: string;
@@ -26,13 +26,16 @@ const pending = new Set<Function>([]);
  * @private
  */
 export function registerFunction(
-  input: Function, [module, relativePath]: [string, string], tag: FunctionMetadataTag,
-  methods?: Record<string, FunctionMetadataTag>, abstract?: boolean,
+  input: Function,
+  [module, relativePath]: [string, string],
+  tag: FunctionMetadataTag,
+  methods?: Record<string, FunctionMetadataTag>,
+  abstract?: boolean
 ): void {
   const modulePath = ManifestModuleUtil.withoutSourceExtension(relativePath);
 
   const metadata: FunctionMetadata = {
-    id: (input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`),
+    id: input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`,
     import: `${module}/${relativePath}`,
     module,
     modulePath,
@@ -65,5 +68,10 @@ export function describeFunction(input?: Function): FunctionMetadata | undefined
 
 const foreignTypeRegistry = new Map<string, Function>();
 export function foreignType(id: string): Function {
-  return foreignTypeRegistry.getOrInsert(id, class { static Ⲑid = id; });
-}
+  return foreignTypeRegistry.getOrInsert(
+    id,
+    class {
+      static Ⲑid = id;
+    }
+  );
+}

package/src/global.d.ts

@@ -2,10 +2,6 @@ import './types';
 
 declare const write: unique symbol;
 
-declare global {
-  var devProcessWarningExclusions: ((message: string, category: string) => boolean)[] | undefined;
-}
-
 declare global {
   // https://github.com/microsoft/TypeScript/issues/59012
   interface WritableStreamDefaultWriter<W = any> {
@@ -20,28 +16,28 @@ declare global {
   /**
    * @concrete node:buffer#Blob
    */
-  interface Blob { }
+  interface Blob {}
 
   /**
    * @concrete node:buffer#File
    */
-  interface File { }
+  interface File {}
 
   /**
    * @concrete node:stream/web#ReadableStream
    */
-  interface ReadableStream { }
+  interface ReadableStream {}
 
   /**
    * @concrete node:buffer#Buffer
    */
-  interface Buffer { }
+  interface Buffer {}
 
   namespace NodeJS {
     /**
      * @concrete node:stream#Readable
      */
-    interface ReadableStream { }
+    interface ReadableStream {}
   }
 }
 
@@ -49,26 +45,38 @@ declare module 'buffer' {
   /**
    * @concrete node:buffer#Blob
    */
-  interface Blob { }
+  interface Blob {}
 
   /**
    * @concrete node:buffer#File
    */
-  interface File { }
+  interface File {}
+}
+
+declare module 'node:buffer' {
+  /**
+   * @concrete node:buffer#Blob
+   */
+  interface Blob {}
+
+  /**
+   * @concrete node:buffer#File
+   */
+  interface File {}
 }
 
 declare module 'stream' {
   /**
    * @concrete node:stream#Readable
    */
-  interface Readable { }
+  interface Readable {}
 }
 
 declare module 'stream/web' {
   /**
    * @concrete node:stream/web#ReadableStream
    */
-  interface ReadableStream { }
+  interface ReadableStream {}
 }
 
 // Remove once node 26 types are released
@@ -76,4 +84,4 @@ declare module 'node:fs' {
   interface StatOptions {
     throwIfNoEntry?: boolean;
   }
-}
+}

package/src/json.ts

@@ -3,27 +3,33 @@ import { AssertionError } from 'node:assert';
 import type { BinaryArray } from './binary.ts';
 import { CodecUtil } from './codec.ts';
 import { RuntimeError, type RuntimeErrorOptions } from './error.ts';
-import { castTo, type Any } from './types.ts';
+import { type Any, castTo } from './types.ts';
 
 const VALID_JSON_ERROR_TYPES = ['runtime', 'plain', 'assert'] as const;
 const VALID_JSON_ERROR_TYPE_SET = new Set<unknown>(VALID_JSON_ERROR_TYPES);
 
 type JSONTransformer = (this: unknown, key: string, value: unknown) => unknown;
-type JSONOutputConfig = { indent?: number, replacer?: JSONTransformer };
+type JSONOutputConfig = { indent?: number; replacer?: JSONTransformer };
 type JSONInputConfig = { reviver?: JSONTransformer };
 type JSONCloneConfig = JSONOutputConfig & JSONInputConfig;
-type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number], name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
+type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number]; name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
 
 Object.defineProperty(BigInt.prototype, 'toJSON', {
-  value() { return `${this}n`; },
+  value() {
+    return `${this}n`;
+  }
 });
 
 Object.defineProperty(Error.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 Object.defineProperty(RuntimeError.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
@@ -31,7 +37,6 @@ const BIGINT_REGEX = /^-?\d+n$/;
 
 /** Utilities for JSON  */
 export class JSONUtil {
-
   static includeStackTraces = false;
 
   static TRANSMIT_REVIVER: JSONTransformer = function (this: unknown, key: string, value: unknown): unknown {
@@ -47,7 +52,6 @@ export class JSONUtil {
     return value;
   };
 
-
   static isJSONError(value: unknown): value is JSONError {
     return typeof value === 'object' && value !== null && '$trv' in value && VALID_JSON_ERROR_TYPE_SET.has(value.$trv);
   }
@@ -57,12 +61,20 @@ export class JSONUtil {
     const { $trv, message, stack, name, ...rest } = error;
     let response: Error;
     switch ($trv) {
-      case 'runtime': response = new RuntimeError(message!, castTo<Any>(rest)); break;
-      case 'assert': response = new AssertionError({ message, ...rest }); break;
-      case 'plain': response = new Error(message!); break;
+      case 'runtime':
+        response = new RuntimeError(message!, castTo<Any>(rest));
+        break;
+      case 'assert':
+        response = new AssertionError({ message, ...rest });
+        break;
+      case 'plain':
+        response = new Error(message!);
+        break;
     }
     response.stack = stack;
-    if (name) { response.name = name; }
+    if (name) {
+      response.name = name;
+    }
     return response;
   }
 
@@ -73,21 +85,29 @@ export class JSONUtil {
     includeStack ??= JSONUtil.includeStackTraces;
     let $trv: JSONError['$trv'];
     switch (true) {
-      case error instanceof RuntimeError: $trv = 'runtime'; break;
-      case error instanceof AssertionError: $trv = 'assert'; break;
-      default: $trv = 'plain'; break;
+      case error instanceof RuntimeError:
+        $trv = 'runtime';
+        break;
+      case error instanceof AssertionError:
+        $trv = 'assert';
+        break;
+      default:
+        $trv = 'plain';
+        break;
     }
     return {
       $trv,
       message: error.message,
       ...(error.cause ? { cause: `${error.cause}` } : undefined),
       ...(includeStack ? { stack: error.stack } : undefined),
-      ...(error instanceof RuntimeError ? {
-        category: error.category,
-        type: error.type,
-        at: error.at,
-        ...(error.details ? { details: error.details } : undefined!),
-      } : {})
+      ...(error instanceof RuntimeError
+        ? {
+            category: error.category,
+            type: error.type,
+            at: error.at,
+            ...(error.details ? { details: error.details } : undefined!)
+          }
+        : {})
     };
   }
 
@@ -147,4 +167,4 @@ export class JSONUtil {
   static cloneFromTransmit<T, R = T>(input: T): R {
     return JSONUtil.clone<T, R>(input, { reviver: JSONUtil.TRANSMIT_REVIVER });
   }
-}
+}

package/src/manifest-index.ts

@@ -1,4 +1,4 @@
 import { ManifestIndex } from '@travetto/manifest';
 
 /** Runtime manifest index */
-export const RuntimeIndex = new ManifestIndex();
+export const RuntimeIndex = new ManifestIndex();