@aws/ml-container-creator 0.10.3 → 0.13.3

package/src/lib/path-prover-brain.js

@@ -2,7 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 /**
  * Path Prover Brain
@@ -364,6 +368,7 @@ export function classifyFailure(errorOutput) {
 function detectStage(errorMsg) {
     const stagePatterns = [
         { pattern: /\b(generate|generation)\b/i, stage: 'generate' },
+        { pattern: /\bdo\/stage\b|model.staging|pre-stage|s3.*stag/i, stage: 'stage' },
         { pattern: /\b(build|docker)\b/i, stage: 'build' },
         { pattern: /\b(push|ecr|registry)\b/i, stage: 'push' },
         { pattern: /\b(deploy|endpoint|CreateEndpoint|InferenceComponent)\b/i, stage: 'deploy' },
@@ -605,3 +610,55 @@ export function loadPriorityTargets(configPath) {
         return null;
     }
 }
+
+// ── TP Degree Auto-Resolution at Prove-Time (Task 6.5) ──────────────────────
+
+/**
+ * Resolve tp_degree from instance catalog when not explicitly set in a prove config.
+ *
+ * At prove-time, if the target config omits tp_degree but specifies an instance_type,
+ * look up the instance catalog's GPU count and use it as the tp_degree.
+ * This mirrors the generation-time logic in template-variable-resolver.js.
+ *
+ * Requirements: FTP-1 (extension) — task 6.5
+ *
+ * @param {object} config - The prove config (from getNextPriorityConfig or similar)
+ * @param {string} [config.instance_type] - Instance type (e.g. 'ml.g5.48xlarge')
+ * @param {number|string|undefined} [config.tp_degree] - TP degree if already set
+ * @param {object|null} [catalogOverride] - Optional catalog data for testing (skips file load)
+ * @returns {object} The config object (mutated in place) with tp_degree resolved
+ */
+export function resolveProveTpDegree(config, catalogOverride = null) {
+    if (!config) return config;
+
+    // If tp_degree is already set (not null/undefined), respect it
+    if (config.tp_degree !== undefined && config.tp_degree !== null) {
+        return config;
+    }
+
+    // Need an instance_type to look up GPU count
+    if (!config.instance_type) {
+        return config;
+    }
+
+    // Load instance catalog
+    let catalog = catalogOverride;
+    if (!catalog) {
+        try {
+            const catalogPath = resolve(__dirname, '..', '..', 'servers', 'lib', 'catalogs', 'instances.json');
+            const raw = readFileSync(catalogPath, 'utf8');
+            catalog = JSON.parse(raw);
+        } catch {
+            return config;
+        }
+    }
+
+    const instanceInfo = catalog?.catalog?.[config.instance_type];
+    if (instanceInfo?.gpus && instanceInfo.gpus > 0) {
+        config.tp_degree = instanceInfo.gpus;
+        config._tpAutoResolved = true;
+        config._tpAutoResolvedFrom = config.instance_type;
+    }
+
+    return config;
+}

package/src/lib/prompts/infrastructure-prompts.js

