action.yml

name: "Configure Node.js"
description: "Install Node.js, resolve the package manager, restore dependency cache, and install dependencies when needed"

inputs:
  node-version:
    description: "Node.js version to install"
    default: "22.x"
  package-manager:
    description: "Optional override for npm, yarn, or pnpm; defaults to the package manager inferred from package.json and lockfiles"
    default: ""
  working-directory:
    description: "Repository-relative directory containing package.json and lockfile"
    default: "."
  cache-key-suffix:
    description: "Optional suffix appended to the dependency cache key for namespacing"
    default: ""
  dependency-cache:
    description: "Default manager cache, or opt-in completed pnpm node-modules tree"
    default: "default"
  cache-mode:
    description: "Completed-tree mode: populate (probe/install/save) or restore (exact restore, never install)"
    default: "auto"
  cache-inputs:
    description: "Additional installation input files, newline-separated paths relative to working-directory"
    default: ""
  cache-corepack:
    description: "Cache pinned pnpm/Yarn executables unless COREPACK_HOME is caller-managed"
    default: "true"
  cache-electron:
    description: "If true, cache workspace-local Electron runtime and native-addon downloads used by lifecycle scripts"
    default: "false"
  lookup-only:
    description: "If true, only checks if the dependency cache exists and skips download. Does not change save cache behavior"
    default: "false"
  persistent-store-dir:
    description: "Absolute path outside the workspace that keeps the pnpm store, Corepack home, and Electron caches between jobs on a persistent self-hosted runner; empty disables"
    default: ""
  persistent-store-max-age-days:
    description: "Days a seeded persistent store stays warm before it is dropped and re-seeded from the dependency cache"
    default: "14"

outputs:
  cache-key:
    description: "Exact dependency cache key shared by compatible producers and consumers"
    value: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}
  package-manager:
    description: "Resolved package manager"
    value: ${{ steps.resolve-package-manager.outputs.packageManager }}
  package-manager-version:
    description: "Resolved package manager version from package.json when available"
    value: ${{ steps.resolve-package-manager.outputs.packageManagerVersion }}
  manager-cache-key:
    description: "Package-manager-specific cache key segment"
    value: ${{ steps.resolve-package-manager.outputs.managerCacheKey }}
  lockfile-name:
    description: "Detected lockfile name"
    value: ${{ steps.resolve-package-manager.outputs.lockfileName }}
  lockfile-path:
    description: "Detected lockfile path relative to the working directory"
    value: ${{ steps.resolve-package-manager.outputs.lockfilePath }}
  lockfile-sha:
    description: "SHA256 hash of the detected lockfile"
    value: ${{ steps.resolve-package-manager.outputs.lockfileSha }}
  install-command:
    description: "Install command used when dependency installation runs"
    value: ${{ steps.persistent-store.outputs.installCommand || steps.resolve-package-manager.outputs.installCommand }}
  working-directory:
    description: "Normalized repository-relative working directory"
    value: ${{ steps.resolve-cache-paths.outputs.workingDirectory }}
  working-directory-key:
    description: "Cache-key-safe identifier for the normalized working directory"
    value: ${{ steps.resolve-cache-paths.outputs.workingDirectoryKey }}
  cache-hit:
    description: "Whether actions/cache restored a dependency cache entry"
    value: ${{ steps.cache-dependencies.outputs.cache-hit }}
  node-major:
    description: "Node.js major version the dependency cache key was built from"
    value: ${{ steps.resolve-dependency-cache-paths.outputs.nodeMajor }}
  pnpm-store-path:
    description: "Absolute pnpm store path when pnpm setup runs"
    value: ${{ steps.seed-persistent-store.outputs.pnpmStorePath || steps.prepare-package-manager.outputs.pnpmStorePath }}
  persistent-store-warm:
    description: "Whether a warm persistent pnpm store let the dependency cache restore be skipped"
    value: ${{ steps.persistent-store.outputs.warm }}
  cache-restore-duration-ms:
    description: "Measured cache restore phase duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.cacheRestoreDurationMs }}
  setup-node-duration-ms:
    description: "Measured setup-node phase duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.setupNodeDurationMs }}
  package-manager-activation-duration-ms:
    description: "Measured Corepack/package-manager activation duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.activationDurationMs }}
  store-discovery-duration-ms:
    description: "Measured pnpm store discovery duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.storeDiscoveryDurationMs }}
  install-duration-ms:
    description: "Measured dependency installation duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.installDurationMs }}
  cache-save-duration-ms:
    description: "Measured cache save phase duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.cacheSaveDurationMs }}
  total-duration-ms:
    description: "Measured total action duration in milliseconds"
    value: ${{ steps.finalize-timings.outputs.totalDurationMs }}

