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

package/README.md

@@ -29,7 +29,7 @@ $ trv pack --help
 Usage: pack [options] [args...:string]
 
 Options:
-  -b, --build-dir <string>             Workspace for building (default: "/tmp/<temp-folder>")
+  -b, --buildDir <string>              Workspace for building (default: "/tmp/<temp-folder>")
   --clean, --no-clean                  Clean workspace (default: true)
   -o, --output <string>                Output location
   --main-scripts, --no-main-scripts    Create entry scripts (default: true)
@@ -95,7 +95,7 @@ $ trv pack:zip --help
 Usage: pack:zip [options] [args...:string]
 
 Options:
-  -b, --build-dir <string>             Workspace for building (default: "/tmp/<temp-folder>")
+  -b, --buildDir <string>              Workspace for building (default: "/tmp/<temp-folder>")
   --clean, --no-clean                  Clean workspace (default: true)
   -o, --output <string>                Output location (default: "travetto_pack.zip")
   --main-scripts, --no-main-scripts    Create entry scripts (default: true)
@@ -124,7 +124,7 @@ $ trv pack:docker --help
 Usage: pack:docker [options] [args...:string]
 
 Options:
-  -b, --build-dir <string>               Workspace for building (default: "/tmp/<temp-folder>")
+  -b, --buildDir <string>                Workspace for building (default: "/tmp/<temp-folder>")
   --clean, --no-clean                    Clean workspace (default: true)
   -o, --output <string>                  Output location
   --main-scripts, --no-main-scripts      Create entry scripts (default: true)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/pack",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -29,12 +29,12 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "@travetto/runtime": "^7.0.0-rc.1",
-    "@travetto/terminal": "^7.0.0-rc.1",
+    "@travetto/runtime": "^7.0.0-rc.2",
+    "@travetto/terminal": "^7.0.0-rc.2",
     "rollup": "^4.53.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/config-util.ts

