@travetto/pack 8.0.0-alpha.8 → 8.0.0

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

@@ -1,9 +1,12 @@
 import { CliCommand } from '@travetto/cli';
 
-import { BasePackCommand } from './pack.base';
+import { BasePackCommand } from './pack.base.ts';
 
 /**
- * Standard pack support
+ * Build a standard module package artifact.
+ *
+ * This base command produces the default packaged output and serves as the
+ * 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,19 +1,22 @@
 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 { DockerPackOperation } from './bin/docker-operation.ts';
-import { BasePackCommand, type PackOperationShape } from './pack.base';
 import type { DockerPackConfig } from '../src/types.ts';
+import { DockerPackOperation } from './bin/docker-operation.ts';
+import { BasePackCommand, type PackOperationShape } from './pack.base.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);
 
 /**
- * Standard docker support for pack
+ * Build container-ready artifacts and optionally publish Docker images.
+ *
+ * Extends the core pack pipeline with Dockerfile generation and image build/
+ * push operations, including runtime user and registry customization.
  */
 @CliCommand()
 export class PackDockerCommand extends BasePackCommand {
@@ -24,7 +27,7 @@ export class PackDockerCommand extends BasePackCommand {
   @CliFlag({ short: 'di', envVars: ['PACK_DOCKER_IMAGE'] })
   dockerImage = `node:${NODE_MAJOR}-alpine`;
   /**  Docker Image Name */
-  @CliFlag({ short: 'dn', envVars: ['PACK_DOCKER_IMAGE'] })
+  @CliFlag({ short: 'dn', envVars: ['PACK_DOCKER_NAME'] })
   @Required(false)
   dockerName: string;
   /**  Docker Runtime user */
@@ -35,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
@@ -110,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

@@ -1,14 +1,16 @@
 import { CliCommand, CliUtil } from '@travetto/cli';
 
 import { PackOperation } from './bin/operation.ts';
-import { BasePackCommand, type PackOperationShape } from './pack.base';
+import { BasePackCommand, type PackOperationShape } from './pack.base.ts';
 
 /**
- * Standard zip support for pack
+ * Build a deployable zip artifact using the standard pack pipeline.
+ *
+ * This command runs base packing operations and then compresses the generated
+ * output into a single archive file.
  */
 @CliCommand()
 export class PackZipCommand extends BasePackCommand {
-
   finalize(forHelp?: boolean): void {
     if (forHelp) {
       this.output = '<module>.zip';
@@ -17,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(' ');
@@ -121,15 +119,14 @@ export abstract class BasePackCommand implements CliCommandShape {
   }
 
   /**
-   * Get all binary dependencies
+   * Get all external dependencies
    */
-  getBinaryDependencies(): string[] {
+  getModuleExternalDependencies(): string[] {
     return [...RuntimeIndex.getModuleList('all')]
       .map(name => RuntimeIndex.getModule(name))
       .filter((module): module is IndexedModule => !!module?.production)
       .map(module => PackageUtil.readPackage(module?.sourcePath))
-      .map(pkg => pkg?.travetto?.build?.binaryDependencies ?? [])
-      .flat();
+      .flatMap(pkg => pkg?.travetto?.build?.externalDependencies ?? []);
   }
 
   @Method()
@@ -141,13 +138,13 @@ 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`;
 
-    // Collect binary dependencies
-    const dependencies = this.getBinaryDependencies();
+    // Collect unmanaged dependencies
+    const dependencies = this.getModuleExternalDependencies();
     this.externalDependencies = [...this.externalDependencies, ...dependencies];
 
     const stream = this.runOperations();
@@ -168,4 +165,4 @@ export abstract class BasePackCommand implements CliCommandShape {
       await term.writer.writeLine(message).commit();
     }
   }
-}
+}