@@ -252,7 +252,7 @@ const infraInstancePrompts = [
             if (!input || input.trim() === '') {
                 return 'At least one instance type is required';
             }
-            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
+            const instancePattern = /^ml\.[a-z0-9-]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
             const instances = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
             if (instances.length === 0) {
                 return 'At least one instance type is required';
@@ -384,7 +384,7 @@ const infraInstancePrompts = [
             if (!input || input.trim() === '') {
                 return 'Instance type is required';
             }
-            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
+            const instancePattern = /^ml\.[a-z0-9-]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
             if (!instancePattern.test(input.trim())) {
                 return 'Invalid instance type format. Expected format: ml.{family}.{size} (e.g., ml.m5.large, ml.g4dn.xlarge)';
             }

package/src/lib/prompts/model-prompts.js

@@ -459,6 +459,12 @@ const hfTokenPrompts = [
                 return false;
             }
             
+            // Skip HF token when model name is an S3 URI (no HF download needed)
+            const modelName = answers.customModelName || answers.modelName;
+            if (modelName && modelName.startsWith('s3://')) {
+                return false;
+            }
+            
             // Display security warning before prompting
             console.log('\n🔐 HuggingFace Authentication');
             console.log('   Many models (e.g. Llama, Mistral) are gated and require a token.');

package/src/lib/prove-pipeline-executor.js

@@ -0,0 +1,294 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Prove Pipeline Executor
+ *
+ * Executes lifecycle stages for validation targets in the `mcc prove` workflow.
+ * Handles stage-specific logic including idempotency checks, status tracking,
+ * and fail-fast behavior.
+ *
+ * Feature: s3-model-loading
+ * Requirements: 5.1, 5.2, 5.3, 5.4, 5.5
+ */
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+const execFileAsync = promisify(execFile);
+
+// ── Valid Lifecycle Stages ────────────────────────────────────────────────────
+
+/**
+ * All recognized lifecycle stages for the prove pipeline.
+ * The "stage" step pre-stages model weights from HuggingFace to S3.
+ */
+export const VALID_LIFECYCLE_STAGES = [
+    'generate',
+    'stage',
+    'build',
+    'push',
+    'deploy',
+    'test',
+    'tune',
+    'adapter',
+    'test-adapter',
+    'benchmark',
+    'register',
+    'clean'
+];
+
+/**
+ * Possible staging states for status output.
+ */
+export const STAGING_STATES = {
+    STAGED: 'staged',
+    NOT_STAGED: 'not-staged',
+    STAGE_FAILED: 'stage-failed'
+};
+
+// ── Stage Lifecycle Step ─────────────────────────────────────────────────────
+
+/**
+ * Check if a model has already been staged by looking for `.mlcc/staged-assets.json`.
+ *
+ * @param {string} projectDir - Path to the generated project directory
+ * @returns {boolean} True if the model has already been staged
+ */
+export function isAlreadyStaged(projectDir) {
+    const stagedAssetsPath = path.join(projectDir, '.mlcc', 'staged-assets.json');
+    if (!existsSync(stagedAssetsPath)) {
+        return false;
+    }
+
+    try {
+        const content = readFileSync(stagedAssetsPath, 'utf8');
+        const data = JSON.parse(content);
+        // Check that there's a valid staged URI
+        return !!(data?.models?.default?.staged_uri);
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Get the current staging state for a project.
+ *
+ * @param {string} projectDir - Path to the generated project directory
+ * @param {object} [stepResults] - Previous step results (to check for stage-failed)
+ * @returns {string} One of: 'staged', 'not-staged', 'stage-failed'
+ */
+export function getStagingState(projectDir, stepResults = null) {
+    // Check if stage previously failed
+    if (stepResults?.stage?.status === 'fail') {
+        return STAGING_STATES.STAGE_FAILED;
+    }
+
+    if (isAlreadyStaged(projectDir)) {
+        return STAGING_STATES.STAGED;
+    }
+
+    return STAGING_STATES.NOT_STAGED;
+}
+
+/**
+ * Execute the stage lifecycle step with idempotency support.
+ *
+ * If the model is already staged (`.mlcc/staged-assets.json` exists with a valid URI),
+ * the step is skipped and marked as passed.
+ *
+ * If `do/stage` exits non-zero, the model is marked as stage-failed.
+ *
+ * @param {string} projectDir - Path to the generated project directory
+ * @param {object} [options] - Execution options
+ * @param {number} [options.timeout=1800] - Timeout in seconds (default: 30 minutes)
+ * @param {boolean} [options.verbose=false] - Stream stdout/stderr in real time
+ * @returns {Promise<object>} StepResult with name, status, duration, stagingState, and optional error
+ */
+export async function executeStageStep(projectDir, options = {}) {
+    const { timeout = 1800, verbose = false } = options;
+    const startTime = Date.now();
+
+    // Idempotency check: skip if already staged (Requirement 5.4)
+    if (isAlreadyStaged(projectDir)) {
+        return {
+            name: 'stage',
+            status: 'pass',
+            duration: Date.now() - startTime,
+            stagingState: STAGING_STATES.STAGED,
+            skipped: true,
+            message: '✓ Model already staged — skipping'
+        };
+    }
+
+    // Execute do/stage and verify exit code 0 (Requirement 5.2)
+    const command = './do/stage';
+
+    try {
+        if (verbose) {
+            // Verbose: stream output in real time
+            const { spawn } = await import('node:child_process');
+            const result = await new Promise((resolve) => {
+                const child = spawn('bash', ['-c', command], {
+                    cwd: projectDir,
+                    stdio: ['pipe', 'inherit', 'inherit']
+                });
+
+                let killed = false;
+                const timer = setTimeout(() => {
+                    killed = true;
+                    child.kill('SIGTERM');
+                }, timeout * 1000);
+
+                child.on('close', (code) => {
+                    clearTimeout(timer);
+                    if (code === 0) {
+                        resolve({
+                            name: 'stage',
+                            status: 'pass',
+                            duration: Date.now() - startTime,
+                            stagingState: STAGING_STATES.STAGED
+                        });
+                    } else {
+                        const error = killed
+                            ? `Timeout after ${timeout}s`
+                            : `do/stage exited with code ${code}`;
+                        resolve({
+                            name: 'stage',
+                            status: 'fail',
+                            duration: Date.now() - startTime,
+                            stagingState: STAGING_STATES.STAGE_FAILED,
+                            error
+                        });
+                    }
+                });
+
+                child.on('error', (err) => {
+                    clearTimeout(timer);
+                    resolve({
+                        name: 'stage',
+                        status: 'fail',
+                        duration: Date.now() - startTime,
+                        stagingState: STAGING_STATES.STAGE_FAILED,
+                        error: err.message.slice(-500)
+                    });
+                });
+            });
+            return result;
+        }
+
+        // Non-verbose: buffer output
+        await execFileAsync('bash', ['-c', command], {
+            cwd: projectDir,
+            timeout: timeout * 1000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+
+        return {
+            name: 'stage',
+            status: 'pass',
+            duration: Date.now() - startTime,
+            stagingState: STAGING_STATES.STAGED
+        };
+    } catch (err) {
+        // Mark model as failed if staging fails (Requirement 5.3)
+        const error = err.killed
+            ? `Timeout after ${timeout}s`
+            : (err.stderr || err.message).slice(-500);
+
+        return {
+            name: 'stage',
+            status: 'fail',
+            duration: Date.now() - startTime,
+            stagingState: STAGING_STATES.STAGE_FAILED,
+            error
+        };
+    }
+}
+
+// ── Stage Validation ─────────────────────────────────────────────────────────
+
+/**
+ * Validate that a lifecycle stage name is recognized by the prove pipeline.
+ *
+ * @param {string} stageName - The stage name to validate
+ * @returns {boolean} True if the stage is valid
+ */
+export function isValidLifecycleStage(stageName) {
+    return VALID_LIFECYCLE_STAGES.includes(stageName);
+}
+
+/**
+ * Validate a stages array from validation-targets configuration.
+ *
+ * @param {string[]} stages - Array of stage names
+ * @returns {object} Validation result: { valid: boolean, errors: string[] }
+ */
+export function validateStagesArray(stages) {
+    const errors = [];
+
+    if (!Array.isArray(stages)) {
+        return { valid: false, errors: ['stages must be an array'] };
+    }
+
+    if (stages.length === 0) {
+        return { valid: false, errors: ['stages array must not be empty'] };
+    }
+
+    for (const stage of stages) {
+        if (typeof stage !== 'string') {
+            errors.push(`Invalid stage type: expected string, got ${typeof stage}`);
+            continue;
+        }
+        if (!isValidLifecycleStage(stage)) {
+            errors.push(`Unrecognized lifecycle stage: "${stage}"`);
+        }
+    }
+
+    return { valid: errors.length === 0, errors };
+}
+
+// ── Status Output ────────────────────────────────────────────────────────────
+
+/**
+ * Format the staging state for status output display.
+ *
+ * @param {string} state - One of STAGING_STATES values
+ * @returns {string} Formatted status string with emoji
+ */
+export function formatStagingStatus(state) {
+    switch (state) {
+    case STAGING_STATES.STAGED:
+        return '✓ staged';
+    case STAGING_STATES.NOT_STAGED:
+        return '○ not-staged';
+    case STAGING_STATES.STAGE_FAILED:
+        return '✗ stage-failed';
+    default:
+        return '? unknown';
+    }
+}
+
+/**
+ * Build a status summary for a prove target including staging state.
+ *
+ * @param {object} target - The validation target
+ * @param {string} target.model_name - Model name
+ * @param {string} projectDir - Path to the project directory
+ * @param {object} [stepResults] - Results of executed steps
+ * @returns {object} Status summary including stagingState
+ */
+export function buildTargetStatus(target, projectDir, stepResults = null) {
+    const stagingState = getStagingState(projectDir, stepResults);
+    const stages = target.stages || [];
+    const includesStage = stages.includes('stage');
+
+    return {
+        model_name: target.model_name,
+        stagingState,
+        stagingStatus: formatStagingStatus(stagingState),
+        includesStageStep: includesStage
+    };
+}

package/src/lib/secrets-prompt-runner.js

@@ -70,6 +70,10 @@ export default class SecretsPromptRunner {
             const modelSource = answers.modelSource;
             if (modelSource && modelSource !== 'huggingface') return false;
 
+            // Skip HF token when model name is an S3 URI (no HF download needed)
+            const modelName = answers.customModelName || answers.modelName;
+            if (modelName && modelName.startsWith('s3://')) return false;
+
             return true;
         }
 

package/src/lib/template-manager.js

@@ -146,7 +146,7 @@ export default class TemplateManager {
         
         // Validate instance type format (ml.*.*) - only for realtime-inference
         if (this.answers.instanceType && this.answers.instanceType !== 'custom') {
-            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
+            const instancePattern = /^ml\.[a-z0-9-]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
             if (!instancePattern.test(this.answers.instanceType)) {
                 throw new Error(`⚠️  Invalid instance type format: ${this.answers.instanceType}. Expected format: ml.{family}.{size} (e.g., ml.m5.large, ml.g5.xlarge)`);
             }

package/src/lib/template-variable-resolver.js

@@ -383,6 +383,68 @@ export async function _ensureTemplateVariables(answers, registryConfigManager =
         }
     }
 
+    // Auto-resolve tensor parallel degree from instance catalog GPU count.
+    // Only applies when:
+    //   1. The engine supports tensor parallelism (vLLM, SGLang, TensorRT-LLM, LMI)
+    //   2. The instance has multiple GPUs (gpus > 1)
+    //   3. The user has NOT explicitly set the TP env var via --server-env or --model-env
+    // This ensures multi-GPU instances default to full TP utilization without requiring
+    // the user to manually specify TENSOR_PARALLEL_SIZE.
+    // Requirements: FTP-1 (extension) — task 6.2
+    const _TP_ENGINE_MAP = {
+        'vllm': 'VLLM_TENSOR_PARALLEL_SIZE',
+        'vllm-omni': 'VLLM_OMNI_TENSOR_PARALLEL_SIZE',
+        'sglang': 'SGLANG_TENSOR_PARALLEL_SIZE',
+        'tensorrt-llm': 'TRTLLM_TENSOR_PARALLEL_SIZE',
+        'lmi': 'OPTION_TENSOR_PARALLEL_DEGREE'
+    };
+
+    const tpEngine = answers.backend || answers.modelServer;
+    const tpEnvKey = tpEngine ? _TP_ENGINE_MAP[tpEngine] : null;
+
+    if (tpEnvKey && answers.instanceType) {
+        // Check if user explicitly set the TP value via --server-env (un-prefixed key)
+        const userServerEnvVars = answers.serverEnvVars || {};
+        const userExplicitlySetTP = (
+            userServerEnvVars['TENSOR_PARALLEL_SIZE'] !== undefined ||
+            userServerEnvVars['TENSOR_PARALLEL_DEGREE'] !== undefined ||
+            userServerEnvVars[tpEnvKey] !== undefined
+        );
+
+        if (!userExplicitlySetTP) {
+            // Look up GPU count from instance catalog
+            let instanceGpuCount = null;
+            if (answers.gpuCount) {
+                instanceGpuCount = answers.gpuCount;
+            } else if (answers.icGpuCount) {
+                instanceGpuCount = answers.icGpuCount;
+            } else {
+                try {
+                    const catalogPath = path.resolve(__dirname, '..', '..', 'servers', 'lib', 'catalogs', 'instances.json');
+                    const catalogData = JSON.parse(fs.readFileSync(catalogPath, 'utf-8'));
+                    const instanceInfo = catalogData?.catalog?.[answers.instanceType];
+                    if (instanceInfo?.gpus && instanceInfo.gpus > 0) {
+                        instanceGpuCount = instanceInfo.gpus;
+                    }
+                } catch {
+                    // Silently continue
+                }
+            }
+
+            // Auto-set TP to GPU count when instance has multiple GPUs
+            if (instanceGpuCount && instanceGpuCount > 1) {
+                if (!answers.envVars) {
+                    answers.envVars = {};
+                }
+                answers.envVars[tpEnvKey] = String(instanceGpuCount);
+                answers.tensorParallelSize = instanceGpuCount;
+                answers._tpAutoResolved = true;
+                answers._tpAutoResolvedFrom = answers.instanceType;
+                console.log(`    ℹ️  TP degree: ${instanceGpuCount} (auto-detected from ${answers.instanceType})`);
+            }
+        }
+    }
+
     // Determine tune support based on model presence in the tune catalog.
     // Used by the do/config template to write TUNE_SUPPORTED=true|false.
     if (answers.tuneSupported === undefined) {

package/templates/do/README.md

@@ -262,6 +262,43 @@ Clean everything:
 
 ---
 
+### `./do/stage`
+
+Pre-stage model weights from HuggingFace to S3 for faster builds and deploys.
+
+**What it does:**
+- Downloads model weights from HuggingFace using `huggingface-cli`
+- Uses `hf_transfer` for accelerated parallel downloads
+- Syncs downloaded weights to S3 (regional, fast access)
+- Records the staged S3 URI in `.mlcc/staged-assets.json`
+- Idempotent: skips if model is already staged (use `--force` to re-stage)
+
+**Prerequisites:**
+- AWS credentials configured
+- `huggingface-cli` installed (`pip install huggingface_hub[cli] hf_transfer`)
+- Bootstrap profile configured (`ml-container-creator bootstrap`)
+
+**Usage:**
+```bash
+# Stage model to S3
+./do/stage
+
+# Force re-stage even if already present
+./do/stage --force
+
+# Stage and update MODEL_NAME in do/config
+./do/stage --update-config
+
+# Submit as SageMaker Processing Job (for models >500GB)
+./do/stage --submit
+```
+
+**Output:**
+- Staged model S3 URI
+- Updated `.mlcc/staged-assets.json` tracking file
+
+---
+
 <% if (typeof includeBenchmark !== 'undefined' && includeBenchmark) { %>
 ### `./do/benchmark`
 

package/templates/do/adapter

@@ -18,6 +18,14 @@ set -o pipefail
 # ── Source project configuration ──────────────────────────────────────────────
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ADAPTER_S3_BUCKET="${ADAPTER_S3_BUCKET:-mlcc-adapters-${_PROFILE[accountId]:-unknown}-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
+
 source "${SCRIPT_DIR}/lib/wait.sh"
 
 # ── Usage ─────────────────────────────────────────────────────────────────────

package/templates/do/build

@@ -9,6 +9,14 @@ set -o pipefail
 # Source configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ECR_REPOSITORY_NAME="${ECR_REPOSITORY_NAME:-${_PROFILE[ecrRepositoryName]:-ml-container-creator}}"
+export AWS_REGION="${AWS_REGION:-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
 
 echo "🚀 Building Docker image for ${PROJECT_NAME}"
 echo "   Deployment config: ${DEPLOYMENT_CONFIG}"

package/templates/do/clean.d/async-inference.ejs

@@ -9,6 +9,14 @@ set -o pipefail
 # Source configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ECR_REPOSITORY_NAME="${ECR_REPOSITORY_NAME:-${_PROFILE[ecrRepositoryName]:-ml-container-creator}}"
+export AWS_REGION="${AWS_REGION:-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
 
 # Parse arguments
 CLEANUP_TARGET=""

package/templates/do/clean.d/batch-transform.ejs

@@ -9,6 +9,14 @@ set -o pipefail
 # Source configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ECR_REPOSITORY_NAME="${ECR_REPOSITORY_NAME:-${_PROFILE[ecrRepositoryName]:-ml-container-creator}}"
+export AWS_REGION="${AWS_REGION:-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
 
 # Parse arguments
 CLEANUP_TARGET=""

package/templates/do/clean.d/hyperpod-eks.ejs

@@ -9,6 +9,14 @@ set -o pipefail
 # Source configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ECR_REPOSITORY_NAME="${ECR_REPOSITORY_NAME:-${_PROFILE[ecrRepositoryName]:-ml-container-creator}}"
+export AWS_REGION="${AWS_REGION:-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
 
 # Parse arguments
 CLEANUP_TARGET=""

package/templates/do/clean.d/managed-inference.ejs

@@ -9,6 +9,14 @@ set -o pipefail
 # Source configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/config"
+source "${SCRIPT_DIR}/lib/profile.sh"
+
+# ── Profile-resolved variables (env var > profile > default) ──────────────────
+# Disable unbound-variable checking for associative array access (bash 3.2 compat)
+set +u
+ECR_REPOSITORY_NAME="${ECR_REPOSITORY_NAME:-${_PROFILE[ecrRepositoryName]:-ml-container-creator}}"
+export AWS_REGION="${AWS_REGION:-${_PROFILE[awsRegion]:-us-east-1}}"
+set -u
 
 # Parse arguments
 CLEANUP_TARGET=""