Initial commit

Author: jdalton

.github/actions/restore-checkpoint/action.yml

@@ -52,12 +52,16 @@ runs:
         MODE_CHECKPOINT_DIR="packages/${PACKAGE_NAME}/build/${BUILD_MODE}/checkpoints"
         SHARED_CHECKPOINT_DIR="packages/${PACKAGE_NAME}/build/shared/checkpoints"
         OUTPUT_DIR="packages/${PACKAGE_NAME}/build/${BUILD_MODE}/out"
+        SHARED_SOURCE_DIR="packages/${PACKAGE_NAME}/build/shared/source"
+        MODE_SOURCE_DIR="packages/${PACKAGE_NAME}/build/${BUILD_MODE}/source"
 
         echo "📦 Package: ${PACKAGE_NAME}"
         echo "🔧 Build mode: ${BUILD_MODE}"
         echo "📁 Mode checkpoint directory: ${MODE_CHECKPOINT_DIR}"
         echo "📁 Shared checkpoint directory: ${SHARED_CHECKPOINT_DIR}"
         echo "📤 Output directory: ${OUTPUT_DIR}"
+        echo "📂 Shared source directory: ${SHARED_SOURCE_DIR}"
+        echo "📂 Mode source directory: ${MODE_SOURCE_DIR}"
         echo ""
 
         # Parse checkpoint chain into array (comma-separated)
@@ -149,10 +153,92 @@ runs:
         fi
         echo ""
 
-        # Extract checkpoint
-        echo "📦 Extracting checkpoint to ${OUTPUT_DIR}..."
-        mkdir -p "${OUTPUT_DIR}"
-        tar -xzf "${CHECKPOINT_FILE}" -C "${OUTPUT_DIR}"
+        # Extract checkpoint to correct directory based on checkpoint name
+        # Checkpoint structure varies by package:
+        #
+        # node-smol-builder:
+        # - finalized → build/{mode}/out/Final/
+        # - binary-compressed → build/{mode}/out/Compressed/
+        # - binary-stripped → build/{mode}/out/Stripped/
+        # - binary-released → build/{mode}/out/Release/
+        # - source-cloned → build/shared/source/
+        # - source-patched → build/{mode}/source/
+        #
+        # onnxruntime-builder, yoga-layout-builder:
+        # - finalized → build/{mode}/out/Final/
+        # - wasm-synced → build/{mode}/out/Synced/
+        # - wasm-released → build/{mode}/out/Released/
+        # - wasm-optimized → build/{mode}/out/Optimized/
+        # - wasm-compiled → build/{mode}/out/Compiled/
+        # - source-configured → build/{mode}/source/ (yoga-layout only)
+        # - source-cloned → build/shared/source/
+        #
+        # models:
+        # - finalized → build/{mode}/out/Final/
+        # - quantized → build/{mode}/models/
+        # - converted → build/{mode}/models/
+        # - downloaded → build/{mode}/models/
+        EXTRACT_DIR="${OUTPUT_DIR}"
+        case "${RESTORED_CHECKPOINT}" in
+          finalized)
+            EXTRACT_DIR="${OUTPUT_DIR}/Final"
+            ;;
+          # node-smol-builder checkpoints
+          binary-compressed)
+            EXTRACT_DIR="${OUTPUT_DIR}/Compressed"
+            ;;
+          binary-stripped)
+            EXTRACT_DIR="${OUTPUT_DIR}/Stripped"
+            ;;
+          binary-released)
+            EXTRACT_DIR="${OUTPUT_DIR}/Release"
+            ;;
+          # onnxruntime-builder, yoga-layout-builder checkpoints
+          wasm-synced)
+            EXTRACT_DIR="${OUTPUT_DIR}/Synced"
+            ;;
+          wasm-released)
+            EXTRACT_DIR="${OUTPUT_DIR}/Released"
+            ;;
+          wasm-optimized)
+            EXTRACT_DIR="${OUTPUT_DIR}/Optimized"
+            ;;
+          wasm-compiled)
+            EXTRACT_DIR="${OUTPUT_DIR}/Compiled"
+            ;;
+          source-configured)
+            # yoga-layout-builder specific: extract to mode source directory
+            EXTRACT_DIR="${MODE_SOURCE_DIR}"
+            ;;
+          # models checkpoints
+          quantized|converted|downloaded)
+            # Models checkpoints extract to build/{mode}/models/
+            EXTRACT_DIR="packages/${PACKAGE_NAME}/build/${BUILD_MODE}/models"
+            ;;
+          # Source checkpoints (shared across packages)
+          source-cloned)
+            # Shared checkpoint: extract to shared source directory
+            EXTRACT_DIR="${SHARED_SOURCE_DIR}"
+            ;;
+          source-patched)
+            # Mode-specific checkpoint: extract to mode source directory
+            EXTRACT_DIR="${MODE_SOURCE_DIR}"
+            ;;
+        esac
+
+        echo "📦 Extracting checkpoint to ${EXTRACT_DIR}..."
+        mkdir -p "${EXTRACT_DIR}"
+        # Extract tarball, stripping the top-level directory wrapper
+        # -x: extract archive
+        # -z: decompress with gzip
+        # -f: input file
+        # -C: change to directory before extracting
+        # --strip-components=1: remove first directory level from paths
+        #
+        # Example: tarball contains Final/ort.wasm
+        #   Without --strip-components=1: extracts to out/Final/Final/ort.wasm (WRONG)
+        #   With --strip-components=1: extracts to out/Final/ort.wasm (CORRECT)
+        tar -xzf "${CHECKPOINT_FILE}" -C "${EXTRACT_DIR}" --strip-components=1
         echo "✅ Checkpoint extracted successfully"
         echo ""
 

