@travetto/pack 8.0.0-alpha.22 → 8.0.0-alpha.24

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/pack
 yarn add @travetto/pack
 ```
 
-This module provides the necessary tools to produce deliverable output for [Travetto](https://travetto.dev) based projects.  The main interaction with this module is through the command line interface, and the operations it provides.  Under the covers, the code bundling is performed by [Rollup](https://rollupjs.org/), with specific configuration to support the frameworks runtime expectations. 
+This module provides the necessary tools to produce deliverable output for [Travetto](https://travetto.dev) based projects. The main interaction with this module is through the command line interface, and the operations it provides. Under the covers, the code bundling is performed by [Rollup](https://rollupjs.org/), with specific configuration to support the frameworks runtime expectations. 
 
 There are three primary cli commands for packing your code:
    *  pack
@@ -61,7 +61,7 @@ This command line operation will compile your project, and produce a ready to us
 Specific to this CLI command, the `output` field determines where the final folder is written that contains all the compiled source.
 
 ### Entry Point Configuration
-Every application requires an entry point to determine execution flow (and in [Rollup](https://rollupjs.org/)'s case, tree-shaking as well.).  By default the [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") acts as the entry point.  This bypasses the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework") intentionally, as the compiler is not available at runtime. 
+Every application requires an entry point to determine execution flow (and in [Rollup](https://rollupjs.org/)'s case, tree-shaking as well.). By default the [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") acts as the entry point. This bypasses the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework") intentionally, as the compiler is not available at runtime. 
 
 Within the command line, the `args` are positional arguments that will be passed to the entry point on application run.
 
@@ -85,16 +85,16 @@ And this entry point would be what is executed by [docker](https://www.docker.co
 ### General Packing Operations
 Every [Pack](https://github.com/travetto/travetto/tree/main/module/pack#readme "Code packing utilities") operation extends from the base command, and that provides some consistent operations that run on every packing command.
    *  `clean` - Empties workspace before beginning, controlled by the `--clean` flag, defaults to on
-   *  `writeEnv` - Writes the .env.js files that includes the necessary details to start the application.  This is primarily to identify the location of the manifest file needed to run.
+   *  `writeEnv` - Writes the .env.js files that includes the necessary details to start the application. This is primarily to identify the location of the manifest file needed to run.
    *  `writePackageJson` - Generates the [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) with the appropriate module type ([CommonJS](https://nodejs.org/api/modules.html) or [Ecmascript Module](https://nodejs.org/api/esm.html)) for interpreting plain `.js` files
    *  `writeEntryScript` - Create the entry script based on the `--entry-command`, `args`
    *  `copyResources` - Will pull in local `resources/**` files into the final output
-   *  `primeAppCache` - Runs `trv run` to ensure the appropriate files are generated to allow for running the application.  This only applies if the entry point is equivalent to `trv run`
-   *  `writeManifest` - Produces the `production`-ready manifest that is used at runtime.  Removes all devDependencies from the manifest.json
-   *  `bundle` - Invokes [Rollup](https://rollupjs.org/) with the appropriate file set to produce a single output .js file.  Depending on the module type ([CommonJS](https://nodejs.org/api/modules.html) or [Ecmascript Module](https://nodejs.org/api/esm.html)) the build process differs to handle the dynamic loading that application does at runtime.
+   *  `primeAppCache` - Runs `trv run` to ensure the appropriate files are generated to allow for running the application. This only applies if the entry point is equivalent to `trv run`
+   *  `writeManifest` - Produces the `production`-ready manifest that is used at runtime. Removes all devDependencies from the manifest.json
+   *  `bundle` - Invokes [Rollup](https://rollupjs.org/) with the appropriate file set to produce a single output .js file. Depending on the module type ([CommonJS](https://nodejs.org/api/modules.html) or [Ecmascript Module](https://nodejs.org/api/esm.html)) the build process differs to handle the dynamic loading that application does at runtime.
 
 ## CLI - pack:zip
-This command is nearly identical to the standard `pack` operation, except for the `output` flag.  In this scenario, the `output` flag determines the location and name of the final zip file.
+This command is nearly identical to the standard `pack` operation, except for the `output` flag. In this scenario, the `output` flag determines the location and name of the final zip file.
 
 **Terminal: Help for pack:zip**
 ```bash
@@ -178,16 +178,16 @@ Options:
 Examples:
 ```
 
-The additional flags provided are allow for specifying the base image, the final docker image name (and tags), and which registry to push to (if  any).  Additionally, there are flags for exposing which ports the image should expect to open as well.   When using the `--eject-file`  flag, the output script will produce the entire Dockerfile output inline, so that it can be easily modified as needed. 
+The additional flags provided are allow for specifying the base image, the final docker image name (and tags), and which registry to push to (if any). Additionally, there are flags for exposing which ports the image should expect to open as well. When using the `--eject-file` flag, the output script will produce the entire Dockerfile output inline, so that it can be easily modified as needed. 
 
 In addition to the standard operations, this command adds the following steps:
    *  `writeDockerFile` - Generate the docker file contents
    *  `pullDockerBaseImage` - Pull base image, to ensure its available and primed
    *  `buildDockerContainer` - Build final container
-   *  `pushDockerContainer` - Push container with appropriate tags.  Only applies if `--docker-push` is specified
+   *  `pushDockerContainer` - Push container with appropriate tags. Only applies if `--docker-push` is specified
 
 ## Ejected File
-As indicated, any of the pack operations can be ejected, and produce an output that can be run independent of the pack command.  This is helpful when integrating with more complicated build processes.
+As indicated, any of the pack operations can be ejected, and produce an output that can be run independent of the pack command. This is helpful when integrating with more complicated build processes.
 
 **Terminal: Sample Ejected File**
 ```bash

package/__index__.ts

@@ -1,2 +1,2 @@
-export type { CommonPackConfig, DockerPackFactory, DockerPackConfig } from './src/types.ts';
-export { PackConfigUtil } from './src/config-util.ts';
+export { PackConfigUtil } from './src/config-util.ts';
+export type { CommonPackConfig, DockerPackConfig, DockerPackFactory } from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/pack",
-  "version": "8.0.0-alpha.22",
+  "version": "8.0.0-alpha.24",
   "type": "module",
   "description": "Code packing utilities",
   "keywords": [
@@ -30,12 +30,12 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",
-    "@travetto/runtime": "^8.0.0-alpha.19",
-    "@travetto/terminal": "^8.0.0-alpha.19",
+    "@travetto/runtime": "^8.0.0-alpha.21",
+    "@travetto/terminal": "^8.0.0-alpha.21",
     "rollup": "^4.62.2"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.26"
+    "@travetto/cli": "^8.0.0-alpha.29"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/config-util.ts

@@ -18,11 +18,14 @@ export class PackConfigUtil {
     const { os, packages } = config.dockerRuntime;
     if (packages?.length) {
       switch (os) {
-        case 'alpine': return `RUN apk --update add ${packages.join(' ')} && rm -rf /var/cache/apk/*`;
-        case 'debian': return `RUN apt update && apt install -y ${packages.join(' ')} && rm -rf  /var/lib/{apt,dpkg,cache,log}/`;
-        case 'centos': return `RUN yum -y install ${packages.join(' ')} && yum -y clean all && rm -fr /var/cache`;
-        case 'unknown':
-        default: throw new Error('Unable to install packages in an unknown os');
+        case 'alpine':
+          return `RUN apk --update add ${packages.join(' ')} && rm -rf /var/cache/apk/*`;
+        case 'debian':
+          return `RUN apt update && apt install -y ${packages.join(' ')} && rm -rf  /var/lib/{apt,dpkg,cache,log}/`;
+        case 'centos':
+          return `RUN yum -y install ${packages.join(' ')} && yum -y clean all && rm -fr /var/cache`;
+        default:
+          throw new Error('Unable to install packages in an unknown os');
       }
     } else {
       return '';
@@ -38,9 +41,11 @@ export class PackConfigUtil {
       const [name, directive] = item.split(':');
       switch (directive) {
         case 'from-source':
-          out.push(`RUN npm_config_build_from_source=true npm install ${name} --build-from-source`); break;
+          out.push(`RUN npm_config_build_from_source=true npm install ${name} --build-from-source`);
+          break;
         default:
-          out.push(`RUN npm install ${name}`); break;
+          out.push(`RUN npm install ${name}`);
+          break;
       }
     }
     if (out.length) {
@@ -65,11 +70,13 @@ export class PackConfigUtil {
       return '';
     } else {
       switch (os) {
-        case 'alpine': return `RUN addgroup -g ${groupId} ${group} && adduser -D -G ${group} -u ${userId} ${user}`;
+        case 'alpine':
+          return `RUN addgroup -g ${groupId} ${group} && adduser -D -G ${group} -u ${userId} ${user}`;
         case 'debian':
-        case 'centos': return `RUN groupadd --gid ${groupId} ${group} && useradd -u ${userId} -g ${group} ${user}`;
-        case 'unknown':
-        default: throw new Error('Unable to add user/group for an unknown os');
+        case 'centos':
+          return `RUN groupadd --gid ${groupId} ${group} && useradd -u ${userId} -g ${group} ${user}`;
+        default:
+          throw new Error('Unable to add user/group for an unknown os');
       }
     }
   }
@@ -78,9 +85,7 @@ export class PackConfigUtil {
    * Setup Env Vars for NODE_OPTIONS and other standard environment variables
    */
   static dockerEnvVars(config: DockerPackConfig): string {
-    return [
-      `ENV NODE_OPTIONS="${[...(config.sourcemap ? ['--enable-source-maps'] : [])].join(' ')}"`,
-    ].join('\n');
+    return [`ENV NODE_OPTIONS="${[...(config.sourcemap ? ['--enable-source-maps'] : [])].join(' ')}"`].join('\n');
   }
 
   /**
@@ -88,9 +93,7 @@ export class PackConfigUtil {
    */
   static dockerAppFolder(config: DockerPackConfig): string {
     const { folder, user, group } = config.dockerRuntime;
-    return [
-      `RUN mkdir ${folder} && chown ${user}:${group} ${folder}`,
-    ].join('\n');
+    return [`RUN mkdir ${folder} && chown ${user}:${group} ${folder}`].join('\n');
   }
 
   /**
@@ -106,11 +109,7 @@ export class PackConfigUtil {
    */
   static dockerEntrypoint(config: DockerPackConfig): string {
     const { user, folder } = config.dockerRuntime;
-    return [
-      `USER ${user}`,
-      `WORKDIR ${folder}`,
-      `ENTRYPOINT ["${folder}/${config.mainName}.sh"]`,
-    ].join('\n');
+    return [`USER ${user}`, `WORKDIR ${folder}`, `ENTRYPOINT ["${folder}/${config.mainName}.sh"]`].join('\n');
   }
   /**
    * Common docker environment setup
@@ -122,8 +121,10 @@ export class PackConfigUtil {
       this.dockerPackageInstall(config),
       this.dockerAppFolder(config),
       this.dockerAppFiles(config),
-      this.dockerEnvVars(config),
-    ].filter(line => !!line).join('\n');
+      this.dockerEnvVars(config)
+    ]
+      .filter(line => !!line)
+      .join('\n');
   }
 
   /**
@@ -137,4 +138,4 @@ export class PackConfigUtil {
       this.dockerEntrypoint(config)
     ].join('\n');
   }
-}
+}

package/src/types.ts

@@ -1,5 +1,5 @@
-import { type OutputOptions } from 'rollup';
 import type terser from '@rollup/plugin-terser';
+import type { OutputOptions } from 'rollup';
 
 export type CommonPackConfig = {
   buildDirectory: string;
@@ -59,10 +59,10 @@ export type ShellCommandProvider = {
   comment(message: string): string[];
   echo(text: string): string[];
   zip(output: string): string[];
-  script(lines: string[], chdir?: boolean): { ext: string, contents: string[] };
+  script(lines: string[], chdir?: boolean): { ext: string; contents: string[] };
 };
 
-export type DockerPackFactory = (config: DockerPackConfig) => (string | Promise<string>);
+export type DockerPackFactory = (config: DockerPackConfig) => string | Promise<string>;
 export type DockerPackFactoryModule = { factory: DockerPackFactory };
 
 export type CoreRollupConfig = {
@@ -73,4 +73,4 @@ export type CoreRollupConfig = {
   ignore: Set<string>;
   external: string[];
   minify: Parameters<typeof terser>[0];
-};
+};

package/support/bin/docker-operation.ts

@@ -1,46 +1,64 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { JSONUtil, Runtime } from '@travetto/runtime';
 import { cliTpl } from '@travetto/cli';
+import { JSONUtil, Runtime } from '@travetto/runtime';
 
-import { ActiveShellCommand } from './shell.ts';
 import type { DockerPackConfig, DockerPackFactoryModule } from '../../src/types.ts';
 import { PackOperation } from './operation.ts';
+import { ActiveShellCommand } from './shell.ts';
 import { PackUtil } from './util.ts';
 
 export class DockerPackOperation {
-
   static getDockerTags(config: DockerPackConfig): string[] {
-    return (config.dockerTag ?? []).map(tag => config.dockerRegistry ? `${config.dockerRegistry}/${config.dockerName}:${tag}` : `${config.dockerName}:${tag}`);
+    return (config.dockerTag ?? []).map(tag =>
+      config.dockerRegistry ? `${config.dockerRegistry}/${config.dockerName}:${tag}` : `${config.dockerName}:${tag}`
+    );
   }
 
   /**
    * Detect image os
    */