@@ -7,15 +7,15 @@ export class PackConfigUtil {
   /**
    * Docker setup
    */
-  static dockerInit(cfg: DockerPackConfig): string {
-    return `FROM ${cfg.dockerImage}`;
+  static dockerInit(config: DockerPackConfig): string {
+    return `FROM ${config.dockerImage}`;
   }
 
   /**
    * Install docker pages in either apk or apt environments
    */
-  static dockerPackageInstall(cfg: DockerPackConfig): string {
-    const { os, packages } = cfg.dockerRuntime;
+  static dockerPackageInstall(config: DockerPackConfig): string {
+    const { os, packages } = config.dockerRuntime;
     if (packages?.length) {
       switch (os) {
         case 'alpine': return `RUN apk --update add ${packages.join(' ')} && rm -rf /var/cache/apk/*`;
@@ -32,9 +32,9 @@ export class PackConfigUtil {
   /**
    * Install docker pages in either apk or apt environments
    */
-  static dockerNodePackageInstall(cfg: DockerPackConfig): string {
+  static dockerNodePackageInstall(config: DockerPackConfig): string {
     const out: string[] = [];
-    for (const item of cfg.externalDependencies ?? []) {
+    for (const item of config.externalDependencies ?? []) {
       const [name, directive] = item.split(':');
       switch (directive) {
         case 'from-source':
@@ -44,7 +44,7 @@ export class PackConfigUtil {
       }
     }
     if (out.length) {
-      out.unshift(`WORKDIR ${cfg.dockerRuntime.folder}`);
+      out.unshift(`WORKDIR ${config.dockerRuntime.folder}`);
     }
     return out.join('\n');
   }
@@ -52,22 +52,22 @@ export class PackConfigUtil {
   /**
    * Setup docker ports
    */
-  static dockerPorts(cfg: DockerPackConfig): string {
-    return (cfg.dockerPort?.map(x => `EXPOSE ${x}`) ?? []).join('\n');
+  static dockerPorts(config: DockerPackConfig): string {
+    return (config.dockerPort?.map(port => `EXPOSE ${port}`) ?? []).join('\n');
   }
 
   /**
    * Setup docker user
    */
-  static dockerUser(cfg: DockerPackConfig): string {
-    const { os, user, group, uid, gid } = cfg.dockerRuntime;
+  static dockerUser(config: DockerPackConfig): string {
+    const { os, user, group, userId, groupId } = config.dockerRuntime;
     if (user === 'root') {
       return '';
     } else {
       switch (os) {
-        case 'alpine': return `RUN addgroup -g ${gid} ${group} && adduser -D -G ${group} -u ${uid} ${user}`;
+        case 'alpine': return `RUN addgroup -g ${groupId} ${group} && adduser -D -G ${group} -u ${userId} ${user}`;
         case 'debian':
-        case 'centos': return `RUN groupadd --gid ${gid} ${group} && useradd -u ${uid} -g ${group} ${user}`;
+        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');
       }
@@ -77,17 +77,17 @@ export class PackConfigUtil {
   /**
    * Setup Env Vars for NODE_OPTIONS and other standard environment variables
    */
-  static dockerEnvVars(cfg: DockerPackConfig): string {
+  static dockerEnvVars(config: DockerPackConfig): string {
     return [
-      `ENV NODE_OPTIONS="${[...(cfg.sourcemap ? ['--enable-source-maps'] : [])].join(' ')}"`,
+      `ENV NODE_OPTIONS="${[...(config.sourcemap ? ['--enable-source-maps'] : [])].join(' ')}"`,
     ].join('\n');
   }
 
   /**
    * Setup docker runtime folder
    */
-  static dockerAppFolder(cfg: DockerPackConfig): string {
-    const { folder, user, group } = cfg.dockerRuntime;
+  static dockerAppFolder(config: DockerPackConfig): string {
+    const { folder, user, group } = config.dockerRuntime;
     return [
       `RUN mkdir ${folder} && chown ${user}:${group} ${folder}`,
     ].join('\n');
@@ -96,45 +96,45 @@ export class PackConfigUtil {
   /**
    * Docker app files copied with proper permissions
    */
-  static dockerAppFiles(cfg: DockerPackConfig): string {
-    const { user, group, folder } = cfg.dockerRuntime;
+  static dockerAppFiles(config: DockerPackConfig): string {
+    const { user, group, folder } = config.dockerRuntime;
     return `COPY --chown="${user}:${group}" . ${folder}`;
   }
 
   /**
    * Entrypoint creation for a docker configuration
    */
-  static dockerEntrypoint(cfg: DockerPackConfig): string {
-    const { user, folder } = cfg.dockerRuntime;
+  static dockerEntrypoint(config: DockerPackConfig): string {
+    const { user, folder } = config.dockerRuntime;
     return [
       `USER ${user}`,
       `WORKDIR ${folder}`,
-      `ENTRYPOINT ["${folder}/${cfg.mainName}.sh"]`,
+      `ENTRYPOINT ["${folder}/${config.mainName}.sh"]`,
     ].join('\n');
   }
   /**
    * Common docker environment setup
    */
-  static dockerWorkspace(cfg: DockerPackConfig): string {
+  static dockerWorkspace(config: DockerPackConfig): string {
     return [
-      this.dockerPorts(cfg),
-      this.dockerUser(cfg),
-      this.dockerPackageInstall(cfg),
-      this.dockerAppFolder(cfg),
-      this.dockerAppFiles(cfg),
-      this.dockerEnvVars(cfg),
-    ].filter(x => !!x).join('\n');
+      this.dockerPorts(config),
+      this.dockerUser(config),
+      this.dockerPackageInstall(config),
+      this.dockerAppFolder(config),
+      this.dockerAppFiles(config),
+      this.dockerEnvVars(config),
+    ].filter(line => !!line).join('\n');
   }
 
   /**
    * Common docker file setup
    */
-  static dockerStandardFile(cfg: DockerPackConfig): string {
+  static dockerStandardFile(config: DockerPackConfig): string {
     return [
-      this.dockerInit(cfg),
-      this.dockerWorkspace(cfg),
-      this.dockerNodePackageInstall(cfg),
-      this.dockerEntrypoint(cfg)
+      this.dockerInit(config),
+      this.dockerWorkspace(config),
+      this.dockerNodePackageInstall(config),
+      this.dockerEntrypoint(config)
     ].join('\n');
   }
 }

package/src/types.ts

@@ -2,7 +2,7 @@ import { type OutputOptions } from 'rollup';
 import type terser from '@rollup/plugin-terser';
 
 export type CommonPackConfig = {
-  buildDir: string;
+  buildDirectory: string;
   output: string;
   clean: boolean;
   ejectFile?: string;
@@ -40,29 +40,29 @@ export type DockerPackConfig = {
     packages?: string[];
     folder: string;
     user: string;
-    uid: number;
+    userId: number;
     group: string;
-    gid: number;
+    groupId: number;
   };
 } & CommonPackConfig;
 
-export type ShellCommandImpl = {
+export type ShellCommandProvider = {
   var(name: string): string;
   createFile(file: string, text: string[], mode?: string): string[][];
   callCommandWithAllArgs(cmd: string, ...args: string[]): string[];
-  copy(src: string, dest: string): string[];
-  copyRecursive(src: string, dest: string, inclusive?: boolean): string[];
-  rmRecursive(dest: string): string[];
-  mkdir(dest: string): string[];
+  copy(sourceFile: string, destinationFile: string): string[];
+  copyRecursive(sourceDirectory: string, destinationDirectory: string, inclusive?: boolean): string[];
+  rmRecursive(destinationDirectory: string): string[];
+  mkdir(destinationDirectory: string): string[];
   export(key: string, value: string): string[];
-  chdir(dest: string): string[];
+  chdir(destinationDirectory: string): string[];
   comment(message: string): string[];
   echo(text: string): string[];
   zip(output: string): string[];
   script(lines: string[], chdir?: boolean): { ext: string, contents: string[] };
 };
 
-export type DockerPackFactory = (cfg: DockerPackConfig) => (string | Promise<string>);
+export type DockerPackFactory = (config: DockerPackConfig) => (string | Promise<string>);
 export type DockerPackFactoryModule = { factory: DockerPackFactory };
 
 export type CoreRollupConfig = {

package/support/bin/docker-operation.ts

@@ -11,17 +11,17 @@ import { PackUtil } from './util.ts';
 
 export class DockerPackOperation {
 
-  static getDockerTags(cfg: DockerPackConfig): string[] {
-    return (cfg.dockerTag ?? []).map(x => cfg.dockerRegistry ? `${cfg.dockerRegistry}/${cfg.dockerName}:${x}` : `${cfg.dockerName}:${x}`);
+  static getDockerTags(config: DockerPackConfig): string[] {
+    return (config.dockerTag ?? []).map(tag => config.dockerRegistry ? `${config.dockerRegistry}/${config.dockerName}:${tag}` : `${config.dockerName}:${tag}`);
   }
 
   /**
    * Detect image os
    */
-  static async* detectDockerImageOs(cfg: DockerPackConfig): AsyncIterable<string[]> {
+  static async* detectDockerImageOs(config: DockerPackConfig): AsyncIterable<string[]> {
     // Read os before writing
-    cfg.dockerRuntime.os = await PackUtil.runCommand(
-      ['docker', 'run', '--rm', '--entrypoint', '/bin/sh', cfg.dockerImage, '-c', 'cat /etc/*release*']
+    config.dockerRuntime.os = await PackUtil.runCommand(
+      ['docker', 'run', '--rm', '--entrypoint', '/bin/sh', config.dockerImage, '-c', 'cat /etc/*release*']
     ).then(out => {
       const found = out.match(/\b(?:debian|alpine|centos)\b/i)?.[0].toLowerCase();
       switch (found) {
@@ -29,20 +29,20 @@ export class DockerPackOperation {
         default: return 'unknown';
       }
     });
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Detected Image OS' }} ${{ param: cfg.dockerImage }} as ${{ param: cfg.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(cfg: DockerPackConfig): AsyncIterable<string[]> {
-    const dockerFile = path.resolve(cfg.buildDir, 'Dockerfile');
-    const mod = await Runtime.importFrom<DockerPackFactoryModule>(cfg.dockerFactory);
-    const content = (await mod.factory(cfg)).trim();
+  static async* writeDockerFile(config: DockerPackConfig): AsyncIterable<string[]> {
+    const dockerFile = path.resolve(config.buildDirectory, 'Dockerfile');
+    const mod = await Runtime.importFrom<DockerPackFactoryModule>(config.dockerFactory);
+    const content = (await mod.factory(config)).trim();
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: cfg.dockerFactory }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: config.dockerFactory }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       yield* ActiveShellCommand.createFile(dockerFile, content.split(/\n/));
     } else {
       await fs.writeFile(dockerFile, content, 'utf8');
@@ -52,12 +52,12 @@ export class DockerPackOperation {
   /**
    * Pull Docker Base Image
    */
-  static async* pullDockerBaseImage(cfg: DockerPackConfig): AsyncIterable<string[]> {
-    const command = ['docker', 'pull', cfg.dockerImage];
+  static async* pullDockerBaseImage(config: DockerPackConfig): AsyncIterable<string[]> {
+    const command = ['docker', 'pull', config.dockerImage];
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: cfg.dockerImage }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: config.dockerImage }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       yield command;
     } else {
       await PackUtil.runCommand(command);
@@ -67,22 +67,22 @@ export class DockerPackOperation {
   /**
    * Building Docker Container
    */
-  static async* buildDockerContainer(cfg: DockerPackConfig): AsyncIterable<string[]> {
+  static async* buildDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
     const cmd = [
       'docker', 'build',
-      ...(cfg.dockerBuildPlatform ? ['--platform', cfg.dockerBuildPlatform] : []),
-      ...DockerPackOperation.getDockerTags(cfg).flatMap(x => ['-t', x]), '.'
+      ...(config.dockerBuildPlatform ? ['--platform', config.dockerBuildPlatform] : []),
+      ...DockerPackOperation.getDockerTags(config).flatMap(tag => ['-t', tag]), '.'
     ];
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Building Docker Container' }} ${{ param: cfg.dockerTag?.join(',') }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Building Docker Container' }} ${{ param: config.dockerTag?.join(',') }}`);
 
-    if (cfg.ejectFile) {
-      yield ActiveShellCommand.chdir(cfg.buildDir);
+    if (config.ejectFile) {
+      yield ActiveShellCommand.chdir(config.buildDirectory);
       yield cmd;
       yield ActiveShellCommand.chdir(path.resolve());
     } else {
-      await PackUtil.runCommand(cmd, { cwd: cfg.buildDir, stdio: [0, 'pipe', 2] });
-      const [image]: [{ Size: number }] = JSON.parse(await PackUtil.runCommand(['docker', 'inspect', cfg.dockerImage]));
+      await PackUtil.runCommand(cmd, { cwd: config.buildDirectory, stdio: [0, 'pipe', 2] });
+      const [image]: [{ Size: number }] = JSON.parse(await PackUtil.runCommand(['docker', 'inspect', config.dockerImage]));
       yield [cliTpl`${{ title: 'Built Docker Container  ' }} ${{ identifier: 'sizeMb' }}=${{ param: Math.trunc(image.Size / 2 ** 20) }}`];
     }
   }
@@ -90,16 +90,16 @@ export class DockerPackOperation {
   /**
    * Push Docker Container
    */
-  static async* pushDockerContainer(cfg: DockerPackConfig): AsyncIterable<string[]> {
-    if (!cfg.dockerPush) {
+  static async* pushDockerContainer(config: DockerPackConfig): AsyncIterable<string[]> {
+    if (!config.dockerPush) {
       return;
     }
-    const tags = DockerPackOperation.getDockerTags(cfg);
+    const tags = DockerPackOperation.getDockerTags(config);
     const cmd = ['docker', 'image', 'push'];
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Push Container to registry' }} ${{ param: cfg.dockerRegistry }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Push Container to registry' }} ${{ param: config.dockerRegistry }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       for (const tag of tags) {
         yield [...cmd, tag];
       }

package/support/bin/operation.ts

@@ -13,8 +13,8 @@ import { ActiveShellCommand, ShellCommands } from './shell.ts';
  */
 export class PackOperation {
 
-  static async * title(cfg: CommonPackConfig, title: string): AsyncIterable<string[]> {
-    if (cfg.ejectFile) {
+  static async * title(config: CommonPackConfig, title: string): AsyncIterable<string[]> {
+    if (config.ejectFile) {
       yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.echo(title);
     } else {
@@ -25,72 +25,73 @@ export class PackOperation {
   /**
    * Clean out pack workspace, removing all content
    */
-  static async * clean(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    if (!cfg.clean) {
+  static async * clean(config: CommonPackConfig): AsyncIterable<string[]> {
+    if (!config.clean) {
       return;
     }
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Cleaning Output' }} ${{ path: cfg.buildDir }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Cleaning Output' }} ${{ path: config.buildDirectory }}`);
 
-    if (cfg.ejectFile) {
-      yield ActiveShellCommand.rmRecursive(cfg.buildDir);
-      if (cfg.output) {
-        yield ActiveShellCommand.rmRecursive(cfg.output);
+    if (config.ejectFile) {
+      yield ActiveShellCommand.rmRecursive(config.buildDirectory);
+      if (config.output) {
+        yield ActiveShellCommand.rmRecursive(config.output);
       }
-      yield ActiveShellCommand.mkdir(cfg.buildDir);
+      yield ActiveShellCommand.mkdir(config.buildDirectory);
     } else {
-      await fs.rm(cfg.buildDir, { recursive: true, force: true });
-      if (cfg.output) {
-        await fs.rm(cfg.output, { recursive: true, force: true });
+      await fs.rm(config.buildDirectory, { recursive: true, force: true });
+      if (config.output) {
+        await fs.rm(config.output, { recursive: true, force: true });
       }
-      await fs.mkdir(cfg.buildDir, { recursive: true });
+      await fs.mkdir(config.buildDirectory, { recursive: true });
     }
   }
 
   /**
    * Invoke bundler (rollup) to produce output in workspace folder
    */
-  static async * bundle(cfg: CommonPackConfig): AsyncIterable<string[]> {
+  static async * bundle(config: CommonPackConfig): AsyncIterable<string[]> {
     const cwd = RuntimeIndex.outputRoot;
     const out = RuntimeIndex.manifest.build.outputFolder;
 
-    const bundleCommand = ['npx', 'rollup', '-c', RuntimeIndex.resolveFileImport(cfg.rollupConfiguration)];
+    const bundleCommand = ['npx', 'rollup', '-c', RuntimeIndex.resolveFileImport(config.rollupConfiguration)];
 
-    const entryPointFile = RuntimeIndex.getFromImport(cfg.entryPoint)!.outputFile.split(`${out}/`)[1];
+    const entryPointFile = RuntimeIndex.getFromImport(config.entryPoint)!.outputFile.split(`${out}/`)[1];
 
     const env = {
       ...Object.fromEntries(([
         ['BUNDLE_ENTRY', entryPointFile],
-        ['BUNDLE_MAIN_FILE', cfg.mainFile],
-        ['BUNDLE_COMPRESS', cfg.minify],
-        ['BUNDLE_SOURCEMAP', cfg.sourcemap],
-        ['BUNDLE_SOURCES', cfg.includeSources],
-        ['BUNDLE_OUTPUT', cfg.buildDir],
+        ['BUNDLE_MAIN_FILE', config.mainFile],
+        ['BUNDLE_COMPRESS', config.minify],
+        ['BUNDLE_SOURCEMAP', config.sourcemap],
+        ['BUNDLE_SOURCES', config.includeSources],
+        ['BUNDLE_OUTPUT', config.buildDirectory],
         ['BUNDLE_FORMAT', Runtime.workspace.type],
-        ['BUNDLE_ENV_FILE', cfg.envFile],
-        ['BUNDLE_EXTERNAL', cfg.externalDependencies.map(x => x.split(':')[0]).join(',')]
+        ['BUNDLE_ENV_FILE', config.envFile],
+        ['BUNDLE_EXTERNAL', config.externalDependencies.map(mod => mod.split(':')[0]).join(',')]
       ] as const)
-        .filter(x => x[1] === false || x[1])
-        .map(x => [x[0], `${x[1]}`])
+        .filter(pair => pair[1] === false || pair[1])
+        .map(pair => [pair[0], `${pair[1]}`])
       ),
-      ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(cfg.module)!.outputPath),
+      ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(config.module)!.outputPath),
     };
 
-    const props = (['minify', 'sourcemap', 'entryPoint'] as const)
-      .map(k => cliTpl`${{ subtitle: k }}=${{ param: cfg[k] }}`).join(' ');
+    const properties = (['minify', 'sourcemap', 'entryPoint'] as const)
+      .map(key => cliTpl`${{ subtitle: key }}=${{ param: config[key] }}`).join(' ');
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Bundling Output' }} ${props}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Bundling Output' }} ${properties}`);
 
-    if (cfg.ejectFile) {
-      yield* Object.entries(env).filter(x => !!x[1]).map(x =>
-        ActiveShellCommand.export(x[0], x[1])
-      );
+    if (config.ejectFile) {
+      yield* Object
+        .entries(env)
+        .filter(pair => !!pair[1])
+        .map(pair => ActiveShellCommand.export(pair[0], pair[1]));
       yield ActiveShellCommand.chdir(cwd);
       yield bundleCommand;
       yield ActiveShellCommand.chdir(path.resolve());
     } else {
       await PackUtil.runCommand(bundleCommand, { cwd, env: { ...process.env, ...env }, stdio: [0, 'pipe', 2] });
-      const stat = await fs.stat(path.resolve(cfg.buildDir, cfg.mainFile));
+      const stat = await fs.stat(path.resolve(config.buildDirectory, config.mainFile));
       yield [cliTpl`${{ title: 'Bundled Output ' }} ${{ identifier: 'sizeKb' }}=${{ param: Math.trunc(stat.size / 2 ** 10) }}`];
     }
   }
@@ -98,20 +99,20 @@ export class PackOperation {
   /**
    * Write out package.json, to help define how output .js file should be interpreted
    */
-  static async * writePackageJson(cfg: CommonPackConfig): AsyncIterable<string[]> {
+  static async * writePackageJson(config: CommonPackConfig): AsyncIterable<string[]> {
     const file = 'package.json';
-    const pkg = { type: Runtime.workspace.type, main: cfg.mainFile };
+    const pkg = { type: Runtime.workspace.type, main: config.mainFile };
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       yield* ActiveShellCommand.createFile(
-        path.resolve(cfg.buildDir, file),
+        path.resolve(config.buildDirectory, file),
         [JSON.stringify(pkg)]
       );
     } else {
       await PackUtil.writeRawFile(
-        path.resolve(cfg.buildDir, file),
+        path.resolve(config.buildDirectory, file),
         [JSON.stringify(pkg, null, 2)]
       );
     }
@@ -120,31 +121,31 @@ export class PackOperation {
   /**
    * Define .env.js file to control manifest location
    */
-  static async * writeEnv(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    const file = path.resolve(cfg.buildDir, cfg.envFile);
+  static async * writeEnv(config: CommonPackConfig): AsyncIterable<string[]> {
+    const file = path.resolve(config.buildDirectory, config.envFile);
     const env = {
       ...Env.NODE_ENV.export('production'),
-      ...Env.TRV_MANIFEST.export(cfg.manifestFile),
-      ...Env.TRV_MODULE.export(cfg.module),
+      ...Env.TRV_MANIFEST.export(config.manifestFile),
+      ...Env.TRV_MODULE.export(config.module),
       ...Env.TRV_CLI_IPC.export(undefined),
       ...Env.TRV_RESOURCE_OVERRIDES.export({
         '@#resources': '@@#resources',
-        ...(cfg.includeWorkspaceResources ? {
-          '@@#resources': `@@#${cfg.workspaceResourceFolder}`
+        ...(config.includeWorkspaceResources ? {
+          '@@#resources': `@@#${config.workspaceResourceFolder}`
         } : {})
       })
     };
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       yield* ActiveShellCommand.createFile(
-        path.resolve(cfg.buildDir, file),
+        path.resolve(config.buildDirectory, file),
         PackUtil.buildEnvFile(env)
       );
     } else {
       await PackUtil.writeRawFile(
-        path.resolve(cfg.buildDir, file),
+        path.resolve(config.buildDirectory, file),
         PackUtil.buildEnvFile(env)
       );
     }
@@ -153,26 +154,26 @@ export class PackOperation {
   /**
    * Create launcher scripts (.sh, .cmd) to run output
    */
-  static async * writeEntryScript(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    if (!cfg.mainScripts && !cfg.entryPoint.includes('@travetto/cli')) {
+  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', cfg.mainFile, ...cfg.entryArguments), true
+        sh.callCommandWithAllArgs('node', config.mainFile, ...config.entryArguments), true
       );
-      const file = `${cfg.mainName}${ext}`;
-      const args = cfg.entryArguments.join(' ');
+      const file = `${config.mainName}${ext}`;
+      const args = config.entryArguments.join(' ');
 
-      yield* PackOperation.title(cfg, cliTpl`${{ title }} ${{ path: file }} args=(${{ param: args }})`);
+      yield* PackOperation.title(config, cliTpl`${{ title }} ${{ path: file }} args=(${{ param: args }})`);
 
-      if (cfg.ejectFile) {
-        yield* ActiveShellCommand.createFile(path.resolve(cfg.buildDir, file), contents, '755');
+      if (config.ejectFile) {
+        yield* ActiveShellCommand.createFile(path.resolve(config.buildDirectory, file), contents, '755');
 
       } else {
-        await PackUtil.writeRawFile(path.resolve(cfg.buildDir, file), contents, '755');
+        await PackUtil.writeRawFile(path.resolve(config.buildDirectory, file), contents, '755');
       }
     }
   }
@@ -180,42 +181,42 @@ export class PackOperation {
   /**
    * Copy over repo /resources folder into workspace, will get packaged into final output
    */
-  static async * copyMonoRepoResources(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    if (!cfg.includeWorkspaceResources) {
+  static async * copyMonoRepoResources(config: CommonPackConfig): AsyncIterable<string[]> {
+    if (!config.includeWorkspaceResources) {
       return;
     }
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Copying over workspace resources' }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Copying over workspace resources' }}`);
 
-    const dest = path.resolve(cfg.buildDir, cfg.workspaceResourceFolder);
-    const src = Runtime.workspaceRelative('resources');
+    const destinationDirectory = path.resolve(config.buildDirectory, config.workspaceResourceFolder);
+    const sourceDirectory = Runtime.workspaceRelative('resources');
 
-    if (cfg.ejectFile) {
-      yield ActiveShellCommand.copyRecursive(src, dest, true);
+    if (config.ejectFile) {
+      yield ActiveShellCommand.copyRecursive(sourceDirectory, destinationDirectory, true);
     } else {
-      await PackUtil.copyRecursive(src, dest, true);
+      await PackUtil.copyRecursive(sourceDirectory, destinationDirectory, true);
     }
   }
 
   /**
    * Copy over /resources folder into workspace, will get packaged into final output
    */
-  static async * copyResources(cfg: CommonPackConfig): AsyncIterable<string[]> {
+  static async * copyResources(config: CommonPackConfig): AsyncIterable<string[]> {
     const resources = {
       count: RuntimeIndex.mainModule.files.resources?.length ?? 0,
-      src: path.resolve(Runtime.mainSourcePath, 'resources'),
-      dest: path.resolve(cfg.buildDir, 'resources')
+      sourceDirectory: path.resolve(Runtime.mainSourcePath, 'resources'),
+      destinationDirectory: path.resolve(config.buildDirectory, 'resources')
     };
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Copying over module resources' }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Copying over module resources' }}`);
 
-    if (cfg.ejectFile) {
+    if (config.ejectFile) {
       if (resources.count) {
-        yield ActiveShellCommand.copyRecursive(resources.src, path.resolve(cfg.buildDir, 'resources'), true);
+        yield ActiveShellCommand.copyRecursive(resources.sourceDirectory, path.resolve(config.buildDirectory, 'resources'), true);
       }
     } else {
       if (resources.count) {
-        await PackUtil.copyRecursive(resources.src, resources.dest, true);
+        await PackUtil.copyRecursive(resources.sourceDirectory, resources.destinationDirectory, true);
       }
     }
   }
@@ -223,15 +224,15 @@ export class PackOperation {
   /**
    * Produce the output manifest, only including prod dependencies
    */
-  static async * writeManifest(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    const out = path.resolve(cfg.buildDir, cfg.manifestFile);
+  static async * writeManifest(config: CommonPackConfig): AsyncIterable<string[]> {
+    const out = path.resolve(config.buildDirectory, config.manifestFile);
     const cmd = ['npx', 'trvc', 'manifest', '--prod', out];
-    const env = { ...Env.TRV_MODULE.export(cfg.module) };
+    const env = { ...Env.TRV_MODULE.export(config.module) };
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing Manifest' }} ${{ path: cfg.manifestFile }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Writing Manifest' }} ${{ path: config.manifestFile }}`);
 
-    if (cfg.ejectFile) {
-      yield [...Object.entries(env).map(([k, v]) => `${k}=${v}`), ...cmd];
+    if (config.ejectFile) {
+      yield [...Object.entries(env).map(([key, value]) => `${key}=${value}`), ...cmd];
     } else {
       await PackUtil.runCommand(cmd, { env: { ...process.env, ...env } });
     }
@@ -240,18 +241,18 @@ export class PackOperation {
   /**
    * Generate ZIP file for workspace
    */
-  static async * compress(cfg: CommonPackConfig): AsyncIterable<string[]> {
+  static async * compress(config: CommonPackConfig): AsyncIterable<string[]> {
 
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Compressing' }} ${{ path: cfg.output }}`);
+    yield* PackOperation.title(config, cliTpl`${{ title: 'Compressing' }} ${{ path: config.output }}`);
 
-    if (cfg.ejectFile) {
-      await ActiveShellCommand.mkdir(path.dirname(cfg.output));
-      yield ActiveShellCommand.chdir(cfg.buildDir);
-      yield ActiveShellCommand.zip(cfg.output);
+    if (config.ejectFile) {
+      await ActiveShellCommand.mkdir(path.dirname(config.output));
+      yield ActiveShellCommand.chdir(config.buildDirectory);
+      yield ActiveShellCommand.zip(config.output);
       yield ActiveShellCommand.chdir(path.resolve());
     } else {
-      await fs.mkdir(path.dirname(cfg.output), { recursive: true });
-      await PackUtil.runCommand(ActiveShellCommand.zip(cfg.output), { cwd: cfg.buildDir });
+      await fs.mkdir(path.dirname(config.output), { recursive: true });
+      await PackUtil.runCommand(ActiveShellCommand.zip(config.output), { cwd: config.buildDirectory });
     }
   }
 }

package/support/bin/preamble.ts

@@ -4,15 +4,15 @@ import { readFileSync as readSyncPreamble } from 'node:fs';
 const objectProto = Object.prototype.__proto__;
 Object.defineProperty(Object.prototype, '__proto__', {
   get() { return objectProto; },
-  set(val) { Object.setPrototypeOf(this, val); }
+  set(value) { Object.setPrototypeOf(this, value); }
 });
 
 if (!process.env.TRV_MODULE && '%%ENV_FILE%%') {
   try {
     readSyncPreamble('%%ENV_FILE%%', 'utf8')
       .split('\n')
-      .map(x => x.match(/\s*(?<key>[^ =]+)\s*=\s*(?<value>\S+)/)?.groups)
-      .filter(x => !!x)
-      .forEach(x => process.env[x.key] = x.value);
+      .map(line => line.match(/\s*(?<key>[^ =]+)\s*=\s*(?<value>\S+)/)?.groups)
+      .filter(pair => !!pair)
+      .forEach(pair => process.env[pair.key] = pair.value);
   } catch { }
 }

package/support/bin/shell.ts

@@ -1,20 +1,20 @@
 import util from 'node:util';
 import path from 'node:path';
 
-import { ShellCommandImpl } from '../../src/types.ts';
+import { ShellCommandProvider } from '../../src/types.ts';
 
 const escape = (text: string): string =>
   text
     .replaceAll('"', '\\"')
     .replaceAll('$', '\\$');
 
-const escapedArgs = (args: string[]): string[] => args.map(x =>
-  x.includes(' ') || x.includes('"') ? `'${x}'` : (x.includes("'") ? `"${x}"` : x)
+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);
 
-export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
+export const ShellCommands: Record<'win32' | 'posix', ShellCommandProvider> = {
   win32: {
     var: (name: string) => `%${name}%`,
     callCommandWithAllArgs: (cmd, ...args) => [[cmd, ...escapedArgs(args), '%*'].join(' ')],
@@ -24,20 +24,20 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
         ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]
       )
     ],
-    copy: (src, dest) => ['copy', src, dest],
-    copyRecursive: (src, dest, inclusive) =>
-      ['xcopy', '/y', '/h', '/s', inclusive ? `${toWin(src)}\\*.*` : toWin(src), toWin(dest)],
-    rmRecursive: (dest) => ['rmdir', '/Q', '/S', dest],
-    mkdir: (dest) => ['md', dest],
+    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],
     export: (key, value) => ['set', `${key}=${value}`],
-    chdir: (dest) => ['cd', dest],
+    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],
-    script: (lines: string[], changeDir: boolean = false) => ({
+    script: (lines: string[], changeDirectory: boolean = false) => ({
       ext: '.cmd',
       contents: [
-        ...(changeDir ? ['cd %~p0'] : []),
+        ...(changeDirectory ? ['cd %~p0'] : []),
         ...lines,
       ]
     })
@@ -50,21 +50,21 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
         ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]),
       ...(mode ? [['chmod', mode, file]] : [])
     ],
-    copy: (src, dest) => ['cp', src, dest],
-    copyRecursive: (src, dest, inclusive) =>
-      ['cp', '-r', '-p', inclusive ? `${src}/*` : src, dest],
-    rmRecursive: (dest) => ['rm', '-rf', dest],
-    mkdir: (dest) => ['mkdir', '-p', dest],
+    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],
     export: (key, value) => ['export', `${key}=${value}`],
-    chdir: (dest) => ['cd', dest],
+    chdir: (destinationDirectory) => ['cd', destinationDirectory],
     comment: (message) => ['\n#', util.stripVTControlCharacters(message), '\n'],
     echo: (message) => ['echo', `"${escape(util.stripVTControlCharacters(message))}"\n`],
     zip: (outputFile) => ['zip', '-r', outputFile, '.'],
-    script: (lines: string[], changeDir: boolean = false) => ({
+    script: (lines: string[], changeDirectory: boolean = false) => ({
       ext: '.sh',
       contents: [
         '#!/bin/sh',
-        ...(changeDir ? ['cd $(dirname "$0")'] : []),
+        ...(changeDirectory ? ['cd $(dirname "$0")'] : []),
         ...lines,
       ]
     })

package/support/bin/util.ts

@@ -12,26 +12,26 @@ export class PackUtil {
    */
   static buildEnvFile(env: Record<string, string | number | boolean | undefined>): string[] {
     return Object.entries(env)
-      .filter(([, v]) => (v !== undefined))
-      .map(([k, v]) => `${k}=${v}`);
+      .filter(([, value]) => (value !== undefined))
+      .map(([key, value]) => `${key}=${value}`);
   }
 
   /**
    * Remove directory, determine if errors should be ignored
-   * @param src The folder to copy
-   * @param dest The folder to copy to
+   * @param sourceDirectory The folder to copy
+   * @param destinationDirectory The folder to copy to
    */
-  static async copyRecursive(src: string, dest: 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 = dest;
+      let final = destinationDirectory;
       if (!inclusive) {
-        final = path.resolve(dest, path.basename(src));
+        final = path.resolve(destinationDirectory, path.basename(sourceDirectory));
       }
       await fs.mkdir(final, { recursive: true });
-      await fs.cp(src, final, { recursive: true });
+      await fs.cp(sourceDirectory, final, { recursive: true });
     } catch {
       if (!ignoreFailure) {
-        throw new Error(`Failed to copy ${src} to ${dest}`);
+        throw new Error(`Failed to copy ${sourceDirectory} to ${destinationDirectory}`);
       }
     }
   }
@@ -43,10 +43,10 @@ export class PackUtil {
     const vars = { DIST: workspace, TRV_OUT: RuntimeIndex.outputRoot, ROOT: path.resolve(), MOD: module };
 
     const replaceArgs = (text: string): string => Object.entries(vars)
-      .reduce((str, [k, v]) => str.replaceAll(v, ActiveShellCommand.var(k)), text);
+      .reduce((result, [key, value]) => result.replaceAll(value, ActiveShellCommand.var(key)), text);
 
     const preamble = ActiveShellCommand.script(
-      Object.entries(vars).map(([k, v]) => ActiveShellCommand.export(k, v).join(' ')),
+      Object.entries(vars).map(([key, value]) => ActiveShellCommand.export(key, value).join(' ')),
     ).contents;
 
     let stream: fs.FileHandle | undefined;
@@ -73,10 +73,10 @@ export class PackUtil {
   /**
    * Track result response
    */
-  static async runCommand(cmd: string[], opts: SpawnOptions = {}): Promise<string> {
+  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'],
-      ...opts,
+      ...options,
     }), { catch: true });
 
     if (!valid) {

package/support/cli.pack_docker.ts

@@ -27,7 +27,7 @@ export class PackDockerCommand extends BasePackCommand {
   dockerName: string;
   /**  Docker Runtime user */
   @CliFlag({ short: 'ru', full: 'runtime-user', envVars: ['PACK_DOCKER_RUNTIME_USER'] })
-  dockerRuntimeUserSrc?: string;
+  dockerRuntimeUser?: string;
   /**  Docker Runtime Packages */
   @CliFlag({ short: 'rp', full: 'runtime-package', envVars: ['PACK_DOCKER_RUNTIME_PACKAGES'] })
   dockerRuntimePackages: string[] = [];
@@ -85,15 +85,15 @@ export class PackDockerCommand extends BasePackCommand {
     this.dockerName ??= CliUtil.getSimpleModuleName('<module>', this.module || undefined);
 
     // Finalize user/group and ids
-    const [userOrUid, groupOrGid = userOrUid] = (this.dockerRuntimeUserSrc ?? '').split(':');
-    const groupIsNum = /^\d+$/.test(groupOrGid);
-    const userIsNum = /^\d+$/.test(userOrUid);
-
-    const uid = userIsNum ? +userOrUid : this.defaultUserId;
-    const gid = groupIsNum ? +groupOrGid : this.defaultUserId;
-    const group = (!groupIsNum ? groupOrGid : undefined) || this.defaultUser;
-    const user = (!userIsNum ? userOrUid : undefined) || this.defaultUser;
-    this.dockerRuntime = { user, uid, group, gid, folder: `/${this.appFolder}`, packages: this.dockerRuntimePackages };
+    const [userOrUserId, groupOrGroupId = userOrUserId] = (this.dockerRuntimeUser ?? '').split(':');
+    const groupIsNumber = /^\d+$/.test(groupOrGroupId);
+    const userIsNumber = /^\d+$/.test(userOrUserId);
+
+    const userId = userIsNumber ? +userOrUserId : this.defaultUserId;
+    const groupId = groupIsNumber ? +groupOrGroupId : this.defaultUserId;
+    const group = (!groupIsNumber ? groupOrGroupId : undefined) || this.defaultUser;
+    const user = (!userIsNumber ? userOrUserId : undefined) || this.defaultUser;
+    this.dockerRuntime = { user, userId, group, groupId, folder: `/${this.appFolder}`, packages: this.dockerRuntimePackages };
 
     if (this.dockerStageOnly) {
       if (this.dockerRegistry) {

package/support/pack.base.ts

@@ -17,19 +17,19 @@ export abstract class BasePackCommand implements CliCommandShape {
 
   static get entryPoints(): string[] {
     return RuntimeIndex.find({
-      module: m => m.prod,
-      folder: f => f === 'support',
-      file: f => f.sourceFile.includes('entry.')
+      module: mod => mod.prod,
+      folder: folder => folder === 'support',
+      file: file => file.sourceFile.includes('entry.')
     })
-      .map(x => x.import.replace(/[.][^.]+s$/, ''));
+      .map(file => file.import.replace(/[.][^.]+s$/, ''));
   }
 
   @Ignore()
   _parsed: ParsedState;
 
   /** Workspace for building */
-  @CliFlag({ short: 'b' })
-  buildDir: string = path.resolve(os.tmpdir(), Runtime.mainSourcePath.replace(/[\/\\: ]/g, '_'));
+  @CliFlag({ short: 'b', full: 'buildDir' })
+  buildDirectory: string = path.resolve(os.tmpdir(), Runtime.mainSourcePath.replace(/[\/\\: ]/g, '_'));
 
   /** Clean workspace */
   clean = true;
@@ -116,8 +116,8 @@ export abstract class BasePackCommand implements CliCommandShape {
    * Run all operations
    */
   async * runOperations(): AsyncIterable<string> {
-    for (const op of this.getOperations()) {
-      for await (const msg of op(this)) {
+    for (const operation of this.getOperations()) {
+      for await (const msg of operation(this)) {
         yield msg.join(' ');
       }
     }
@@ -128,11 +128,11 @@ export abstract class BasePackCommand implements CliCommandShape {
    */
   getBinaryDependencies(): string[] {
     return [...RuntimeIndex.getModuleList('all')]
-      .map(m => RuntimeIndex.getModule(m))
-      .filter(m => !!m)
-      .filter(m => m.prod)
-      .map(m => PackageUtil.readPackage(m?.sourcePath))
-      .map(p => p?.travetto?.build?.binaryDependencies ?? [])
+      .map(name => RuntimeIndex.getModule(name))
+      .filter(mod => !!mod)
+      .filter(mod => mod.prod)
+      .map(mod => PackageUtil.readPackage(mod?.sourcePath))
+      .map(pkg => pkg?.travetto?.build?.binaryDependencies ?? [])
       .flat();
   }
 
@@ -141,7 +141,7 @@ export abstract class BasePackCommand implements CliCommandShape {
     // Resolve all files to absolute paths
     this.output = this.output ? path.resolve(this.output) : undefined!;
     this.ejectFile = this.ejectFile ? path.resolve(this.ejectFile) : undefined;
-    this.buildDir = path.resolve(this.buildDir);
+    this.buildDirectory = path.resolve(this.buildDirectory);
 
     // Update entry points
     this.entryArguments = [...this.entryArguments ?? [], ...args, ...this._parsed.unknown];
@@ -150,14 +150,14 @@ export abstract class BasePackCommand implements CliCommandShape {
     this.mainFile = `${this.mainName}.js`;
 
     // Collect binary dependencies
-    const binaryDeps = await this.getBinaryDependencies();
-    this.externalDependencies = [...this.externalDependencies, ...binaryDeps];
+    const dependencies = await this.getBinaryDependencies();
+    this.externalDependencies = [...this.externalDependencies, ...dependencies];
 
     const stream = this.runOperations();
 
     // Eject to file
     if (this.ejectFile) {
-      await PackUtil.writeEjectOutput(this.buildDir, this.module, stream, this.ejectFile);
+      await PackUtil.writeEjectOutput(this.buildDirectory, this.module, stream, this.ejectFile);
     } else {
       const start = Date.now();
       const term = new Terminal();

package/support/pack.dockerfile.ts

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

package/support/rollup/config.ts

@@ -8,17 +8,17 @@ import { EnvProp, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { CoreRollupConfig } from '../../src/types.ts';
 
-function getFilesFromModule(m: ManifestModule): string[] {
+function getFilesFromModule(mod: ManifestModule): string[] {
   return [
-    ...m.files.$index ?? [],
-    ...m.files.src ?? [],
-    ...(m.files.bin ?? []).filter(f => !(/bin\/trv[.]js$/.test(f[0]) && m.name === '@travetto/cli')),
-    ...(m.files.support ?? [])
-      .filter(f => !/support\/(test|doc|pack)/.test(f[0]))
+    ...mod.files.$index ?? [],
+    ...mod.files.src ?? [],
+    ...(mod.files.bin ?? []).filter(file => !(/bin\/trv[.]js$/.test(file[0]) && mod.name === '@travetto/cli')),
+    ...(mod.files.support ?? [])
+      .filter(file => !/support\/(test|doc|pack)/.test(file[0]))
   ]
-    .filter(([, t]) => t === 'ts' || t === 'js' || t === 'json')
-    .filter(f => (f[3] ?? 'std') === 'std') // Only include standard files
-    .map(([f]) => ManifestModuleUtil.withOutputExtension(path.resolve(m.outputFolder, f)));
+    .filter(([, type]) => type === 'ts' || type === 'js' || type === 'json')
+    .filter(([, , , role]) => (role ?? 'std') === 'std') // Only include standard files
+    .map(([file]) => ManifestModuleUtil.withOutputExtension(path.resolve(mod.outputFolder, file)));
 }
 
 function getFormat(value: string = 'commonjs'): NodeModuleType {
@@ -31,17 +31,17 @@ function getFormat(value: string = 'commonjs'): NodeModuleType {
 
 export function getOutput(): OutputOptions {
   const format = getFormat(process.env.BUNDLE_FORMAT);
-  const dir = process.env.BUNDLE_OUTPUT!;
+  const output = process.env.BUNDLE_OUTPUT!;
   const mainFile = process.env.BUNDLE_MAIN_FILE!;
   return {
     format,
     interop: format === 'commonjs' ? 'auto' : undefined,
-    sourcemapPathTransform: (src, map): string =>
-      Runtime.stripWorkspacePath(path.resolve(path.dirname(map), src)),
+    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,
-    file: path.resolve(dir, mainFile),
+    file: path.resolve(output, mainFile),
     inlineDynamicImports: true
   };
 }
@@ -52,16 +52,16 @@ export function getEntry(): string {
 
 export function getFiles(entry?: string): string[] {
   return [...RuntimeIndex.getModuleList('all')]
-    .map(x => RuntimeIndex.getManifestModule(x))
-    .filter(m => m.prod)
+    .map(name => RuntimeIndex.getManifestModule(name))
+    .filter(mod => mod.prod)
     .flatMap(getFilesFromModule)
-    .filter(x => (!entry || !x.endsWith(entry)) && !x.includes('@travetto/pack/support/'));
+    .filter(file => (!entry || !file.endsWith(entry)) && !file.includes('@travetto/pack/support/'));
 }
 
 export function getIgnoredModules(): ManifestModule[] {
   return [...RuntimeIndex.getModuleList('all')]
-    .map(x => RuntimeIndex.getManifestModule(x))
-    .filter(m => !m.prod);
+    .map(name => RuntimeIndex.getManifestModule(name))
+    .filter(mod => !mod.prod);
 }
 
 export function getMinifyConfig(): Parameters<typeof terser>[0] {
@@ -85,11 +85,11 @@ export function getCoreConfig(): CoreRollupConfig {
   const ignoreModules = getIgnoredModules();
   const ignoreFiles = ignoreModules.flatMap(getFilesFromModule);
   const minify = getMinifyConfig();
-  const envFile = new EnvProp('BUNDLE_ENV_FILE').val;
+  const envFile = new EnvProp('BUNDLE_ENV_FILE').value;
   const external = new EnvProp('BUNDLE_EXTERNAL').list ?? [];
 
   return {
     output, entry, files, envFile, minify, external,
-    ignore: new Set([...ignoreModules.map(x => x.name), ...ignoreFiles]),
+    ignore: new Set([...ignoreModules.map(mod => mod.name), ...ignoreFiles]),
   };
 }

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

@@ -9,15 +9,15 @@ export const GLOBAL_IMPORT = '__trv_imp';
 
 export function travettoEntryPlugin(config: CoreRollupConfig): Plugin {
   const imports = config.files
-    .map(x => x.split('node_modules/').pop()!)
-    .flatMap(x => x.endsWith('/__index__.js') ? [x.replace('/__index__.js', ''), x] : [x]);
+    .map(file => file.split('node_modules/').pop()!)
+    .flatMap(file => file.endsWith('/__index__.js') ? [file.replace('/__index__.js', ''), file] : [file]);
 
-  const op = config.output.format === 'module' ? 'import' : 'require';
+  const operation = config.output.format === 'module' ? 'import' : 'require';
   const importer = `
 function trvImp(path) {
   switch (path) {
-${imports.map(x => `    case '${x}': return ${op}('${x}')`).join('\n')}
-    default: return ${op}(path); // Fall back for built-ins
+${imports.map(file => `    case '${file}': return ${operation}('${file}')`).join('\n')}
+    default: return ${operation}(path); // Fall back for built-ins
   }
 }
 globalThis.${GLOBAL_IMPORT} = trvImp;

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

@@ -33,8 +33,8 @@ export function travettoSourcemaps(config: CoreRollupConfig): Plugin {
           return { code, map };
         }
         return { code, map: null };
-      } catch (e) {
-        this.warn({ message: toString(e), id });
+      } catch (error) {
+        this.warn({ message: toString(error), id });
         return null;
       }
     },