packages/build-infra/lib/checkpoint-manager.mjs

@@ -146,36 +146,62 @@ export async function hasCheckpoint(buildDir, packageName, checkpointName) {
  * - Tarball: build/{mode}/checkpoints/{package}/{phase}.tar.gz (if artifactPath provided)
  *
  * @param {string} buildDir - Build directory path
- * @param {string} packageName - Package name
  * @param {string} checkpointName - Checkpoint name (e.g., 'release', 'patches-applied')
  * @param {Function} smokeTest - Async function that validates build artifacts (REQUIRED)
- * @param {object} data - Checkpoint metadata
- * @param {string} [data.artifactPath] - Path to file or directory to archive in checkpoint
- * @param {string[]} [data.sourcePaths] - Source file paths to hash for cache validation
- * @param {string} [data.packageRoot] - Package root for relative path display
- * @param {string} [data.platform] - Platform (darwin, linux, win32)
- * @param {string} [data.arch] - Architecture (x64, arm64)
+ * @param {object} [options] - Optional checkpoint metadata
+ * @param {string | undefined} [options.packageName=''] - Package name (defaults to '' for flat structure)
+ * @param {string | undefined} [options.artifactPath] - Path to file or directory to archive in checkpoint
+ * @param {string[] | undefined} [options.sourcePaths] - Source file paths to hash for cache validation
+ * @param {string | undefined} [options.packageRoot] - Package root for relative path display
+ * @param {string | undefined} [options.platform=process.platform] - Platform (darwin, linux, win32)
+ * @param {string | undefined} [options.arch=process.arch] - Architecture (x64, arm64)
+ * @param {string | undefined} [options.binaryPath] - Binary path for macOS code signing
  * @returns {Promise<void>}
  *
  * @example
- * await createCheckpoint(BUILD_DIR, '', 'release', async () => {
- *   // Smoke test: Verify binary runs
+ * // Minimal usage
+ * await createCheckpoint(BUILD_DIR, 'release', async () => {
+ *   await spawn(binaryPath, ['--version'])
+ * })
+ *
+ * // With options
+ * await createCheckpoint(BUILD_DIR, 'release', async () => {
  *   await spawn(binaryPath, ['--version'])
  * }, {
- *   artifactPath: './out/Release/node', // Archive this binary
- *   sourcePaths: ['build.mjs', 'patches/*.patch'], // Cache key
+ *   artifactPath: './out/Release/node',
+ *   sourcePaths: ['build.mjs', 'patches/*.patch'],
  *   packageRoot: PACKAGE_ROOT,
- *   platform: 'darwin',
- *   arch: 'arm64',
  * })
  */
 export async function createCheckpoint(
   buildDir,
-  packageName,
   checkpointName,
   smokeTest,
-  data = {},
+  options = {},
 ) {
+  // Extract options with defaults
+  const {
+    arch = process.arch,
+    artifactPath,
+    binaryPath,
+    packageName = '',
+    packageRoot,
+    platform = process.platform,
+    sourcePaths,
+    ...rest
+  } = options
+
+  // Build data object for legacy code paths
+  const data = {
+    artifactPath,
+    sourcePaths,
+    packageRoot,
+    platform,
+    arch,
+    binaryPath,
+    ...rest,
+  }
+
   // Enforce smoke test requirement
   if (typeof smokeTest !== 'function') {
     const actualValue =
@@ -187,18 +213,17 @@ export async function createCheckpoint(
         'ERROR: createCheckpoint() called incorrectly!\n' +
         `${'='.repeat(70)}\n` +
         `Checkpoint: "${checkpointName}"\n` +
-        `Package: "${packageName || '(none)'}"\n` +
         '\n' +
-        'Expected parameter 4: smokeTest callback function\n' +
-        `Actual parameter 4: ${actualValue}\n` +
+        'Expected parameter 3: smokeTest callback function\n' +
+        `Actual parameter 3: ${actualValue}\n` +
         '\n' +
         'Correct pattern:\n' +
-        '  createCheckpoint(buildDir, pkg, name, async () => {\n' +
+        '  createCheckpoint(buildDir, checkpointName, async () => {\n' +
         '    // Smoke test validation code here\n' +
-        '  }, data)\n' +
+        '  }, options)\n' +
         '\n' +
         'You passed:\n' +
-        '  createCheckpoint(buildDir, pkg, name, data) ❌ Missing callback!\n' +
+        '  createCheckpoint(buildDir, checkpointName, options) ❌ Missing callback!\n' +
         `${'='.repeat(70)}\n`,
     )
   }
@@ -213,7 +238,6 @@ export async function createCheckpoint(
   }
 
   // Build checkpoint identifier with platform/arch if provided
-  const { arch, packageRoot, platform } = data
   let checkpointId = checkpointName
   if (platform && arch) {
     checkpointId = `${checkpointName} (${platform}-${arch})`
@@ -291,6 +315,16 @@ export async function createCheckpoint(
     const unixTarDir = toUnixPath(tarDir)
 
     try {
+      // Create tarball with artifact as top-level entry
+      // -c: create archive
+      // -z: compress with gzip
+      // -f: output file
+      // -C: change to directory before archiving (ensures artifact becomes top-level entry)
+      // tarBase: the artifact basename to archive (file or directory)
+      //
+      // Example: tar -czf checkpoint.tar.gz -C /build/dev/out Final
+      //   → Creates tarball containing Final/ as top-level entry
+      //   → During extraction, use --strip-components=1 to remove this wrapper
       await spawn(
         tarBin,
         ['-czf', unixTarballPath, '-C', unixTarDir, tarBase],