runs:
  using: "composite"
  steps:
    - name: Resolve working directory and Node.js version spec
      id: resolve-cache-paths
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_WORKING_DIRECTORY: ${{ inputs.working-directory }}
        CONFIGURE_NODEJS_CACHE_KEY_SUFFIX: ${{ inputs.cache-key-suffix }}
        CONFIGURE_NODEJS_CACHE_ELECTRON: ${{ inputs.cache-electron }}
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_CACHE_MODE: ${{ inputs.cache-mode }}
        CONFIGURE_NODEJS_LOOKUP_ONLY: ${{ inputs.lookup-only }}
        CONFIGURE_NODEJS_NODE_VERSION: ${{ inputs.node-version }}
      with:
        script: |
          const actionStartedAt = Date.now();
          const path = require('path');
          const { pathToFileURL } = require('url');

          const moduleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-cache-paths.mjs'),
          ).href;
          const {
            buildResult,
          } = await import(moduleUrl);
          const nodeVersionModuleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-node-version.mjs'),
          ).href;
          const { parseNodeVersionSpec } = await import(nodeVersionModuleUrl);

          const result = buildResult({
            cwd: process.env.GITHUB_WORKSPACE,
            workingDirectory: process.env.CONFIGURE_NODEJS_WORKING_DIRECTORY,
            cacheKeySuffix: process.env.CONFIGURE_NODEJS_CACHE_KEY_SUFFIX,
            cacheElectron: process.env.CONFIGURE_NODEJS_CACHE_ELECTRON,
          });

          const { validateCacheMode } = await import(pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'completed-tree.mjs'),
          ).href);
          validateCacheMode({
            dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
            cacheMode: process.env.CONFIGURE_NODEJS_CACHE_MODE,
            lookupOnly: process.env.CONFIGURE_NODEJS_LOOKUP_ONLY,
          });

          core.setOutput('absoluteWorkingDirectory', result.absoluteWorkingDirectory);
          core.setOutput('workingDirectory', result.workingDirectory);
          core.setOutput('workingDirectoryKey', result.workingDirectoryKey);
          core.setOutput('cacheKeySuffix', result.cacheKeySuffix);
          core.setOutput('cacheKeySuffixSegment', result.cacheKeySuffixSegment);
          core.setOutput('actionStartedAt', actionStartedAt);

          const nodeVersionSpec = parseNodeVersionSpec(
            process.env.CONFIGURE_NODEJS_NODE_VERSION,
          );
          core.setOutput('nodeVersionIsFloating', String(nodeVersionSpec.isFloating));
          core.info(
            nodeVersionSpec.isFloating
              ? `Node.js version "${nodeVersionSpec.spec}" can span major versions (${nodeVersionSpec.reason}); resolving it with actions/setup-node before restoring the dependency cache.`
              : `Node.js version "${nodeVersionSpec.spec}" pins major ${nodeVersionSpec.major}; restoring the dependency cache before installing Node.js.`,
          );

    - name: Resolve package manager
      id: resolve-package-manager
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY: ${{ steps.resolve-cache-paths.outputs.absoluteWorkingDirectory }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ inputs.package-manager }}
      with:
        script: |
          const path = require('path');
          const { pathToFileURL } = require('url');

          const moduleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-manager.mjs'),
          ).href;
          const {
            buildResult,
            normalizeManager,
          } = await import(moduleUrl);

          const result = buildResult({
            cwd: process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY,
            explicitManager: normalizeManager(process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER ?? ''),
          });

          core.setOutput('packageManager', result.packageManager);
          core.setOutput('packageManagerVersion', result.packageManagerVersion);
          core.setOutput('managerCacheKey', result.managerCacheKey);
          core.setOutput('lockfileName', result.lockfileName);
          core.setOutput('lockfilePath', result.lockfilePath);
          core.setOutput('lockfileSha', result.lockfileSha);
          core.setOutput('installCommand', result.installCommand);
          core.setOutput('installExecutable', result.installExecutable);
          core.setOutput('installArguments', JSON.stringify(result.installArguments));
          core.setOutput('needsCorepack', result.needsCorepack);
          core.setOutput('setupNodeStartedAt', Date.now());

    # Persistent self-hosted runners keep their disk between jobs, but checkout
    # cleans the workspace, so the in-workspace store is deleted every job. With
    # persistent-store-dir set, the store lives outside the workspace instead. A
    # warm store skips the dependency cache restore; a cold one (missing,
    # unreadable, future-dated, or expired marker) is dropped here and re-seeded
    # after the normal restore and install. See scripts/persistent-store.mjs.
    - name: Check persistent pnpm store
      id: persistent-store
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_PERSISTENT_STORE_DIR: ${{ inputs.persistent-store-dir }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_MAX_AGE_DAYS: ${{ inputs.persistent-store-max-age-days }}
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_LOOKUP_ONLY: ${{ inputs.lookup-only }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ steps.resolve-package-manager.outputs.packageManager }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION: ${{ steps.resolve-package-manager.outputs.packageManagerVersion }}
        CONFIGURE_NODEJS_INSTALL_EXECUTABLE: ${{ steps.resolve-package-manager.outputs.installExecutable }}
        CONFIGURE_NODEJS_INSTALL_ARGUMENTS: ${{ steps.resolve-package-manager.outputs.installArguments }}
      with:
        script: |
          const path = require('path');
          const { pathToFileURL } = require('url');
          const {
            checkPersistentStore,
            describePersistentStoreCheck,
            isPersistentStoreEnabled,
            isUnderRunnerTemp,
            normalizeMaxAgeDays,
            persistentStorePaths,
            resolvePersistentCorepackHome,
            resolvePersistentStoreRoot,
            validatePersistentStoreMode,
            withStoreDir,
          } = await import(pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'persistent-store.mjs'),
          ).href);

          core.setOutput('warm', 'false');
          if (!isPersistentStoreEnabled(process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_DIR)) {
            core.setOutput('enabled', 'false');
            return;
          }

          validatePersistentStoreMode({
            dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
            lookupOnly: process.env.CONFIGURE_NODEJS_LOOKUP_ONLY,
            packageManager: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER,
            packageManagerVersion: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION,
          });
          const maxAgeDays = normalizeMaxAgeDays(
            process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_MAX_AGE_DAYS,
          );
          const root = resolvePersistentStoreRoot({
            persistentStoreDir: process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_DIR,
            workspace: process.env.GITHUB_WORKSPACE,
            home: require('os').homedir(),
          });
          if (isUnderRunnerTemp({ root, runnerTemp: process.env.RUNNER_TEMP ?? '' })) {
            core.warning(`persistent-store-dir "${root}" is under RUNNER_TEMP, which the runner empties before every job, so the store will never be warm.`);
          }
          const paths = persistentStorePaths(root);
          const result = checkPersistentStore({
            paths,
            now: Math.floor(Date.now() / 1000),
            maxAgeDays,
          });
          core.info(describePersistentStoreCheck(result, { paths, maxAgeDays }));

          const corepack = resolvePersistentCorepackHome({
            paths,
            corepackHome: process.env.COREPACK_HOME ?? '',
            managedCorepackHome: process.env.CONFIGURE_NODEJS_MANAGED_COREPACK_HOME ?? '',
          });
          if (corepack.managed) {
            core.exportVariable('COREPACK_HOME', corepack.home);
          } else {
            core.info(`Keeping caller-managed COREPACK_HOME ${corepack.home}.`);
          }

          core.setOutput('enabled', 'true');
          core.setOutput('warm', String(result.warm));
          core.setOutput('root', paths.root);
          core.setOutput('storePath', paths.store);
          core.setOutput('electronCachePath', paths.electron);
          core.setOutput('prebuildCachePath', paths.prebuild);
          if (result.warm) {
            const installArguments = withStoreDir(
              JSON.parse(process.env.CONFIGURE_NODEJS_INSTALL_ARGUMENTS),
              paths.store,
            );
            core.setOutput('installArguments', JSON.stringify(installArguments));
            core.setOutput(
              'installCommand',
              [process.env.CONFIGURE_NODEJS_INSTALL_EXECUTABLE, ...installArguments].join(' '),
            );
          }
          // Dropping an expired store can take seconds; keep it out of the
          // setup-node timing that a floating Node.js spec measures from here.
          core.setOutput('setupNodeStartedAt', Date.now());

    # The dependency cache key has to carry the Node.js major that will actually
    # run the restored tree, because NODE_MODULE_VERSION -- and therefore the ABI
    # every compiled native addon in node_modules was built against -- changes
    # with each major. A pinned spec supplies that major from the string alone, so
    # the restore stays ahead of setup-node and `lookup-only` can still skip
    # installing Node entirely on a hit. A spec that can cross a major (lts/*,
    # latest, >=20) has no such shortcut: the only source of truth is setup-node
    # itself, so it runs first and the fast path is given up for those specs only.
    # In practice a floating spec resolves to a version already in the runner
    # toolcache, which makes this a PATH update rather than a download.
    #
    # pnpm reinstalls on every run, so it could in principle keep the fast path
    # by dropping the major from its key. That is left alone deliberately: the
    # key already separated pnpm stores by Node version before this change, and
    # removing that separation would rest on an unverified assumption about how
    # pnpm keys build side effects inside its store.
    - name: Setup Node.js for floating version spec
      id: setup-node-floating
      if: steps.resolve-cache-paths.outputs.nodeVersionIsFloating == 'true'
      uses: actions/setup-node@v6
      with:
        node-version: ${{ inputs.node-version }}
        package-manager-cache: false

    - name: Resolve dependency cache paths
      id: resolve-dependency-cache-paths
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_CACHE_MODE: ${{ inputs.cache-mode }}
        CONFIGURE_NODEJS_LOOKUP_ONLY: ${{ inputs.lookup-only }}
        CONFIGURE_NODEJS_CACHE_INPUTS: ${{ inputs.cache-inputs }}
        CONFIGURE_NODEJS_MANAGER_VERSION: ${{ steps.resolve-package-manager.outputs.packageManagerVersion }}
        CONFIGURE_NODEJS_MANAGER_KEY: ${{ steps.resolve-package-manager.outputs.managerCacheKey }}
        CONFIGURE_NODEJS_LOCKFILE_PATH: ${{ steps.resolve-package-manager.outputs.lockfilePath }}
        CONFIGURE_NODEJS_LOCKFILE_SHA: ${{ steps.resolve-package-manager.outputs.lockfileSha }}
        CONFIGURE_NODEJS_RUNNER_OS: ${{ runner.os }}
        CONFIGURE_NODEJS_RUNNER_ARCH: ${{ runner.arch }}
        CONFIGURE_NODEJS_WORKING_DIRECTORY: ${{ inputs.working-directory }}
        CONFIGURE_NODEJS_CACHE_KEY_SUFFIX: ${{ inputs.cache-key-suffix }}
        CONFIGURE_NODEJS_CACHE_ELECTRON: ${{ inputs.cache-electron }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ steps.resolve-package-manager.outputs.packageManager }}
        CONFIGURE_NODEJS_NODE_VERSION: ${{ inputs.node-version }}
        CONFIGURE_NODEJS_INSTALLED_NODE_VERSION: ${{ steps.setup-node-floating.outputs.node-version }}
        CONFIGURE_NODEJS_SETUP_NODE_STARTED_AT: ${{ steps.persistent-store.outputs.setupNodeStartedAt || steps.resolve-package-manager.outputs.setupNodeStartedAt }}
      with:
        script: |
          const path = require('path');
          const { pathToFileURL } = require('url');

          const moduleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-cache-paths.mjs'),
          ).href;
          const {
            buildResult,
          } = await import(moduleUrl);
          const nodeVersionModuleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-node-version.mjs'),
          ).href;
          const { buildResult: buildNodeVersionResult } = await import(
            nodeVersionModuleUrl,
          );

          const installedNodeVersion =
            process.env.CONFIGURE_NODEJS_INSTALLED_NODE_VERSION ?? '';
          const nodeVersion = buildNodeVersionResult({
            nodeVersion: process.env.CONFIGURE_NODEJS_NODE_VERSION,
            installedNodeVersion,
          });

          if (nodeVersion.resolvedFrom === 'setup-node') {
            const setupNodeStartedAt = Number.parseInt(
              process.env.CONFIGURE_NODEJS_SETUP_NODE_STARTED_AT,
              10,
            );
            core.setOutput(
              'floatingSetupNodeDurationMs',
              Number.isFinite(setupNodeStartedAt)
                ? Date.now() - setupNodeStartedAt
                : 0,
            );
            core.info(
              `Node.js version "${nodeVersion.spec}" resolved to ${installedNodeVersion}; keying the dependency cache on major ${nodeVersion.nodeMajor}.`,
            );
          }

          const result = buildResult({
            cwd: process.env.GITHUB_WORKSPACE,
            workingDirectory: process.env.CONFIGURE_NODEJS_WORKING_DIRECTORY,
            cacheKeySuffix: process.env.CONFIGURE_NODEJS_CACHE_KEY_SUFFIX,
            cacheElectron: process.env.CONFIGURE_NODEJS_CACHE_ELECTRON,
            packageManager: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER,
            dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
          });

          const { validateCacheMode, installationInputsHash, actionSourceHash, buildCompletedKey } = await import(pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'completed-tree.mjs'),
          ).href);
          validateCacheMode({
            dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
            cacheMode: process.env.CONFIGURE_NODEJS_CACHE_MODE,
            lookupOnly: process.env.CONFIGURE_NODEJS_LOOKUP_ONLY,
            packageManager: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER,
            packageManagerVersion: process.env.CONFIGURE_NODEJS_MANAGER_VERSION,
          });
          let cacheKey;
          if (process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE === 'node-modules') {
            const inputsHash = installationInputsHash({
              cwd: result.absoluteWorkingDirectory,
              repositoryRoot: process.env.GITHUB_WORKSPACE,
              lockfilePath: process.env.CONFIGURE_NODEJS_LOCKFILE_PATH,
              cacheInputs: process.env.CONFIGURE_NODEJS_CACHE_INPUTS,
            });
            core.setOutput('inputsHash', inputsHash);
            cacheKey = buildCompletedKey({
              nodeMajor: nodeVersion.nodeMajor,
              packageManagerVersion: process.env.CONFIGURE_NODEJS_MANAGER_VERSION,
              os: process.env.CONFIGURE_NODEJS_RUNNER_OS,
              arch: process.env.CONFIGURE_NODEJS_RUNNER_ARCH,
              imageOS: process.env.ImageOS ?? '',
              workingDirectory: result.workingDirectory,
              inputsHash,
              actionRevision: actionSourceHash(process.env.GITHUB_ACTION_PATH),
              cacheKeySuffix: process.env.CONFIGURE_NODEJS_CACHE_KEY_SUFFIX,
              cacheElectron: result.cacheElectron,
            });
          } else {
            cacheKey = `${result.cacheKeyPrefix}-${nodeVersion.nodeCacheKeySegment}-${process.env.CONFIGURE_NODEJS_RUNNER_OS}-${process.env.CONFIGURE_NODEJS_RUNNER_ARCH}-${result.workingDirectoryKey}-${process.env.CONFIGURE_NODEJS_MANAGER_KEY}-${process.env.CONFIGURE_NODEJS_LOCKFILE_SHA}${result.electronCacheKeySegment}${result.cacheKeySuffixSegment}`;
          }
          core.setOutput('cacheKey', cacheKey);
          core.setOutput('absolutePnpmStorePath', path.join(result.absoluteWorkingDirectory, '.pnpm-store'));
          core.setOutput('cachePaths', result.cachePaths.join('\n'));
          core.setOutput('primaryCachePath', result.primaryCachePath);
          core.setOutput('absolutePrimaryCachePath', result.absolutePrimaryCachePath);
          core.setOutput('cacheKeyPrefix', result.cacheKeyPrefix);
          core.setOutput('cacheElectron', String(result.cacheElectron));
          core.setOutput('electronCacheKeySegment', result.electronCacheKeySegment);
          core.setOutput('absolutePrebuildCachePath', result.absolutePrebuildCachePath);
          core.setOutput('absoluteElectronCachePath', result.absoluteElectronCachePath);
          core.setOutput('nodeMajor', nodeVersion.nodeMajor);
          core.setOutput('nodeCacheKeySegment', nodeVersion.nodeCacheKeySegment);
          core.setOutput('cacheRestoreStartedAt', Date.now());

    - name: Restore dependencies from cache
      id: cache-dependencies
      if: steps.persistent-store.outputs.warm != 'true'
      uses: actions/cache/restore@v5
      with:
        path: ${{ steps.resolve-dependency-cache-paths.outputs.cachePaths }}
        key: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}
        lookup-only: ${{ inputs.lookup-only == 'true' || (inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'populate') }}
        fail-on-cache-miss: ${{ inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'restore' }}

    - name: Require an exact completed consumer hit
      if: inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'restore'
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_CACHE_HIT: ${{ steps.cache-dependencies.outputs.cache-hit }}
      with:
        script: |
          if (process.env.CONFIGURE_NODEJS_CACHE_HIT !== 'true') {
            throw new Error('Exact completed dependency cache miss; strict restore forbids fallback or installation.');
          }

    - name: Record cache restore timing
      id: cache-restore-timing
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_CACHE_RESTORE_STARTED_AT: ${{ steps.resolve-dependency-cache-paths.outputs.cacheRestoreStartedAt }}
      with:
        script: |
          const now = Date.now();
          const startedAt = Number.parseInt(
            process.env.CONFIGURE_NODEJS_CACHE_RESTORE_STARTED_AT,
            10,
          );
          core.setOutput('cacheRestoreDurationMs', now - startedAt);
          core.setOutput('setupNodeStartedAt', now);

    - name: Setup Node.js
      id: setup-node
      uses: actions/setup-node@v6
      if: steps.resolve-cache-paths.outputs.nodeVersionIsFloating != 'true' && ((inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'restore') || (inputs.dependency-cache != 'node-modules' && inputs.lookup-only != 'true') || steps.cache-dependencies.outputs.cache-hit != 'true')
      with:
        node-version: ${{ inputs.node-version }}
        package-manager-cache: false

    - name: Resolve Corepack cache
      id: resolve-corepack-cache
      if: steps.resolve-package-manager.outputs.needsCorepack == 'true' && steps.persistent-store.outputs.enabled != 'true' && ((inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'restore') || (inputs.dependency-cache != 'node-modules' && inputs.lookup-only != 'true') || steps.cache-dependencies.outputs.cache-hit != 'true')
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_CACHE_COREPACK: ${{ inputs.cache-corepack }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ steps.resolve-package-manager.outputs.packageManager }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION: ${{ steps.resolve-package-manager.outputs.packageManagerVersion }}
        CONFIGURE_NODEJS_RUNNER_OS: ${{ runner.os }}
        CONFIGURE_NODEJS_RUNNER_ARCH: ${{ runner.arch }}
      with:
        script: |
          core.setOutput('startedAt', Date.now());
          const path = require('path');
          const { pathToFileURL } = require('url');
          const { resolveCorepackCache } = await import(pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-corepack-cache.mjs'),
          ).href);
          const result = resolveCorepackCache({
            enabled: process.env.CONFIGURE_NODEJS_CACHE_COREPACK === 'true',
            corepackHome: process.env.COREPACK_HOME ?? '',
            managedCorepackHome: process.env.CONFIGURE_NODEJS_MANAGED_COREPACK_HOME ?? '',
            manager: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER,
            version: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION,
            runnerTemp: process.env.RUNNER_TEMP,
            os: process.env.CONFIGURE_NODEJS_RUNNER_OS,
            arch: process.env.CONFIGURE_NODEJS_RUNNER_ARCH,
          });
          if (result) {
            core.exportVariable('COREPACK_HOME', result.home);
            core.exportVariable('CONFIGURE_NODEJS_MANAGED_COREPACK_HOME', result.home);
            core.setOutput('home', result.home);
            core.setOutput('key', result.key);
          }

    - name: Restore Corepack package manager
      id: cache-corepack
      if: steps.resolve-corepack-cache.outputs.key != ''
      uses: actions/cache/restore@v5
      with:
        path: ${{ steps.resolve-corepack-cache.outputs.home }}
        key: ${{ steps.resolve-corepack-cache.outputs.key }}

    - name: Prepare package manager
      id: prepare-package-manager
      if: ((inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'restore') || (inputs.dependency-cache != 'node-modules' && inputs.lookup-only != 'true') || steps.cache-dependencies.outputs.cache-hit != 'true')
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_CACHE_MODE: ${{ inputs.cache-mode }}
        CONFIGURE_NODEJS_CACHE_KEY: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}
        CONFIGURE_NODEJS_PNPM_STORE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePnpmStorePath }}
        CONFIGURE_NODEJS_COREPACK_CACHE_STARTED_AT: ${{ steps.resolve-corepack-cache.outputs.startedAt }}
        CONFIGURE_NODEJS_SETUP_STARTED_AT: ${{ steps.cache-restore-timing.outputs.setupNodeStartedAt }}
        CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY: ${{ steps.resolve-cache-paths.outputs.absoluteWorkingDirectory }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ steps.resolve-package-manager.outputs.packageManager }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION: ${{ steps.resolve-package-manager.outputs.packageManagerVersion }}
        CONFIGURE_NODEJS_NEEDS_COREPACK: ${{ steps.resolve-package-manager.outputs.needsCorepack }}
        CONFIGURE_NODEJS_ABSOLUTE_PRIMARY_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePrimaryCachePath }}
        CONFIGURE_NODEJS_LOOKUP_ONLY: ${{ inputs.lookup-only }}
        CONFIGURE_NODEJS_NODE_VERSION: ${{ inputs.node-version }}
        CONFIGURE_NODEJS_NODE_CACHE_KEY_MAJOR: ${{ steps.resolve-dependency-cache-paths.outputs.nodeMajor }}
        CONFIGURE_NODEJS_INSTALLED_NODE_VERSION: ${{ steps.setup-node.outputs.node-version }}
        CONFIGURE_NODEJS_FLOATING_SETUP_NODE_DURATION_MS: ${{ steps.resolve-dependency-cache-paths.outputs.floatingSetupNodeDurationMs }}
        CONFIGURE_NODEJS_CACHE_HIT: ${{ steps.cache-dependencies.outputs.cache-hit }}
        CONFIGURE_NODEJS_CACHE_ELECTRON: ${{ steps.resolve-dependency-cache-paths.outputs.cacheElectron }}
        CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePrebuildCachePath }}
        CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absoluteElectronCachePath }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_WARM: ${{ steps.persistent-store.outputs.warm }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT: ${{ steps.persistent-store.outputs.root }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_PATH: ${{ steps.persistent-store.outputs.storePath }}
        CONFIGURE_NODEJS_PERSISTENT_ELECTRON_CACHE_PATH: ${{ steps.persistent-store.outputs.electronCachePath }}
        CONFIGURE_NODEJS_PERSISTENT_PREBUILD_CACHE_PATH: ${{ steps.persistent-store.outputs.prebuildCachePath }}
      with:
        script: |
          const fs = require('fs');
          const path = require('path');
          const { pathToFileURL } = require('url');
          const cwd = process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY;
          const manager = process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER;
          const version = process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER_VERSION;
          // A warm persistent store replaces the workspace store and Electron
          // caches. A cold one installs in the workspace as usual, so the cache
          // save sees the same paths, and is moved out after the save.
          const persistentWarm =
            process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_WARM === 'true';
          const expectedStorePath = persistentWarm
            ? process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_PATH
            : process.env.CONFIGURE_NODEJS_PNPM_STORE_PATH;
          const setupStartedAt = Number.parseInt(
            process.env.CONFIGURE_NODEJS_SETUP_STARTED_AT,
            10,
          );

          const floatingSetupNodeDurationMs = Number.parseInt(
            process.env.CONFIGURE_NODEJS_FLOATING_SETUP_NODE_DURATION_MS,
            10,
          );
          core.setOutput(
            'setupNodeDurationMs',
            Number.isFinite(floatingSetupNodeDurationMs) &&
              floatingSetupNodeDurationMs > 0
              ? floatingSetupNodeDurationMs
              : (Number(process.env.CONFIGURE_NODEJS_COREPACK_CACHE_STARTED_AT) || Date.now()) - setupStartedAt,
          );

          // Backstop: the cache was keyed on a major parsed out of the
          // node-version string. If setup-node disagrees, the restored
          // node_modules was built against a different NODE_MODULE_VERSION, so
          // drop it and reinstall rather than hand a mismatched ABI to the job.
          const nodeVersionModuleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-node-version.mjs'),
          ).href;
          const {
            detectNodeMajorMismatch,
            shouldDiscardRestoredDependencies,
            shouldInstallDependencies,
          } = await import(nodeVersionModuleUrl);
          const cacheHit = process.env.CONFIGURE_NODEJS_CACHE_HIT === 'true';
          const lookupOnly = process.env.CONFIGURE_NODEJS_LOOKUP_ONLY === 'true';
          const mismatch = detectNodeMajorMismatch({
            cacheKeyNodeMajor: process.env.CONFIGURE_NODEJS_NODE_CACHE_KEY_MAJOR,
            installedNodeVersion:
              process.env.CONFIGURE_NODEJS_INSTALLED_NODE_VERSION,
          });
          if (mismatch && process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE !== 'node-modules') {
            core.warning(
              `Node.js version "${process.env.CONFIGURE_NODEJS_NODE_VERSION}" was treated as pinned to major ${mismatch.cacheKeyNodeMajor}, but actions/setup-node installed major ${mismatch.installedMajor}. Discarding the restored dependencies and reinstalling so native addons match the running ABI. The cache entry cannot be corrected under a key that already exists, so every run will reinstall until the lockfile changes -- please report this version spec to pwrdrvr/configure-nodejs so the classifier can be fixed.`,
            );
          }
          if (
            shouldDiscardRestoredDependencies({
              packageManager: manager,
              cacheHit,
              mismatch,
              dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
            })
          ) {
            // For npm and Yarn the primary cache path is node_modules itself.
            fs.rmSync(process.env.CONFIGURE_NODEJS_ABSOLUTE_PRIMARY_CACHE_PATH, {
              recursive: true,
              force: true,
            });
          }
          core.setOutput(
            'shouldInstall',
            String(
              shouldInstallDependencies({
                packageManager: manager,
                cacheHit,
                lookupOnly,
                mismatch,
                dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
                cacheMode: process.env.CONFIGURE_NODEJS_CACHE_MODE,
              }),
            ),
          );

          if (process.env.CONFIGURE_NODEJS_CACHE_ELECTRON === 'true') {
            const prebuildCachePath = persistentWarm
              ? process.env.CONFIGURE_NODEJS_PERSISTENT_PREBUILD_CACHE_PATH
              : process.env.CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH;
            const electronCachePath = persistentWarm
              ? process.env.CONFIGURE_NODEJS_PERSISTENT_ELECTRON_CACHE_PATH
              : process.env.CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH;
            fs.mkdirSync(prebuildCachePath, { recursive: true });
            fs.mkdirSync(electronCachePath, { recursive: true });
            core.exportVariable('npm_config_cache', prebuildCachePath);
            core.exportVariable('electron_config_cache', electronCachePath);
            core.info(
              `Using ${persistentWarm ? 'persistent' : 'workspace-local'} Electron caches at ${electronCachePath} and ${prebuildCachePath}.`,
            );
          }

          let activationDurationMs = 0;
          let storeDiscoveryDurationMs = 0;
          if (process.env.CONFIGURE_NODEJS_NEEDS_COREPACK === 'true') {
            const activationStartedAt = Date.now();
            await exec.exec('corepack', ['enable', manager], { cwd });
            if (version !== '') {
              await exec.exec(
                'corepack',
                ['prepare', `${manager}@${version}`, '--activate'],
                { cwd },
              );
            }

            const versionResult = await exec.getExecOutput(manager, ['--version'], {
              cwd,
              silent: true,
            });
            const activatedVersion = versionResult.stdout.trim();
            const expectedExactVersion = version.split('+')[0];
            if (
              /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(expectedExactVersion) &&
              activatedVersion !== expectedExactVersion
            ) {
              throw new Error(
                `Expected ${manager} ${expectedExactVersion}, got ${activatedVersion}.`,
              );
            }
            core.info(`Activated ${manager} ${activatedVersion}.`);
            activationDurationMs = Date.now() - activationStartedAt;
          }

          if (manager === 'pnpm') {
            const storeDiscoveryStartedAt = Date.now();
            process.env.PNPM_CONFIG_STORE_DIR = expectedStorePath;
            core.exportVariable('PNPM_CONFIG_STORE_DIR', expectedStorePath);
            process.env.npm_config_store_dir = expectedStorePath;
            core.exportVariable('npm_config_store_dir', expectedStorePath);

            const storeResult = await exec.getExecOutput(
              'pnpm',
              ['store', 'path', '--silent'],
              { cwd, silent: true },
            );
            const discoveredStorePath = storeResult.stdout.trim();
            const normalizeForComparison = (value) => {
              const normalized = path.resolve(value);
              return process.platform === 'win32'
                ? normalized.toLowerCase()
                : normalized;
            };

            const relativeStorePath = path.relative(
              normalizeForComparison(expectedStorePath),
              normalizeForComparison(discoveredStorePath),
            );
            if (
              relativeStorePath === '..' ||
              relativeStorePath.startsWith(`..${path.sep}`) ||
              path.isAbsolute(relativeStorePath)
            ) {
              throw new Error(
                `Expected pnpm store within ${expectedStorePath}, got ${discoveredStorePath}.`,
              );
            }

            const { assertPathWithinDirectory } = await import(pathToFileURL(
              path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-cache-paths.mjs'),
            ).href);
            if (persistentWarm) {
              assertPathWithinDirectory({ boundaryPath: process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT, candidatePath: expectedStorePath, description: 'Persistent pnpm store' });
            } else {
              assertPathWithinDirectory({ boundaryPath: cwd, candidatePath: expectedStorePath, description: 'pnpm workspace store' });
            }
            fs.mkdirSync(expectedStorePath, { recursive: true });
            assertPathWithinDirectory({ boundaryPath: expectedStorePath, candidatePath: discoveredStorePath, description: 'Discovered pnpm store', allowEqual: true });
            core.info(`Using pnpm store ${discoveredStorePath}.`);
            core.setOutput('pnpmStorePath', discoveredStorePath);
            storeDiscoveryDurationMs = Date.now() - storeDiscoveryStartedAt;
          }
          if (process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE === 'node-modules') {
            const runtime = await exec.getExecOutput('node', ['-p', 'JSON.stringify({major: Number(process.versions.node.split(".")[0]), abi: process.versions.modules})'], { cwd, silent: true });
            const { major, abi } = JSON.parse(runtime.stdout.trim());
            if (major !== Number(process.env.CONFIGURE_NODEJS_NODE_CACHE_KEY_MAJOR)) {
              throw new Error('Completed dependency Node major mismatch; installation/repair is forbidden.');
            }
            core.setOutput('nodeABI', abi);
            if (cacheHit) {
              const { verifyCompletedTree } = await import(pathToFileURL(
                path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'completed-tree.mjs'),
              ).href);
              verifyCompletedTree({ cwd, key: process.env.CONFIGURE_NODEJS_CACHE_KEY, nodeMajor: major, nodeABI: abi });
            }
          }
          core.setOutput('activationDurationMs', activationDurationMs);
          core.setOutput('storeDiscoveryDurationMs', storeDiscoveryDurationMs);

    # Save immediately so a later dependency install failure does not discard pnpm/Yarn.
    - name: Save Corepack package manager
      id: save-corepack
      if: steps.resolve-corepack-cache.outputs.key != '' && steps.cache-corepack.outputs.cache-hit != 'true'
      uses: actions/cache/save@v5
      with:
        path: ${{ steps.resolve-corepack-cache.outputs.home }}
        key: ${{ steps.resolve-corepack-cache.outputs.key }}

    - name: Install dependencies
      id: install-dependencies
      if: steps.prepare-package-manager.outputs.shouldInstall == 'true'
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_CACHE_KEY: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}
        CONFIGURE_NODEJS_NODE_MAJOR: ${{ steps.resolve-dependency-cache-paths.outputs.nodeMajor }}
        CONFIGURE_NODEJS_NODE_ABI: ${{ steps.prepare-package-manager.outputs.nodeABI }}
        CONFIGURE_NODEJS_LOCKFILE_PATH: ${{ steps.resolve-package-manager.outputs.lockfilePath }}
        CONFIGURE_NODEJS_LOCKFILE_SHA: ${{ steps.resolve-package-manager.outputs.lockfileSha }}
        CONFIGURE_NODEJS_INPUTS_HASH: ${{ steps.resolve-dependency-cache-paths.outputs.inputsHash }}
        CONFIGURE_NODEJS_CACHE_INPUTS: ${{ inputs.cache-inputs }}
        CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY: ${{ steps.resolve-cache-paths.outputs.absoluteWorkingDirectory }}
        CONFIGURE_NODEJS_INSTALL_EXECUTABLE: ${{ steps.resolve-package-manager.outputs.installExecutable }}
        CONFIGURE_NODEJS_INSTALL_ARGUMENTS: ${{ steps.persistent-store.outputs.installArguments || steps.resolve-package-manager.outputs.installArguments }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_WARM: ${{ steps.persistent-store.outputs.warm }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT: ${{ steps.persistent-store.outputs.root }}
      with:
        script: |
          const startedAt = Date.now();
          const executable = process.env.CONFIGURE_NODEJS_INSTALL_EXECUTABLE;
          const args = JSON.parse(process.env.CONFIGURE_NODEJS_INSTALL_ARGUMENTS);
          if (process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE === 'node-modules') {
            const path = require('path');
            const { pathToFileURL } = require('url');
            const { removeMaterializedDependencies } = await import(pathToFileURL(
              path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'completed-tree.mjs'),
            ).href);
            removeMaterializedDependencies(process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY);
          }
          try {
            await exec.exec(executable, args, {
              cwd: process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY,
            });
          } catch (error) {
            // A damaged persistent store must not fail every job until it
            // expires: drop the marker so the next job re-seeds it.
            if (process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_WARM === 'true') {
              const path = require('path');
              const { pathToFileURL } = require('url');
              const { invalidatePersistentStore, persistentStorePaths } = await import(pathToFileURL(
                path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'persistent-store.mjs'),
              ).href);
              invalidatePersistentStore(persistentStorePaths(process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT));
              core.warning('Install failed against the persistent pnpm store; removed its seed marker so the next job re-seeds it.');
            }
            throw error;
          }
          if (process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE === 'node-modules') {
            const path = require('path');
            const { pathToFileURL } = require('url');
            const { completePopulation } = await import(pathToFileURL(
              path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'completed-tree.mjs'),
            ).href);
            completePopulation({
              cwd: process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY,
              repositoryRoot: process.env.GITHUB_WORKSPACE,
              key: process.env.CONFIGURE_NODEJS_CACHE_KEY,
              nodeMajor: process.env.CONFIGURE_NODEJS_NODE_MAJOR,
              nodeABI: process.env.CONFIGURE_NODEJS_NODE_ABI,
              lockfilePath: process.env.CONFIGURE_NODEJS_LOCKFILE_PATH,
              lockfileSha: process.env.CONFIGURE_NODEJS_LOCKFILE_SHA,
              inputsHash: process.env.CONFIGURE_NODEJS_INPUTS_HASH,
              cacheInputs: process.env.CONFIGURE_NODEJS_CACHE_INPUTS,
            });
          }
          core.setOutput('durationMs', Date.now() - startedAt);

    - name: Detect cacheable dependency paths
      id: detect-cache-paths
      if: steps.persistent-store.outputs.warm != 'true' && steps.cache-dependencies.outputs.cache-hit != 'true' && inputs.cache-mode != 'restore'
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_DEPENDENCY_CACHE: ${{ inputs.dependency-cache }}
        CONFIGURE_NODEJS_PACKAGE_MANAGER: ${{ steps.resolve-package-manager.outputs.packageManager }}
        CONFIGURE_NODEJS_ABSOLUTE_PRIMARY_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePrimaryCachePath }}
        CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY: ${{ steps.resolve-cache-paths.outputs.absoluteWorkingDirectory }}
        CONFIGURE_NODEJS_CACHE_ELECTRON: ${{ steps.resolve-dependency-cache-paths.outputs.cacheElectron }}
        CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePrebuildCachePath }}
        CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absoluteElectronCachePath }}
      with:
        script: |
          const path = require('path');
          const { pathToFileURL } = require('url');

          const moduleUrl = pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'detect-cache-paths.mjs'),
          ).href;
          const { hasCacheableDependencyPath } = await import(moduleUrl);
          if (process.env.CONFIGURE_NODEJS_CACHE_ELECTRON === 'true') {
            const cachePathsModuleUrl = pathToFileURL(
              path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'resolve-cache-paths.mjs'),
            ).href;
            const { assertElectronCachePathsSafe } = await import(
              cachePathsModuleUrl
            );
            assertElectronCachePathsSafe({
              cwd: process.env.GITHUB_WORKSPACE,
              absoluteWorkingDirectory:
                process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY,
              absoluteElectronCachePaths: [
                process.env.CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH,
                process.env.CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH,
              ],
            });
          }
          const exists = hasCacheableDependencyPath({
            dependencyCache: process.env.CONFIGURE_NODEJS_DEPENDENCY_CACHE,
            packageManager: process.env.CONFIGURE_NODEJS_PACKAGE_MANAGER,
            absolutePrimaryCachePath:
              process.env.CONFIGURE_NODEJS_ABSOLUTE_PRIMARY_CACHE_PATH,
            absoluteWorkingDirectory:
              process.env.CONFIGURE_NODEJS_ABSOLUTE_WORKING_DIRECTORY,
          });

          core.setOutput('exists', exists);
          core.setOutput('cacheSaveStartedAt', Date.now());

    - name: Save dependencies to cache
      id: save-dependencies
      if: steps.persistent-store.outputs.warm != 'true' && steps.cache-dependencies.outputs.cache-hit != 'true' && inputs.cache-mode != 'restore' && steps.detect-cache-paths.outputs.exists == 'true'
      uses: actions/cache/save@v5
      with:
        path: ${{ steps.resolve-dependency-cache-paths.outputs.cachePaths }}
        key: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}

    # Cold persistent path: the restore, install, and any save above used the
    # workspace paths, so the cache entry stays shared with default-mode jobs.
    # Now move the store and Electron caches out of checkout's reach.
    - name: Seed persistent pnpm store
      id: seed-persistent-store
      if: steps.persistent-store.outputs.enabled == 'true' && steps.persistent-store.outputs.warm != 'true'
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT: ${{ steps.persistent-store.outputs.root }}
        CONFIGURE_NODEJS_PNPM_STORE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePnpmStorePath }}
        CONFIGURE_NODEJS_DISCOVERED_PNPM_STORE_PATH: ${{ steps.prepare-package-manager.outputs.pnpmStorePath }}
        CONFIGURE_NODEJS_CACHE_ELECTRON: ${{ steps.resolve-dependency-cache-paths.outputs.cacheElectron }}
        CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absolutePrebuildCachePath }}
        CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH: ${{ steps.resolve-dependency-cache-paths.outputs.absoluteElectronCachePath }}
      with:
        script: |
          const startedAt = Date.now();
          const path = require('path');
          const { pathToFileURL } = require('url');
          const {
            persistentStorePaths,
            relocateStorePath,
            seedPersistentStore,
          } = await import(pathToFileURL(
            path.join(process.env.GITHUB_ACTION_PATH, 'scripts', 'persistent-store.mjs'),
          ).href);
          const paths = persistentStorePaths(process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_ROOT);
          const cacheElectron = process.env.CONFIGURE_NODEJS_CACHE_ELECTRON === 'true';
          const workspaceStore = process.env.CONFIGURE_NODEJS_PNPM_STORE_PATH;
          const result = seedPersistentStore({
            paths,
            workspaceStore,
            workspaceElectron: cacheElectron ? process.env.CONFIGURE_NODEJS_ABSOLUTE_ELECTRON_CACHE_PATH : '',
            workspacePrebuild: cacheElectron ? process.env.CONFIGURE_NODEJS_ABSOLUTE_PREBUILD_CACHE_PATH : '',
            now: Math.floor(Date.now() / 1000),
          });
          if (!result.seeded) {
            core.warning(`No workspace pnpm store at ${workspaceStore}; the persistent store stays cold.`);
            return;
          }

          // Later steps in this job use the moved store and caches.
          for (const name of ['PNPM_CONFIG_STORE_DIR', 'npm_config_store_dir']) {
            core.exportVariable(name, paths.store);
          }
          if (cacheElectron) {
            core.exportVariable('npm_config_cache', paths.prebuild);
            core.exportVariable('electron_config_cache', paths.electron);
          }
          core.setOutput('pnpmStorePath', relocateStorePath({
            discoveredStorePath: process.env.CONFIGURE_NODEJS_DISCOVERED_PNPM_STORE_PATH,
            workspaceStore,
            persistentStore: paths.store,
          }));
          core.setOutput('durationMs', Date.now() - startedAt);
          core.info(`Seeded the persistent pnpm store at ${paths.store} (moved: ${result.moved.join(', ')}).`);

    # cache/save reports some service failures as warnings. A cold completed
    # producer must not report success unless the consumer's exact entry exists.
    - name: Confirm completed dependency cache was saved
      id: confirm-completed-save
      if: inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'populate' && steps.cache-dependencies.outputs.cache-hit != 'true'
      uses: actions/cache/restore@v5
      with:
        path: ${{ steps.resolve-dependency-cache-paths.outputs.cachePaths }}
        key: ${{ steps.resolve-dependency-cache-paths.outputs.cacheKey }}
        lookup-only: true
        fail-on-cache-miss: true

    - name: Require exact completed save confirmation
      if: inputs.dependency-cache == 'node-modules' && inputs.cache-mode == 'populate' && steps.cache-dependencies.outputs.cache-hit != 'true'
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_CACHE_HIT: ${{ steps.confirm-completed-save.outputs.cache-hit }}
      with:
        script: |
          if (process.env.CONFIGURE_NODEJS_CACHE_HIT !== 'true') {
            throw new Error('Completed dependency cache was not saved under its exact key.');
          }

    - name: Report phase timings
      id: finalize-timings
      if: always()
      uses: actions/github-script@v8
      env:
        CONFIGURE_NODEJS_ACTION_STARTED_AT: ${{ steps.resolve-cache-paths.outputs.actionStartedAt }}
        CONFIGURE_NODEJS_CACHE_RESTORE_DURATION_MS: ${{ steps.cache-restore-timing.outputs.cacheRestoreDurationMs }}
        CONFIGURE_NODEJS_SETUP_NODE_DURATION_MS: ${{ steps.prepare-package-manager.outputs.setupNodeDurationMs }}
        CONFIGURE_NODEJS_FLOATING_SETUP_NODE_DURATION_MS: ${{ steps.resolve-dependency-cache-paths.outputs.floatingSetupNodeDurationMs }}
        CONFIGURE_NODEJS_ACTIVATION_DURATION_MS: ${{ steps.prepare-package-manager.outputs.activationDurationMs }}
        CONFIGURE_NODEJS_STORE_DISCOVERY_DURATION_MS: ${{ steps.prepare-package-manager.outputs.storeDiscoveryDurationMs }}
        CONFIGURE_NODEJS_INSTALL_DURATION_MS: ${{ steps.install-dependencies.outputs.durationMs }}
        CONFIGURE_NODEJS_CACHE_SAVE_STARTED_AT: ${{ steps.detect-cache-paths.outputs.cacheSaveStartedAt }}
        CONFIGURE_NODEJS_CACHE_SAVED: ${{ steps.cache-dependencies.outputs.cache-hit != 'true' && steps.detect-cache-paths.outputs.exists == 'true' }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_ENABLED: ${{ steps.persistent-store.outputs.enabled }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_WARM: ${{ steps.persistent-store.outputs.warm }}
        CONFIGURE_NODEJS_PERSISTENT_STORE_SEED_DURATION_MS: ${{ steps.seed-persistent-store.outputs.durationMs }}
      with:
        script: |
          const numberOrZero = (value) => {
            const parsed = Number.parseInt(value, 10);
            return Number.isFinite(parsed) ? parsed : 0;
          };
          const cacheSaved = process.env.CONFIGURE_NODEJS_CACHE_SAVED === 'true';
          const cacheSaveStartedAt = numberOrZero(
            process.env.CONFIGURE_NODEJS_CACHE_SAVE_STARTED_AT,
          );
          const actionStartedAt = numberOrZero(
            process.env.CONFIGURE_NODEJS_ACTION_STARTED_AT,
          );
          const timings = {
            cacheRestoreDurationMs: numberOrZero(
              process.env.CONFIGURE_NODEJS_CACHE_RESTORE_DURATION_MS,
            ),
            // A floating spec sets up Node before the cache restore, and that
            // path skips the package-manager step entirely on a lookup-only hit.
            setupNodeDurationMs:
              numberOrZero(process.env.CONFIGURE_NODEJS_SETUP_NODE_DURATION_MS) ||
              numberOrZero(
                process.env.CONFIGURE_NODEJS_FLOATING_SETUP_NODE_DURATION_MS,
              ),
            activationDurationMs: numberOrZero(
              process.env.CONFIGURE_NODEJS_ACTIVATION_DURATION_MS,
            ),
            storeDiscoveryDurationMs: numberOrZero(
              process.env.CONFIGURE_NODEJS_STORE_DISCOVERY_DURATION_MS,
            ),
            installDurationMs: numberOrZero(
              process.env.CONFIGURE_NODEJS_INSTALL_DURATION_MS,
            ),
            cacheSaveDurationMs:
              cacheSaved && cacheSaveStartedAt > 0
                ? Date.now() - cacheSaveStartedAt
                : 0,
            totalDurationMs:
              actionStartedAt > 0 ? Date.now() - actionStartedAt : 0,
          };

          for (const [name, value] of Object.entries(timings)) {
            core.setOutput(name, value);
          }

          const persistentStore =
            process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_ENABLED === 'true'
              ? (process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_WARM === 'true' ? 'warm' : 'cold')
              : '';
          const persistentSeedDurationMs = numberOrZero(
            process.env.CONFIGURE_NODEJS_PERSISTENT_STORE_SEED_DURATION_MS,
          );

          core.notice(
            `configure-nodejs timings (ms): ${JSON.stringify(timings)}${persistentStore ? ` persistent store: ${persistentStore}` : ''}`,
          );
          const rows = [
            [
              { data: 'Phase', header: true },
              { data: 'Milliseconds', header: true },
            ],
            ['Cache restore', String(timings.cacheRestoreDurationMs)],
            ['Setup Node.js', String(timings.setupNodeDurationMs)],
            ['Package-manager activation', String(timings.activationDurationMs)],
            ['pnpm store discovery', String(timings.storeDiscoveryDurationMs)],
            ['Dependency install', String(timings.installDurationMs)],
            ['Cache save', String(timings.cacheSaveDurationMs)],
          ];
          if (persistentStore === 'cold') {
            rows.push(['Persistent store seed', String(persistentSeedDurationMs)]);
          }
          rows.push(['Total action', String(timings.totalDurationMs)]);
          const summary = core.summary.addHeading('configure-nodejs phase timings', 3);
          if (persistentStore) {
            summary.addRaw(
              persistentStore === 'warm'
                ? 'Persistent pnpm store was warm; the dependency cache restore was skipped.'
                : 'Persistent pnpm store was cold; restored as usual, then seeded.',
              true,
            );
          }
          await summary.addTable(rows).write();