-  static async* detectDockerImageOs(config: DockerPackConfig): AsyncIterable<string[]> {
+  static async *detectDockerImageOs(config: DockerPackConfig): AsyncIterable<string[]> {
     // Read os before writing
-    config.dockerRuntime.os = await PackUtil.runCommand(
-      ['docker', 'run', '--rm', '--entrypoint', '/bin/sh', config.dockerImage, '-c', 'cat /etc/*release*']
-    ).then(out => {
+    config.dockerRuntime.os = await PackUtil.runCommand([
+      'docker',
+      'run',
+      '--rm',
+      '--entrypoint',
+      '/bin/sh',
+      config.dockerImage,
+      '-c',
+      'cat /etc/*release*'
+    ]).then(out => {
       const found = out.toLowerCase().match(/\b(?:debian|alpine|centos)\b/)?.[0];
       switch (found) {
-        case 'debian': case 'alpine': case 'centos': return found;
-        default: return 'unknown';
+        case 'debian':
+        case 'alpine':
+        case 'centos':
+          return found;
+        default:
+          return 'unknown';
       }
     });
-    yield* PackOperation.title(config, cliTpl`${{ title: 'Detected Image OS' }} ${{ param: config.dockerImage }} as ${{ param: config.dockerRuntime.os }}`);
+    yield* PackOperation.title(
+      config,
+      cliTpl`${{ title: 'Detected Image OS' }} ${{ param: config.dockerImage }} as ${{ param: config.dockerRuntime.os }}`
+    );
   }
 
   /**
    * Write Docker File
    */
-  static async* writeDockerFile(config: DockerPackConfig): AsyncIterable<string[]> {
+  static async *writeDockerFile(config: DockerPackConfig): AsyncIterable<string[]> {
     const dockerFile = path.resolve(config.buildDirectory, 'Dockerfile');
     const { factory } = await Runtime.importFrom<DockerPackFactoryModule>(config.dockerFactory);
     const content = (await factory(config)).trim();
 
-    yield* PackOperation.title(config, cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: config.dockerFactory }}`);
+    yield* PackOperation.title(
+      config,
+      cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: config.dockerFactory }}`
+    );
 
     if (config.ejectFile) {
       yield* ActiveShellCommand.createFile(dockerFile, content.split(/\n/));
@@ -52,7 +70,7 @@ export class DockerPackOperation {
   /**
    * Pull Docker Base Image
    */
-  static async* pullDockerBaseImage(config: DockerPackConfig): AsyncIterable<string[]> {
+  static async *pullDockerBaseImage(config: DockerPackConfig): AsyncIterable<string[]> {
     const command = ['docker', 'pull', config.dockerImage];
 
     yield* PackOperation.title(config, cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: config.dockerImage }}`);
@@ -67,11 +85,13 @@ export class DockerPackOperation {
   /**
    * Building Docker Container
    */
-  static async* buildDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
+  static async *buildDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
     const cmd = [
-      'docker', 'build',
+      'docker',
+      'build',
       ...(config.dockerBuildPlatform ? ['--platform', config.dockerBuildPlatform] : []),
-      ...DockerPackOperation.getDockerTags(config).flatMap(tag => ['-t', tag]), '.'
+      ...DockerPackOperation.getDockerTags(config).flatMap(tag => ['-t', tag]),
+      '.'
     ];
 
     yield* PackOperation.title(config, cliTpl`${{ title: 'Building Docker Container' }} ${{ param: config.dockerTag?.join(',') }}`);
@@ -90,7 +110,7 @@ export class DockerPackOperation {
   /**
    * Push Docker Container
    */
-  static async* pushDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
+  static async *pushDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
     if (!config.dockerPush) {
       return;
     }
@@ -109,4 +129,4 @@ export class DockerPackOperation {
       }
     }
   }
-}
+}

package/support/bin/operation.ts

@@ -2,18 +2,17 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { cliTpl } from '@travetto/cli';
-import { JSONUtil, Env, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { Env, JSONUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import type { CommonPackConfig } from '../../src/types.ts';
-import { PackUtil } from './util.ts';
 import { ActiveShellCommand, ShellCommands } from './shell.ts';
+import { PackUtil } from './util.ts';
 
 /**
  * General pack operations
  */
 export class PackOperation {
-
-  static async * title(config: CommonPackConfig, title: string): AsyncIterable<string[]> {
+  static async *title(config: CommonPackConfig, title: string): AsyncIterable<string[]> {
     if (config.ejectFile) {
       yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.echo(title);
@@ -25,7 +24,7 @@ export class PackOperation {
   /**
    * Clean out pack workspace, removing all content
    */
-  static async * clean(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *clean(config: CommonPackConfig): AsyncIterable<string[]> {
     if (!config.clean) {
       return;
     }
@@ -50,39 +49,47 @@ export class PackOperation {
   /**
    * Invoke bundler (rollup) to produce output in workspace folder
    */
-  static async * bundle(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *bundle(config: CommonPackConfig): AsyncIterable<string[]> {
     const cwd = RuntimeIndex.outputRoot;
     const out = RuntimeIndex.manifest.build.outputFolder;
 
-    const bundleCommand = [process.argv0, RuntimeIndex.resolvePackageCommand('rollup'), '-c', RuntimeIndex.resolveFileImport(config.rollupConfiguration)];
+    const bundleCommand = [
+      process.argv0,
+      RuntimeIndex.resolvePackageCommand('rollup'),
+      '-c',
+      RuntimeIndex.resolveFileImport(config.rollupConfiguration)
+    ];
 
     const entryPointFile = RuntimeIndex.getFromImport(config.entryPoint)!.outputFile.split(`${out}/`)[1];
 
     const env = {
-      ...Object.fromEntries(([
-        ['BUNDLE_ENTRY', entryPointFile],
-        ['BUNDLE_MAIN_FILE', config.mainFile],
-        ['BUNDLE_COMPRESS', config.minify],
-        ['BUNDLE_SOURCEMAP', config.sourcemap],
-        ['BUNDLE_SOURCES', config.includeSources],
-        ['BUNDLE_OUTPUT', config.buildDirectory],
-        ['BUNDLE_ENV_FILE', config.envFile],
-        ['BUNDLE_EXTERNAL', config.externalDependencies.map(module => module.split(':')[0]).join(',')]
-      ] as const)
-        .filter(pair => pair[1] === false || pair[1])
-        .map(pair => [pair[0], `${pair[1]}`])
+      ...Object.fromEntries(
+        (
+          [
+            ['BUNDLE_ENTRY', entryPointFile],
+            ['BUNDLE_MAIN_FILE', config.mainFile],
+            ['BUNDLE_COMPRESS', config.minify],
+            ['BUNDLE_SOURCEMAP', config.sourcemap],
+            ['BUNDLE_SOURCES', config.includeSources],
+            ['BUNDLE_OUTPUT', config.buildDirectory],
+            ['BUNDLE_ENV_FILE', config.envFile],
+            ['BUNDLE_EXTERNAL', config.externalDependencies.map(module => module.split(':')[0]).join(',')]
+          ] as const
+        )
+          .filter(pair => pair[1] === false || pair[1])
+          .map(pair => [pair[0], `${pair[1]}`])
       ),
-      ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(config.module)!.outputPath),
+      ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(config.module)!.outputPath)
     };
 
     const properties = (['minify', 'sourcemap', 'entryPoint'] as const)
-      .map(key => cliTpl`${{ subtitle: key }}=${{ param: config[key] }}`).join(' ');
+      .map(key => cliTpl`${{ subtitle: key }}=${{ param: config[key] }}`)
+      .join(' ');
 
     yield* PackOperation.title(config, cliTpl`${{ title: 'Bundling Output' }} ${properties}`);
 
     if (config.ejectFile) {
-      yield* Object
-        .entries(env)
+      yield* Object.entries(env)
         .filter(pair => !!pair[1])
         .map(pair => ActiveShellCommand.export(pair[0], pair[1]));
       yield ActiveShellCommand.chdir(cwd);
@@ -98,29 +105,23 @@ export class PackOperation {
   /**
    * Write out package.json, to help define how output .js file should be interpreted
    */
-  static async * writePackageJson(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *writePackageJson(config: CommonPackConfig): AsyncIterable<string[]> {
     const file = 'package.json';
     const pkg = { type: 'module', main: config.mainFile };
 
     yield* PackOperation.title(config, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
 
     if (config.ejectFile) {
-      yield* ActiveShellCommand.createFile(
-        path.resolve(config.buildDirectory, file),
-        [JSONUtil.toUTF8(pkg)]
-      );
+      yield* ActiveShellCommand.createFile(path.resolve(config.buildDirectory, file), [JSONUtil.toUTF8(pkg)]);
     } else {
-      await PackUtil.writeRawFile(
-        path.resolve(config.buildDirectory, file),
-        [JSONUtil.toUTF8Pretty(pkg)]
-      );
+      await PackUtil.writeRawFile(path.resolve(config.buildDirectory, file), [JSONUtil.toUTF8Pretty(pkg)]);
     }
   }
 
   /**
    * Define .env.js file to control manifest location
    */
-  static async * writeEnv(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *writeEnv(config: CommonPackConfig): AsyncIterable<string[]> {
     const file = path.resolve(config.buildDirectory, config.envFile);
     const env = {
       ...Env.NODE_ENV.export('production'),
@@ -129,40 +130,34 @@ export class PackOperation {
       ...Env.TRV_CLI_IPC.export(undefined),
       ...Env.TRV_RESOURCE_OVERRIDES.export({
         '@#resources': '@@#resources',
-        ...(config.includeWorkspaceResources ? {
-          '@@#resources': `@@#${config.workspaceResourceFolder}`
-        } : {})
+        ...(config.includeWorkspaceResources
+          ? {
+              '@@#resources': `@@#${config.workspaceResourceFolder}`
+            }
+          : {})
       })
     };
 
     yield* PackOperation.title(config, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
 
     if (config.ejectFile) {
-      yield* ActiveShellCommand.createFile(
-        path.resolve(config.buildDirectory, file),
-        PackUtil.buildEnvFile(env)
-      );
+      yield* ActiveShellCommand.createFile(path.resolve(config.buildDirectory, file), PackUtil.buildEnvFile(env));
     } else {
-      await PackUtil.writeRawFile(
-        path.resolve(config.buildDirectory, file),
-        PackUtil.buildEnvFile(env)
-      );
+      await PackUtil.writeRawFile(path.resolve(config.buildDirectory, file), PackUtil.buildEnvFile(env));
     }
   }
 
   /**
    * Create launcher scripts (.sh, .cmd) to run output
    */
-  static async * writeEntryScript(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *writeEntryScript(config: CommonPackConfig): AsyncIterable<string[]> {
     if (!config.mainScripts && !config.entryPoint.includes('@travetto/cli')) {
       return;
     }
 
     const title = 'Writing entry scripts';
     for (const sh of [ShellCommands.posix, ShellCommands.win32]) {
-      const { ext, contents } = sh.script(
-        sh.callCommandWithAllArgs('node', config.mainFile, ...config.entryArguments), true
-      );
+      const { ext, contents } = sh.script(sh.callCommandWithAllArgs('node', config.mainFile, ...config.entryArguments), true);
       const file = `${config.mainName}${ext}`;
       const args = config.entryArguments.join(' ');
 
@@ -170,7 +165,6 @@ export class PackOperation {
 
       if (config.ejectFile) {
         yield* ActiveShellCommand.createFile(path.resolve(config.buildDirectory, file), contents, '755');
-
       } else {
         await PackUtil.writeRawFile(path.resolve(config.buildDirectory, file), contents, '755');
       }
@@ -180,7 +174,7 @@ export class PackOperation {
   /**
    * Copy over repo /resources folder into workspace, will get packaged into final output
    */
-  static async * copyMonoRepoResources(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *copyMonoRepoResources(config: CommonPackConfig): AsyncIterable<string[]> {
     if (!config.includeWorkspaceResources) {
       return;
     }
@@ -200,7 +194,7 @@ export class PackOperation {
   /**
    * Copy over /resources folder into workspace, will get packaged into final output
    */
-  static async * copyResources(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *copyResources(config: CommonPackConfig): AsyncIterable<string[]> {
     const resources = {
       count: RuntimeIndex.mainModule.files.resources?.length ?? 0,
       sourceDirectory: path.resolve(Runtime.mainSourcePath, 'resources'),
@@ -223,7 +217,7 @@ export class PackOperation {
   /**
    * Produce the output manifest, only including production dependencies
    */
-  static async * writeManifest(config: CommonPackConfig): AsyncIterable<string[]> {
+  static async *writeManifest(config: CommonPackConfig): AsyncIterable<string[]> {
     const out = path.resolve(config.buildDirectory, config.manifestFile);
     const cmd = [process.argv0, RuntimeIndex.resolvePackageCommand('trvc'), 'manifest:production', out];
     const env = { ...Env.TRV_MODULE.export(config.module) };
@@ -240,8 +234,7 @@ export class PackOperation {
   /**
    * Generate ZIP file for workspace
    */
-  static async * compress(config: CommonPackConfig): AsyncIterable<string[]> {
-
+  static async *compress(config: CommonPackConfig): AsyncIterable<string[]> {
     yield* PackOperation.title(config, cliTpl`${{ title: 'Compressing' }} ${{ path: config.output }}`);
 
     if (config.ejectFile) {
@@ -254,4 +247,4 @@ export class PackOperation {
       await PackUtil.runCommand(ActiveShellCommand.zip(config.output), { cwd: config.buildDirectory });
     }
   }
-}
+}

package/support/bin/preamble.ts

@@ -1,10 +1,15 @@
 import { readFileSync as readSyncPreamble } from 'node:fs';
 
 // @ts-expect-error -- Lock to prevent __proto__ pollution in JSON
+// biome-ignore lint/suspicious/noProto: Lock to prevent __proto__ pollution in JSON
 const objectProto = Object.prototype.__proto__;
 Object.defineProperty(Object.prototype, '__proto__', {
-  get() { return objectProto; },
-  set(value) { Object.setPrototypeOf(this, value); }
+  get() {
+    return objectProto;
+  },
+  set(value) {
+    Object.setPrototypeOf(this, value);
+  }
 });
 
 if (!process.env.TRV_MODULE && '%%ENV_FILE%%') {
@@ -13,6 +18,8 @@ if (!process.env.TRV_MODULE && '%%ENV_FILE%%') {
       .split('\n')
       .map(line => line.match(/\s*(?<key>[^ =]+)\s*=\s*(?<value>\S+)/)?.groups)
       .filter(pair => !!pair)
-      .forEach(pair => process.env[pair.key] = pair.value);
-  } catch { }
-}
+      .forEach(pair => {
+        process.env[pair.key] = pair.value;
+      });
+  } catch {}
+}

package/support/bin/shell.ts

@@ -1,18 +1,14 @@
-import util from 'node:util';
 import path from 'node:path';
+import util from 'node:util';
 
 import type { ShellCommandProvider } from '../../src/types.ts';
 
-const escape = (text: string): string =>
-  text
-    .replaceAll('"', '\\"')
-    .replaceAll('$', '\\$');
+const shellEscape = (text: string): string => text.replaceAll('"', '\\"').replaceAll('$', '\\$');
 
-const escapedArgs = (args: string[]): string[] => args.map(arg =>
-  arg.includes(' ') || arg.includes('"') ? `'${arg}'` : (arg.includes("'") ? `"${arg}"` : arg)
-);
+const escapedArgs = (args: string[]): string[] =>
+  args.map(arg => (arg.includes(' ') || arg.includes('"') ? `'${arg}'` : arg.includes("'") ? `"${arg}"` : arg));
 
-const toWin = (file: string): string => file.replace(/[\\\/]+/g, path.win32.sep);
+const toWin = (file: string): string => file.replace(/[/\\]+/g, path.win32.sep);
 
 export const ShellCommands: Record<'win32' | 'posix', ShellCommandProvider> = {
   win32: {
@@ -20,55 +16,56 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandProvider> = {
     callCommandWithAllArgs: (cmd, ...args) => [[cmd, ...escapedArgs(args), '%*'].join(' ')],
     createFile: (file, text) => [
       ['@echo', 'off'],
-      ...text.map((line, i) =>
-        ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]
-      )
+      ...text.map((line, i) => ['echo', `"${shellEscape(line)}"`, i === 0 ? '>' : '>>', file])
     ],
     copy: (sourceFile, destinationFile) => ['copy', sourceFile, destinationFile],
-    copyRecursive: (sourceDirectory, destinationDirectory, inclusive) =>
-      ['xcopy', '/y', '/h', '/s', inclusive ? `${toWin(sourceDirectory)}\\*.*` : toWin(sourceDirectory), toWin(destinationDirectory)],
-    rmRecursive: (destinationDirectory) => ['rmdir', '/Q', '/S', destinationDirectory],
-    mkdir: (destinationDirectory) => ['md', destinationDirectory],
+    copyRecursive: (sourceDirectory, destinationDirectory, inclusive) => [
+      'xcopy',
+      '/y',
+      '/h',
+      '/s',
+      inclusive ? `${toWin(sourceDirectory)}\\*.*` : toWin(sourceDirectory),
+      toWin(destinationDirectory)
+    ],
+    rmRecursive: destinationDirectory => ['rmdir', '/Q', '/S', destinationDirectory],
+    mkdir: destinationDirectory => ['md', destinationDirectory],
     export: (key, value) => ['set', `${key}=${value}`],
-    chdir: (destinationDirectory) => ['cd', destinationDirectory],
-    comment: (message) => ['\nREM', util.stripVTControlCharacters(message), '\n'],
-    echo: (message) => ['echo', `"${escape(util.stripVTControlCharacters(message))}"\n`],
-    zip: (outputFile) => ['powershell', 'Compress-Archive', '-Path', '.', '-DestinationPath', outputFile],
+    chdir: destinationDirectory => ['cd', destinationDirectory],
+    comment: message => ['\nREM', util.stripVTControlCharacters(message), '\n'],
+    echo: message => ['echo', `"${shellEscape(util.stripVTControlCharacters(message))}"\n`],
+    zip: outputFile => ['powershell', 'Compress-Archive', '-Path', '.', '-DestinationPath', outputFile],
     script: (lines: string[], changeDirectory: boolean = false) => ({
       ext: '.cmd',
-      contents: [
-        ...(changeDirectory ? ['cd %~p0'] : []),
-        ...lines,
-      ]
+      contents: [...(changeDirectory ? ['cd %~p0'] : []), ...lines]
     })
   },
   posix: {
     var: (name: string) => `$${name}`,
     callCommandWithAllArgs: (cmd, ...args) => [[cmd, ...escapedArgs(args), '$@'].join(' ')],
     createFile: (file, text, mode) => [
-      ...text.map((line, i) =>
-        ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]),
+      ...text.map((line, i) => ['echo', `"${shellEscape(line)}"`, i === 0 ? '>' : '>>', file]),
       ...(mode ? [['chmod', mode, file]] : [])
     ],
     copy: (sourceFile, destinationFile) => ['cp', sourceFile, destinationFile],
-    copyRecursive: (sourceDirectory, destinationDirectory, inclusive) =>
-      ['cp', '-r', '-p', inclusive ? `${sourceDirectory}/*` : sourceDirectory, destinationDirectory],
-    rmRecursive: (destinationDirectory) => ['rm', '-rf', destinationDirectory],
-    mkdir: (destinationDirectory) => ['mkdir', '-p', destinationDirectory],
+    copyRecursive: (sourceDirectory, destinationDirectory, inclusive) => [
+      'cp',
+      '-r',
+      '-p',
+      inclusive ? `${sourceDirectory}/*` : sourceDirectory,
+      destinationDirectory
+    ],
+    rmRecursive: destinationDirectory => ['rm', '-rf', destinationDirectory],
+    mkdir: destinationDirectory => ['mkdir', '-p', destinationDirectory],
     export: (key, value) => ['export', `${key}=${value}`],
-    chdir: (destinationDirectory) => ['cd', destinationDirectory],
-    comment: (message) => ['\n#', util.stripVTControlCharacters(message), '\n'],
-    echo: (message) => ['echo', `"${escape(util.stripVTControlCharacters(message))}"\n`],
-    zip: (outputFile) => ['zip', '-r', outputFile, '.'],
+    chdir: destinationDirectory => ['cd', destinationDirectory],
+    comment: message => ['\n#', util.stripVTControlCharacters(message), '\n'],
+    echo: message => ['echo', `"${shellEscape(util.stripVTControlCharacters(message))}"\n`],
+    zip: outputFile => ['zip', '-r', outputFile, '.'],
     script: (lines: string[], changeDirectory: boolean = false) => ({
       ext: '.sh',
-      contents: [
-        '#!/bin/sh',
-        ...(changeDirectory ? ['cd $(dirname "$0")'] : []),
-        ...lines,
-      ]
+      contents: ['#!/bin/sh', ...(changeDirectory ? ['cd $(dirname "$0")'] : []), ...lines]
     })
-  },
+  }
 };
 
-export const ActiveShellCommand = ShellCommands[process.platform === 'win32' ? 'win32' : 'posix'];
+export const ActiveShellCommand = ShellCommands[process.platform === 'win32' ? 'win32' : 'posix'];

package/support/bin/util.ts

@@ -1,8 +1,8 @@
+import { type SpawnOptions, spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
-import { spawn, type SpawnOptions } from 'node:child_process';
 import path from 'node:path';
 
-import { RuntimeError, ExecUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { ExecUtil, Runtime, RuntimeError, RuntimeIndex } from '@travetto/runtime';
 
 import { ActiveShellCommand } from './shell.ts';
 
@@ -12,7 +12,7 @@ export class PackUtil {
    */
   static buildEnvFile(env: Record<string, string | number | boolean | undefined>): string[] {
     return Object.entries(env)
-      .filter(([, value]) => (value !== undefined))
+      .filter(([, value]) => value !== undefined)
       .map(([key, value]) => `${key}=${value}`);
   }
 
@@ -21,7 +21,12 @@ export class PackUtil {
    * @param sourceDirectory The folder to copy
    * @param destinationDirectory The folder to copy to
    */
-  static async copyRecursive(sourceDirectory: string, destinationDirectory: string, inclusive: boolean = false, ignoreFailure = false): Promise<void> {
+  static async copyRecursive(
+    sourceDirectory: string,
+    destinationDirectory: string,
+    inclusive: boolean = false,
+    ignoreFailure = false
+  ): Promise<void> {
     try {
       let final = destinationDirectory;
       if (!inclusive) {
@@ -43,11 +48,11 @@ export class PackUtil {
     const repoRoot = Runtime.workspaceRelative('.');
     const vars = { ROOT: path.resolve(), TRV_OUT: RuntimeIndex.outputRoot, REPO_ROOT: repoRoot, DIST: workspace, MODULE: module };
 
-    const replaceArgs = (text: string): string => Object.entries(vars)
-      .reduce((result, [key, value]) => result.replaceAll(value, ActiveShellCommand.var(key)), text);
+    const replaceArgs = (text: string): string =>
+      Object.entries(vars).reduce((result, [key, value]) => result.replaceAll(value, ActiveShellCommand.var(key)), text);
 
     const preamble = ActiveShellCommand.script(
-      Object.entries(vars).map(([key, value]) => ActiveShellCommand.export(key, value).join(' ')),
+      Object.entries(vars).map(([key, value]) => ActiveShellCommand.export(key, value).join(' '))
     ).contents;
 
     let stream: fs.FileHandle | undefined;
@@ -58,7 +63,7 @@ export class PackUtil {
       stream = await fs.open(file, 'w', 0o755);
     }
 
-    const write = (text: string): Promise<unknown> | unknown => stream ? stream.write(`${text}\n`) : process.stdout.write(`${text}\n`);
+    const write = (text: string): Promise<unknown> | unknown => (stream ? stream.write(`${text}\n`) : process.stdout.write(`${text}\n`));
 
     for (const line of preamble) {
       write(line);
@@ -75,10 +80,13 @@ export class PackUtil {
    * Track result response
    */
   static async runCommand(cmd: string[], options: SpawnOptions = {}): Promise<string> {
-    const { valid, code, stderr, message, stdout } = await ExecUtil.getResult(spawn(cmd[0], cmd.slice(1), {
-      stdio: [0, 'pipe', 'pipe'],
-      ...options,
-    }), { catch: true });
+    const { valid, code, stderr, message, stdout } = await ExecUtil.getResult(
+      spawn(cmd[0], cmd.slice(1), {
+        stdio: [0, 'pipe', 'pipe'],
+        ...options
+      }),
+      { catch: true }
+    );
 
     if (!valid) {
       process.exitCode = code;
@@ -93,4 +101,4 @@ export class PackUtil {
   static async writeRawFile(file: string, contents: string[], mode?: string): Promise<void> {
     await fs.writeFile(file, contents.join('\n'), { encoding: 'utf8', mode });
   }
-}
+}

package/support/cli.pack.ts

@@ -9,4 +9,4 @@ import { BasePackCommand } from './pack.base.ts';
  * common entry point for module packaging workflows.
  */
 @CliCommand()
-export class PackCommand extends BasePackCommand { }
+export class PackCommand extends BasePackCommand {}

package/support/cli.pack_docker.ts

@@ -1,16 +1,16 @@
 import path from 'node:path';
 
-import { RuntimeIndex } from '@travetto/runtime';
 import { CliCommand, CliFlag, CliUtil } from '@travetto/cli';
+import { RuntimeIndex } from '@travetto/runtime';
 import { Ignore, Max, Min, Required } from '@travetto/schema';
 
+import type { DockerPackConfig } from '../src/types.ts';
 import { DockerPackOperation } from './bin/docker-operation.ts';
 import { BasePackCommand, type PackOperationShape } from './pack.base.ts';
-import type { DockerPackConfig } from '../src/types.ts';
 
 const NODE_MAJOR = process.version.match(/\d+/)?.[0] ?? '22';
-const asNumber = (input?: string): number | undefined => (!input || isNaN(+input)) ? undefined : +input;
-const asString = (input?: string): string | undefined => (input && asNumber(input)) ? input : undefined;
+const asNumber = (input?: string): number | undefined => (!input || Number.isNaN(+input) ? undefined : +input);
+const asString = (input?: string): string | undefined => (input && asNumber(input) ? input : undefined);
 
 /**
  * Build container-ready artifacts and optionally publish Docker images.
@@ -38,7 +38,8 @@ export class PackDockerCommand extends BasePackCommand {
   dockerRuntimePackages: string[] = [];
   /**  Docker Image Port */
   @CliFlag({ short: 'dp', envVars: ['PACK_DOCKER_PORT'] })
-  @Min(1) @Max(65536)
+  @Min(1)
+  @Max(65536)
   dockerPort: number[] = [];
 
   // Publish flags
@@ -113,10 +114,7 @@ export class PackDockerCommand extends BasePackCommand {
       DockerPackOperation.pullDockerBaseImage,
       DockerPackOperation.detectDockerImageOs,
       DockerPackOperation.writeDockerFile,
-      ...this.dockerStageOnly ? [] : [
-        DockerPackOperation.buildDockerContainer,
-        DockerPackOperation.pushDockerContainer
-      ]
+      ...(this.dockerStageOnly ? [] : [DockerPackOperation.buildDockerContainer, DockerPackOperation.pushDockerContainer])
     ];
   }
-}
+}

package/support/cli.pack_zip.ts

@@ -11,7 +11,6 @@ import { BasePackCommand, type PackOperationShape } from './pack.base.ts';
  */
 @CliCommand()
 export class PackZipCommand extends BasePackCommand {
-
   finalize(forHelp?: boolean): void {
     if (forHelp) {
       this.output = '<module>.zip';
@@ -20,9 +19,6 @@ export class PackZipCommand extends BasePackCommand {
   }
 
   getOperations(): PackOperationShape<this>[] {
-    return [
-      ...super.getOperations(),
-      PackOperation.compress
-    ];
+    return [...super.getOperations(), PackOperation.compress];
   }
-}
+}

package/support/pack.base.ts

@@ -2,31 +2,29 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { type CliCommandShape, CliFlag, CliModuleFlag, CliParseUtil, cliTpl } from '@travetto/cli';
-import { TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
-import { Terminal } from '@travetto/terminal';
+import { type IndexedModule, PackageUtil } from '@travetto/manifest';
+import { Runtime, RuntimeIndex, TimeUtil } from '@travetto/runtime';
 import { Ignore, Method, Required, Schema } from '@travetto/schema';
-import { PackageUtil, type IndexedModule } from '@travetto/manifest';
+import { Terminal } from '@travetto/terminal';
 
 import { PackOperation } from './bin/operation.ts';
 import { PackUtil } from './bin/util.ts';
 
-export type PackOperationShape<T> = ((config: T) => AsyncIterable<string[]>);
+export type PackOperationShape<T> = (config: T) => AsyncIterable<string[]>;
 
 @Schema()
 export abstract class BasePackCommand implements CliCommandShape {
-
   static get entryPoints(): string[] {
     return RuntimeIndex.find({
       module: module => module.production,
       folder: folder => folder === 'support',
       file: file => file.sourceFile.includes('entry.')
-    })
-      .map(file => file.import.replace(/[.][^.]+s$/, ''));
+    }).map(file => file.import.replace(/[.][^.]+s$/, ''));
   }
 
   /** Workspace for building */
   @CliFlag({ short: 'b', full: 'buildDir' })
-  buildDirectory: string = path.resolve(os.tmpdir(), Runtime.mainSourcePath.replace(/[\/\\: ]/g, '_'));
+  buildDirectory: string = path.resolve(os.tmpdir(), Runtime.mainSourcePath.replace(/[/\\: ]/g, '_'));
 
   /** Clean workspace */
   clean = true;
@@ -105,14 +103,14 @@ export abstract class BasePackCommand implements CliCommandShape {
       PackOperation.copyMonoRepoResources,
       PackOperation.copyResources,
       PackOperation.writeManifest,
-      PackOperation.bundle,
+      PackOperation.bundle
     ];
   }
 
   /**
    * Run all operations
    */
-  async * runOperations(): AsyncIterable<string> {
+  async *runOperations(): AsyncIterable<string> {
     for (const operation of this.getOperations()) {
       for await (const message of operation(this)) {
         yield message.join(' ');
@@ -128,8 +126,7 @@ export abstract class BasePackCommand implements CliCommandShape {
       .map(name => RuntimeIndex.getModule(name))
       .filter((module): module is IndexedModule => !!module?.production)
       .map(module => PackageUtil.readPackage(module?.sourcePath))
-      .map(pkg => pkg?.travetto?.build?.externalDependencies ?? [])
-      .flat();
+      .flatMap(pkg => pkg?.travetto?.build?.externalDependencies ?? []);
   }
 
   @Method()
@@ -141,7 +138,7 @@ export abstract class BasePackCommand implements CliCommandShape {
 
     // Update entry points
     const parsed = CliParseUtil.getState(this);
-    this.entryArguments = [...this.entryArguments ?? [], ...args, ...parsed?.unknown ?? []];
+    this.entryArguments = [...(this.entryArguments ?? []), ...args, ...(parsed?.unknown ?? [])];
     this.module ||= Runtime.main.name;
     this.mainName ??= path.basename(this.module);
     this.mainFile = `${this.mainName}.js`;
@@ -168,4 +165,4 @@ export abstract class BasePackCommand implements CliCommandShape {
       await term.writer.writeLine(message).commit();
     }
   }
-}
+}

package/support/pack.dockerfile.ts

@@ -1,4 +1,4 @@
-import type { DockerPackFactory } from '../src/types.ts';
 import { PackConfigUtil } from '../src/config-util.ts';
+import type { DockerPackFactory } from '../src/types.ts';
 
-export const factory: DockerPackFactory = config => PackConfigUtil.dockerStandardFile(config);
+export const factory: DockerPackFactory = config => PackConfigUtil.dockerStandardFile(config);

package/support/rollup/build.ts

@@ -1,13 +1,13 @@
 import commonjsRequire from '@rollup/plugin-commonjs';
+import jsonImport from '@rollup/plugin-json';
 import nodeResolve from '@rollup/plugin-node-resolve';
 import terser from '@rollup/plugin-terser';
-import jsonImport from '@rollup/plugin-json';
 import type { RollupOptions } from 'rollup';
 
 import { getCoreConfig } from './config.ts';
+import { travettoEntryPlugin } from './rollup-travetto-entry.ts';
 import { travettoImportPlugin } from './rollup-travetto-import.ts';
 import { travettoSourcemaps } from './rollup-travetto-sourcemaps.ts';
-import { travettoEntryPlugin } from './rollup-travetto-entry.ts';
 
 export default function buildConfig(): RollupOptions {
   // Load up if not defined
@@ -27,4 +27,4 @@ export default function buildConfig(): RollupOptions {
       ...(config.output.compact ? [terser(config.minify)] : [])
     ]
   };
-}
+}

package/support/rollup/config.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 
-import type { OutputOptions } from 'rollup';
 import type terser from '@rollup/plugin-terser';
+import type { OutputOptions } from 'rollup';
 
 import { type ManifestModule, ManifestModuleUtil } from '@travetto/manifest';
 import { EnvProp, Runtime, RuntimeIndex } from '@travetto/runtime';
@@ -10,11 +10,10 @@ import type { CoreRollupConfig } from '../../src/types.ts';
 
 function getFilesFromModule(module: ManifestModule): string[] {
   return [
-    ...module.files.$index ?? [],
-    ...module.files.src ?? [],
+    ...(module.files.$index ?? []),
+    ...(module.files.src ?? []),
     ...(module.files.bin ?? []).filter(file => !(/bin\/trv[.]js$/.test(file[0]) && module.name === '@travetto/cli')),
-    ...(module.files.support ?? [])
-      .filter(file => !/support\/(test|doc|pack)/.test(file[0]))
+    ...(module.files.support ?? []).filter(file => !/support\/(test|doc|pack)/.test(file[0]))
   ]
     .filter(([, type]) => type === 'ts' || type === 'js' || type === 'json')
     .filter(([, , , role]) => (role ?? 'std') === 'std') // Only include standard files
@@ -26,8 +25,7 @@ export function getOutput(): OutputOptions {
   const mainFile = process.env.BUNDLE_MAIN_FILE!;
   return {
     format: 'module',
-    sourcemapPathTransform: (source, map): string =>
-      Runtime.stripWorkspacePath(path.resolve(path.dirname(map), source)),
+    sourcemapPathTransform: (source, map): string => Runtime.stripWorkspacePath(path.resolve(path.dirname(map), source)),
     sourcemap: new EnvProp('BUNDLE_SOURCEMAP').bool ?? false,
     sourcemapExcludeSources: !(new EnvProp('BUNDLE_SOURCES').bool ?? false),
     compact: new EnvProp('BUNDLE_COMPRESS').bool ?? true,
@@ -49,9 +47,7 @@ export function getFiles(entry?: string): string[] {
 }
 
 export function getIgnoredModules(): ManifestModule[] {
-  return [...RuntimeIndex.getModuleList('all')]
-    .map(name => RuntimeIndex.getManifestModule(name))
-    .filter(module => !module.production);
+  return [...RuntimeIndex.getModuleList('all')].map(name => RuntimeIndex.getManifestModule(name)).filter(module => !module.production);
 }
 
 export function getMinifyConfig(): Parameters<typeof terser>[0] {
@@ -63,7 +59,7 @@ export function getMinifyConfig(): Parameters<typeof terser>[0] {
     compress: {},
     output: {
       shebang: false,
-      comments: false,
+      comments: false
     }
   };
 }
@@ -79,7 +75,12 @@ export function getCoreConfig(): CoreRollupConfig {
   const external = new EnvProp('BUNDLE_EXTERNAL').list ?? [];
 
   return {
-    output, entry, files, envFile, minify, external,
-    ignore: new Set([...ignoreModules.map(module => module.name), ...ignoreFiles]),
+    output,
+    entry,
+    files,
+    envFile,
+    minify,
+    external,
+    ignore: new Set([...ignoreModules.map(module => module.name), ...ignoreFiles])
   };
-}
+}

package/support/rollup/rollup-travetto-entry.ts

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+
 import type { Plugin } from 'rollup';
 
 import { RuntimeIndex } from '@travetto/runtime';
@@ -10,7 +11,7 @@ export const GLOBAL_IMPORT = '__trv_imp';
 export function travettoEntryPlugin(config: CoreRollupConfig): Plugin {
   const imports = config.files
     .map(file => file.split('node_modules/').pop()!)
-    .flatMap(file => file.endsWith('/__index__.js') ? [file.replace('/__index__.js', ''), file] : [file]);
+    .flatMap(file => (file.endsWith('/__index__.js') ? [file.replace('/__index__.js', ''), file] : [file]));
 
   const importer = `
 function trvImp(path) {
@@ -39,4 +40,4 @@ globalThis.${GLOBAL_IMPORT} = trvImp;
   };
 
   return out;
-}
+}

package/support/rollup/rollup-travetto-import.ts

@@ -1,12 +1,12 @@
-import type { AstNode, Plugin } from 'rollup';
 // @ts-expect-error - This module lacks types
 import { walk } from 'estree-walker';
 import magicString from 'magic-string';
+import type { AstNode, Plugin } from 'rollup';
 
-import { GLOBAL_IMPORT } from './rollup-travetto-entry.ts';
 import type { CoreRollupConfig } from '../../src/types.ts';
+import { GLOBAL_IMPORT } from './rollup-travetto-entry.ts';
 
-type TNode = AstNode & { source?: { type: string }, callee?: TNode & { name?: string }, args?: TNode[] };
+type TNode = AstNode & { source?: { type: string }; callee?: TNode & { name?: string }; args?: TNode[] };
 
 /**
  * Handles importing via non-static strings (e.g. ClassSource)
@@ -59,4 +59,4 @@ export function travettoImportPlugin(config: CoreRollupConfig): Plugin {
   };
 
   return out;
-}
+}

package/support/rollup/rollup-travetto-sourcemaps.ts

@@ -1,14 +1,14 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 
 import type { LoadResult, Plugin, PluginContext, SourceMapInput } from 'rollup';
 
-import { JSONUtil, FileLoader } from '@travetto/runtime';
+import { FileLoader, JSONUtil } from '@travetto/runtime';
 
 import type { CoreRollupConfig } from '../../src/types.ts';
 
-function toString(error: unknown): string {
-  return error instanceof Error ? error.stack ?? error.toString() : JSONUtil.toUTF8(error);
+function errorString(error: unknown): string {
+  return error instanceof Error ? (error.stack ?? error.toString()) : JSONUtil.toUTF8(error);
 }
 // Pulled from https://github.com/Azure/azure-sdk-for-js/blob/main/common/tools/dev-tool/src/config/rollup.base.config.ts#L128
 export function travettoSourcemaps(config: CoreRollupConfig): Plugin {
@@ -30,18 +30,16 @@ export function travettoSourcemaps(config: CoreRollupConfig): Plugin {
             return null;
           }
           const loader = new FileLoader([path.dirname(id)]);
-          const map = await loader.readUTF8(mapPath)
-            .then(value => value.startsWith('{') ?
-              JSONUtil.fromUTF8<SourceMapInput>(value) :
-              JSONUtil.fromBase64<SourceMapInput>(value)
-            );
+          const map = await loader
+            .readUTF8(mapPath)
+            .then(value => (value.startsWith('{') ? JSONUtil.fromUTF8<SourceMapInput>(value) : JSONUtil.fromBase64<SourceMapInput>(value)));
           return { code, map };
         }
         return { code, map: null };
       } catch (error) {
-        this.warn({ message: toString(error), id });
+        this.warn({ message: errorString(error), id });
         return null;
       }
-    },
+    }
   };
 }