@invarn/cibuild 2.9.6 → 2.9.8

package/dist/src/yaml/steps/gradle-memory.d.ts

@@ -1,91 +0,0 @@
-/**
- * Gradle's daemon heaps, fitted to the machine the build runs on.
- *
- * A project's `gradle.properties` sizes its heaps for a developer laptop. On a
- * 10 GiB build guest, `org.gradle.jvmargs=-Xmx8G` (which the Kotlin daemon
- * inherits) or `-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g` asks for more
- * than the machine has, and the kernel kills a daemon mid-build. All the log
- * then says is "Gradle build daemon disappeared unexpectedly". IacobIonut01/ReFra
- * and vitorpamplona/amethyst are the two measured cases; ReFra's own CI lowers
- * its heap to 4g before building.
- *
- * Two things, both at run time, in the Gradle project directory:
- *
- *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
- *     daemon and the Kotlin daemon. When their sum is past
- *     `GRADLE_HEAP_SHARE_PERCENT` of memory, run one heap instead: the Gradle
- *     daemon gets the whole budget (`-Dorg.gradle.jvmargs=`) and Kotlin
- *     compiles in it (`-Pkotlin.compiler.execution.strategy=in-process`). One
- *     line names the old values and the new. Two heaps did not fit: halved,
- *     ReFra's Kotlin compile ran out of heap; split 60/40, its Kotlin daemon
- *     was lost mid-compile, and mifos-mobile's Gradle daemon ran out of its
- *     40 % on a 6 GiB guest.
- *  2. **Say so.** When a Gradle run exits 137, its output says the daemon
- *     disappeared, or the Kotlin daemon was lost mid-compile, print the
- *     kernel's out-of-memory lines and one sentence with the machine's memory
- *     and what the build asked for.
- *  3. **Workers.** A heap cap does not bound what runs beside the heaps:
- *     off-heap memory, and native compilers run in parallel. IacobIonut01/ReFra
- *     was killed again at a capped -Xmx3712m, one JVM holding ~5.1 GiB
- *     resident; its own CI also sets `org.gradle.workers.max=2`. A pipeline
- *     may ask for a worker count, passed as `--max-workers=<n>`.
- *
- * Precedence, measured with Gradle 8.14.3 and 9.5.0 (daemon and --no-daemon):
- * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
- * home's and the project's `gradle.properties` for the daemon's heap, and
- * `-P` beats `gradle.properties` for a Gradle property, which is how the
- * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs` and
- * `kotlin.compiler.execution.strategy`: with
- * `-Pkotlin.compiler.execution.strategy=in-process`, no Kotlin daemon starts
- * even where the project's file says `daemon`. `--max-workers` beats
- * `org.gradle.workers.max` in both files (`gradle.startParameter.maxWorkerCount`).
- * `GRADLE_OPTS` is not used: it sizes the client JVM, not the daemon.
- *
- * Written as shell functions so what ships is what the tests run. Its lines
- * start with "Gradle memory:", never with a step-progress marker.
- */
-/** The share of the machine's memory the two daemon heaps may take together. */
-export declare const GRADLE_HEAP_SHARE_PERCENT = 75;
-/**
- * Sends a Kotlin Multiplatform project's metadata compiles
- * (compile*KotlinMetadata, the KotlinCompileCommon tasks) to the Kotlin daemon
- * while every other Kotlin compile stays in-process. With
- * -Pkotlin.compiler.execution.strategy=in-process, Kotlin 2.2.0 compiled
- * DroidKaigi/conference-app-2025's common metadata in K1 mode and rejected its
- * context parameters; the same task on the daemon passed (nightly-baseline 95).
- *
- * The Kotlin plugin's classes are not on an init script's classpath, so the
- * task is matched by class name and the strategy enum is loaded through the
- * task's own classloader. A Kotlin plugin without the property (older than the
- * strategy API) is left alone: this script must never fail a build. Lazy
- * (configureEach where Gradle has it), so it is configuration-cache safe and
- * realizes no task. It runs once per build, included builds as well; they
- * have no metadata compiles to touch.
- */
-export declare const KOTLIN_METADATA_DAEMON_INIT_SCRIPT = "// cibuild: Kotlin metadata compiles run in the Kotlin daemon (nightly-baseline 95).\nallprojects {\n  def hook = { t ->\n    if (!t.class.name.startsWith('org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon')) return\n    try {\n      def strategy = t.class.classLoader.loadClass('org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy')\n      t.compilerExecutionStrategy.set(strategy.enumConstants.find { it.name() == 'DAEMON' })\n    } catch (Throwable ignored) {\n    }\n  }\n  try {\n    tasks.configureEach(hook)\n  } catch (MissingMethodException ignored) {\n    tasks.all(hook)\n  }\n}\n";
-export declare const GRADLE_MEMORY_FUNCTIONS = "# This machine's memory in MiB, or nothing when it cannot be read.\ncibuild_mem_mib() {\n  if [ -r /proc/meminfo ]; then\n    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo\n  else\n    local bytes\n    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)\n    if [ -n \"$bytes\" ]; then echo $(( bytes / 1048576 )); fi\n  fi\n}\n\n# $1 a .properties file, $2 a key. Prints \"<line number><TAB><value>\" for the\n# last assignment of the key, or nothing.\ncibuild_prop_line() {\n  [ -f \"$1\" ] || return 0\n  awk -v key=\"$2\" '\n    { line = $0; sub(/^[ \\t]+/, \"\", line) }\n    line ~ /^[#!]/ { next }\n    {\n      k = line; sub(/[ \\t]*[=:].*$/, \"\", k)\n      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, \"\", v); sub(/[ \\t\\r]+$/, \"\", v); found = NR \"\\t\" v }\n    }\n    END { if (found != \"\") print found }\n  ' \"$1\"\n}\n\n# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),\n# or nothing when it has none.\ncibuild_xmx_mib() {\n  printf '%s\\n' \"$1\" | tr ' \\t' '\\n\\n' | awk '\n    /^-Xmx[0-9]+[kKmMgGtT]?$/ {\n      n = substr($0, 5); u = substr(n, length(n))\n      if (u ~ /[0-9]/) { v = n / 1048576 }\n      else {\n        n = substr(n, 1, length(n) - 1)\n        if (u ~ /[kK]/) v = n / 1024\n        else if (u ~ /[mM]/) v = n\n        else if (u ~ /[gG]/) v = n * 1024\n        else v = n * 1048576\n      }\n      r = int(v)\n    }\n    END { if (r != \"\") print r }'\n}\n\n# The -XX:MaxMetaspaceSize of a JVM argument string in MiB (the last one\n# wins), or nothing when it has none.\ncibuild_metaspace_mib() {\n  printf '%s\\n' \"$1\" | tr ' \\t,' '\\n\\n\\n' | awk '\n    /^-XX:MaxMetaspaceSize=[0-9]+[kKmMgGtT]?$/ {\n      n = substr($0, 22); u = substr(n, length(n))\n      if (u ~ /[0-9]/) { v = n / 1048576 }\n      else {\n        n = substr(n, 1, length(n) - 1)\n        if (u ~ /[kK]/) v = n / 1024\n        else if (u ~ /[mM]/) v = n\n        else if (u ~ /[gG]/) v = n * 1024\n        else v = n * 1048576\n      }\n      r = int(v)\n    }\n    END { if (r != \"\") print r }'\n}\n\n# $1 a JVM argument string, $2 a size in MiB: the same arguments with every\n# -XX:MaxMetaspaceSize replaced by that one.\ncibuild_with_metaspace() (\n  set -f\n  out=\"\"\n  replaced=0\n  for arg in $1; do\n    case \"$arg\" in\n      -XX:MaxMetaspaceSize=*) if [ \"$replaced\" -eq 0 ]; then out=\"$out -XX:MaxMetaspaceSize=${2}m\"; replaced=1; fi ;;\n      *) out=\"$out $arg\" ;;\n    esac\n  done\n  printf '%s' \"${out# }\"\n)\n\n# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every\n# -Xmx replaced by that one (added in front when there was none).\ncibuild_with_xmx() (\n  set -f\n  out=\"\"\n  replaced=0\n  for arg in $1; do\n    case \"$arg\" in\n      -Xmx*) if [ \"$replaced\" -eq 0 ]; then out=\"$out -Xmx${2}m\"; replaced=1; fi ;;\n      *) out=\"$out $arg\" ;;\n    esac\n  done\n  [ \"$replaced\" -eq 1 ] || out=\" -Xmx${2}m$out\"\n  printf '%s' \"${out# }\"\n)\n\n# MiB as GiB with one decimal.\ncibuild_gib() {\n  awk -v m=\"$1\" 'BEGIN { printf \"%.1f\", m / 1024 }'\n}\n\n# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.\ncibuild_scaled_heap() {\n  local v=$(( $1 * $2 / $3 / 64 * 64 ))\n  [ \"$v\" -ge 512 ] || v=512\n  echo \"$v\"\n}\n\n# The Kotlin daemon heap a multiplatform project's metadata compiles get out\n# of a budget in MiB: an eighth, rounded down to 64 MiB, from 512 MiB to 1 GiB.\ncibuild_metadata_daemon_heap() {\n  local v=$(( $1 / 8 / 64 * 64 ))\n  [ \"$v\" -ge 512 ] || v=512\n  [ \"$v\" -le 1024 ] || v=1024\n  echo \"$v\"\n}\n\n# Whether the Gradle project here applies Kotlin Multiplatform: a build script\n# or version catalog that names the plugin. Convention plugins in buildSrc or\n# an included build sit a few directories down; build outputs are not read.\ncibuild_applies_kotlin_multiplatform() {\n  local f\n  while IFS= read -r -d '' f; do\n    if grep -q -E 'kotlin\\(\"multiplatform\"\\)|org\\.jetbrains\\.kotlin\\.multiplatform|kotlin-multiplatform|kotlinMultiplatform' \"$f\" 2>/dev/null; then return 0; fi\n  done < <(find . -maxdepth 6 \\( -name .git -o -name node_modules -o -name build -o -name .gradle \\) -prune -o -type f \\( -name '*.gradle' -o -name '*.gradle.kts' -o -name '*.versions.toml' \\) -print0 2>/dev/null)\n  return 1\n}\n\n# The plan, from its inputs only, so a test can run it:\n#   $1 this machine's memory in MiB (empty when unknown)\n#   $2 the project's gradle.properties   $3 the Gradle user home's\n#   $4 JVM arguments the pipeline asks for instead (may be empty)\n#   $5 the metadata init script, when the project applies Kotlin\n#      Multiplatform (empty otherwise)\n# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),\n# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when\n# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a\n# daemon is killed).\n#\n# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's\n# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of\n# its own inherits the Gradle daemon's, and in-process compilation has no\n# Kotlin daemon at all.\ncibuild_gradle_memory_plan() {\n  local mem=\"$1\" project=\"$2\" user=\"$3\" preferred=\"$4\" init=\"${5:-}\" l\n  local jvm=\"\" jvm_at=\"\" kd=\"\" kd_at=\"\" strategy=\"\"\n  CIBUILD_GRADLE_MEMORY_ARGS=()\n  CIBUILD_GRADLE_MEMORY_LINE=\"\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"\"\n\n  if [ -n \"$preferred\" ]; then jvm=\"$preferred\"; jvm_at=\"the pipeline\"; fi\n  for f in \"$user\" \"$project\"; do\n    if [ -z \"$jvm_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" org.gradle.jvmargs)\n      if [ -n \"$l\" ]; then jvm=\"${l#*\t}\"; jvm_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$kd_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.daemon.jvmargs)\n      if [ -n \"$l\" ]; then kd=\"${l#*\t}\"; kd_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$strategy\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.compiler.execution.strategy)\n      strategy=\"${l#*\t}\"\n    fi\n  done\n\n  local g k kd_own=\"\"\n  g=$(cibuild_xmx_mib \"$jvm\")\n  [ -n \"$g\" ] || g=512\n  if [ \"$strategy\" = \"in-process\" ]; then\n    k=0\n  else\n    kd_own=$(cibuild_xmx_mib \"$kd\")\n    k=\"${kd_own:-$g}\"\n  fi\n  local total=$(( g + k ))\n\n  local asked\n  if [ -n \"$jvm_at\" ]; then asked=\"org.gradle.jvmargs=$jvm at ${jvm_at}\"; else asked=\"Gradle's default -Xmx512m\"; fi\n  if [ \"$k\" -eq 0 ]; then\n    asked=\"$asked; Kotlin compiles in-process\"\n  elif [ -n \"$kd_own\" ]; then\n    asked=\"$asked, kotlin.daemon.jvmargs=$kd at ${kd_at}\"\n  else\n    asked=\"$asked; the Kotlin daemon inherits its -Xmx\"\n  fi\n\n  if [ -z \"$mem\" ]; then\n    CIBUILD_GRADLE_MEMORY_SENTENCE=\"This build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked); this machine's memory could not be read.\"\n    if [ -n \"$preferred\" ]; then CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\"); fi\n    return 0\n  fi\n\n  local budget=$(( mem * 75 / 100 ))\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"The build machine has $(cibuild_gib \"$mem\") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked).\"\n\n  if [ \"$total\" -le \"$budget\" ]; then\n    if [ -n \"$preferred\" ]; then\n      CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\")\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line).\"\n    fi\n    return 0\n  fi\n\n  case \"$jvm\" in\n    *\\\\)\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: the declared heaps ask for $(cibuild_gib \"$total\") GiB of this machine's $(cibuild_gib \"$mem\") GiB, but org.gradle.jvmargs at ${jvm_at} continues onto another line, so it is left as it is.\"\n      return 0\n      ;;\n  esac\n\n  # One heap, the whole budget. Two did not fit: ReFra's Kotlin daemon was\n  # lost mid-compile at a 60/40 split, and mifos-mobile's Gradle daemon ran out\n  # of its 40 %. In-process, Kotlin compiles in the Gradle daemon's heap.\n  # A multiplatform project's metadata compiles are the exception: they go to\n  # a small Kotlin daemon (the init script), carved out of the same budget.\n  local ng now newjvm mg mk md=\"\"\n  if [ \"$k\" -gt 0 ] && [ -n \"$init\" ]; then md=$(cibuild_metadata_daemon_heap \"$budget\"); fi\n  ng=$(cibuild_scaled_heap $(( budget - ${md:-0} )) 1 1)\n  newjvm=$(cibuild_with_xmx \"$jvm\" \"$ng\")\n  now=\"Gradle -Xmx${ng}m\"\n  if [ \"$k\" -gt 0 ]; then\n    # One JVM now holds what two did, so a Metaspace cap Gradle declared must\n    # hold Kotlin's too: the Kotlin daemon's own (kotlin.daemon.jvmargs, or\n    # -Dkotlin.daemon.jvm.options in Gradle's), else the Gradle one it\n    # inherits. GetStream/whatsApp-clone-compose capped Gradle at 512m and gave\n    # Kotlin 1g, and in-process compileDebugKotlin ran out of Metaspace\n    # (nightly-baseline 79). No Gradle cap, nothing to raise.\n    mg=$(cibuild_metaspace_mib \"$jvm\")\n    if [ -n \"$mg\" ]; then\n      mk=$(cibuild_metaspace_mib \"$kd\")\n      [ -n \"$mk\" ] || mk=$(cibuild_metaspace_mib \"$(printf '%s\\n' \"$jvm\" | tr ' \\t' '\\n\\n' | sed -n 's/^-Dkotlin\\.daemon\\.jvm\\.options=//p')\")\n      [ -n \"$mk\" ] || mk=\"$mg\"\n      newjvm=$(cibuild_with_metaspace \"$newjvm\" $(( mg + mk )))\n      now=\"$now with -XX:MaxMetaspaceSize=$(( mg + mk ))m (Gradle's ${mg}m and Kotlin's ${mk}m, in one JVM now)\"\n    fi\n    now=\"$now and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon)\"\n  fi\n  if [ -n \"$md\" ]; then\n    now=\"$now, and Kotlin metadata compiles (compile*KotlinMetadata) in a Kotlin daemon of -Xmx${md}m beside it (in-process, Kotlin 2.2 compiled them in K1 mode)\"\n  fi\n  CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$newjvm\")\n  if [ \"$k\" -gt 0 ]; then\n    CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Pkotlin.compiler.execution.strategy=in-process\")\n  fi\n  if [ -n \"$md\" ]; then\n    CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Pkotlin.daemon.jvmargs=-Xmx${md}m\" --init-script \"$init\")\n  fi\n  CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: this machine has $(cibuild_gib \"$mem\") GiB and the declared heaps ask for $(cibuild_gib \"$total\") GiB ($asked), past the $(cibuild_gib \"$budget\") GiB this build allows them. Running with $now, set on the command line.\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now.\"\n}\n\n# $1 the project's gradle.properties, $2 the Gradle user home's. A JDK path the\n# project pins with org.gradle.java.home that is not on this machine \u2014 a\n# developer's own, like SEAbdulbasit/MusicApp-KMP's\n# /Users/abdulbasit/Library/Java/... (nightly-baseline 83) \u2014 stops Gradle\n# before it starts: \"given for org.gradle.java.home Gradle property is\n# invalid\". On the command line, -Dorg.gradle.java.home beats both files\n# (measured, Gradle 8.14.3), so the build's own JDK is passed instead. A path\n# that exists is left alone. Sets CIBUILD_GRADLE_JAVA_HOME_LINE.\ncibuild_gradle_java_home_plan() {\n  local l v=\"\" at=\"\"\n  CIBUILD_GRADLE_JAVA_HOME_LINE=\"\"\n  for f in \"$2\" \"$1\"; do\n    l=$(cibuild_prop_line \"$f\" org.gradle.java.home)\n    if [ -n \"$l\" ]; then v=\"${l#*\t}\"; at=\"$f:${l%%\t*}\"; break; fi\n  done\n  [ -n \"$v\" ] || return 0\n  [ -d \"$v\" ] && return 0\n  [ -n \"${JAVA_HOME:-}\" ] && [ -d \"$JAVA_HOME\" ] || return 0\n  CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Dorg.gradle.java.home=$JAVA_HOME\")\n  CIBUILD_GRADLE_JAVA_HOME_LINE=\"Gradle: org.gradle.java.home=$v at $at is not on this machine; running with this build's JDK, $JAVA_HOME (-Dorg.gradle.java.home on the command line).\"\n}\n\n# $1 the number of Gradle workers the pipeline asks for (may be empty). Adds\n# --max-workers to the plan's arguments; run after cibuild_gradle_memory_plan.\n# Sets CIBUILD_GRADLE_WORKERS_LINE (what to print; empty when nothing asked).\ncibuild_gradle_workers_plan() {\n  CIBUILD_GRADLE_WORKERS_LINE=\"\"\n  [ -n \"$1\" ] || return 0\n  case \"$1\" in\n    *[!0-9]*|0*)\n      CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: max_workers=$1 is not a positive whole number, so it is not passed and Gradle picks its own worker count.\"\n      return 0\n      ;;\n  esac\n  CIBUILD_GRADLE_MEMORY_ARGS+=(\"--max-workers=$1\")\n  CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: running with --max-workers=$1, as the pipeline asks (set on the command line, over any org.gradle.workers.max).\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE Gradle ran with --max-workers=$1.\"\n}\n\n# The kernel's out-of-memory lines, if this user may read the kernel log.\n# Linux guests restrict dmesg to root by default; their build user has\n# non-interactive sudo, so that is the second try.\ncibuild_kernel_oom_lines() {\n  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |\n    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true\n}\n\n# $1 Gradle's exit status, $2 a file holding its output. Says so when the\n# failure is a killed daemon rather than a failed build.\ncibuild_gradle_memory_report() {\n  local kotlin_lost=\"\"\n  if grep -q \"Connection to the Kotlin daemon has been unexpectedly lost\" \"$2\" 2>/dev/null; then kotlin_lost=1; fi\n  if [ \"$1\" -ne 137 ] && [ -z \"$kotlin_lost\" ] && ! grep -q \"daemon disappeared unexpectedly\" \"$2\" 2>/dev/null; then\n    return 0\n  fi\n  local oom\n  oom=$(cibuild_kernel_oom_lines)\n  echo \"\"\n  if [ -n \"$kotlin_lost\" ]; then\n    echo \"Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit $1). Kotlin then compiled without it, in the Gradle daemon's heap.\"\n  else\n    echo \"Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1).\"\n  fi\n  if [ -n \"$oom\" ]; then\n    echo \"The kernel's out-of-memory lines:\"\n    printf '%s\\n' \"$oom\" | sed 's/^/    /'\n  else\n    echo \"The kernel log shows no out-of-memory kill, or this machine does not let the build read it.\"\n  fi\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_SENTENCE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_SENTENCE\"; fi\n}\n\n# Runs Gradle with the plan's arguments, and reports a killed daemon.\ncibuild_gradle() {\n  local log rc\n  log=$(mktemp)\n  set +e\n  \"$CIBUILD_GRADLE_BIN\" \"${CIBUILD_GRADLE_MEMORY_ARGS[@]}\" \"$@\" 2>&1 | tee \"$log\"\n  rc=${PIPESTATUS[0]}\n  set -e\n  if [ \"$rc\" -ne 0 ]; then cibuild_gradle_memory_report \"$rc\" \"$log\" || true; fi\n  rm -f \"$log\"\n  return \"$rc\"\n}\n\n# $1 JVM arguments the pipeline asks for, $2 the Gradle workers it asks for\n# (either may be empty). Run in the Gradle project directory, after GRADLE_CMD\n# is chosen.\ncibuild_gradle_memory_cap() {\n  local metadata_init=\"\"\n  if cibuild_applies_kotlin_multiplatform; then\n    metadata_init=\"$(mktemp -d)/cibuild-kotlin-metadata-daemon.init.gradle\"\n    cat > \"$metadata_init\" <<'CIBUILD_KOTLIN_METADATA_INIT'\n// cibuild: Kotlin metadata compiles run in the Kotlin daemon (nightly-baseline 95).\nallprojects {\n  def hook = { t ->\n    if (!t.class.name.startsWith('org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon')) return\n    try {\n      def strategy = t.class.classLoader.loadClass('org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy')\n      t.compilerExecutionStrategy.set(strategy.enumConstants.find { it.name() == 'DAEMON' })\n    } catch (Throwable ignored) {\n    }\n  }\n  try {\n    tasks.configureEach(hook)\n  } catch (MissingMethodException ignored) {\n    tasks.all(hook)\n  }\n}\nCIBUILD_KOTLIN_METADATA_INIT\n  fi\n  cibuild_gradle_memory_plan \"$(cibuild_mem_mib || true)\" \"gradle.properties\" \\\n    \"${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties\" \"$1\" \"$metadata_init\"\n  cibuild_gradle_workers_plan \"$2\"\n  cibuild_gradle_java_home_plan \"gradle.properties\" \"${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties\"\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_LINE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_LINE\"; fi\n  if [ -n \"$CIBUILD_GRADLE_WORKERS_LINE\" ]; then echo \"$CIBUILD_GRADLE_WORKERS_LINE\"; fi\n  if [ -n \"$CIBUILD_GRADLE_JAVA_HOME_LINE\" ]; then echo \"$CIBUILD_GRADLE_JAVA_HOME_LINE\"; fi\n  CIBUILD_GRADLE_BIN=\"$GRADLE_CMD\"\n  GRADLE_CMD=cibuild_gradle\n}";
-/**
- * The commands a Gradle step runs once it has chosen `GRADLE_CMD` and is in
- * the project directory. Afterwards `$GRADLE_CMD` runs Gradle with the plan's
- * arguments and reports a killed daemon.
- *
- * `jvmargs` is what the pipeline asks for instead of the project's
- * `org.gradle.jvmargs` (a value the repository's own CI sets, say); the cap
- * still applies to it. `maxWorkers` is the worker count it asks for (the
- * repository CI's `org.gradle.workers.max`), passed as `--max-workers`.
- */
-export declare function gradleMemoryCommands(jvmargs: string, escape: (value: string) => string, maxWorkers?: string): string[];
-/**
- * A pinned org.gradle.java.home that is not on this machine, made to name the
- * build's JDK for every Gradle run in the build. The Gradle steps already pass
- * -Dorg.gradle.java.home on their own command line; a script step's
- * ./gradlew and a build phase Xcode runs do not, and they read the checkout's
- * gradle.properties. SEAbdulbasit/MusicApp-KMP's Android step went on with the
- * override and its KMM "Prepare the iOS build" script stopped on the same
- * "given for org.gradle.java.home Gradle property is invalid"
- * (nightly-baseline 92). So the line itself is rewritten, in every
- * gradle.properties of the checkout, once the build's JDK is chosen. A path
- * that exists, an empty value or a commented-out line is left alone.
- */
-export declare const GRADLE_JAVA_HOME_PIN_FUNCTIONS = "# $1 a .properties file, $2 a key. Prints \"<line number><TAB><value>\" for the\n# last assignment of the key, or nothing.\ncibuild_prop_line() {\n  [ -f \"$1\" ] || return 0\n  awk -v key=\"$2\" '\n    { line = $0; sub(/^[ \\t]+/, \"\", line) }\n    line ~ /^[#!]/ { next }\n    {\n      k = line; sub(/[ \\t]*[=:].*$/, \"\", k)\n      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, \"\", v); sub(/[ \\t\\r]+$/, \"\", v); found = NR \"\\t\" v }\n    }\n    END { if (found != \"\") print found }\n  ' \"$1\"\n}\n\n# Run once JAVA_HOME is the build's JDK. Searches the checkout\n# (CIBUILD_SOURCE_DIR, else the current directory) to the depth a nested\n# Gradle project sits at, and prints one line per file it rewrites.\ncibuild_gradle_java_home_pin() {\n  [ -n \"${JAVA_HOME:-}\" ] && [ -d \"$JAVA_HOME\" ] || return 0\n  local root f l v tmp\n  root=\"${CIBUILD_SOURCE_DIR:-.}\"\n  while IFS= read -r f; do\n    l=$(cibuild_prop_line \"$f\" org.gradle.java.home)\n    [ -n \"$l\" ] || continue\n    v=\"${l#*\t}\"\n    [ -n \"$v\" ] || continue\n    [ -d \"$v\" ] && continue\n    tmp=$(mktemp)\n    awk -v key=org.gradle.java.home -v home=\"$JAVA_HOME\" '\n      { line = $0; sub(/^[ \\t]+/, \"\", line) }\n      line !~ /^[#!]/ { k = line; sub(/[ \\t]*[=:].*$/, \"\", k); if (k == key) { print key \"=\" home; next } }\n      { print }\n    ' \"$f\" > \"$tmp\" && cat \"$tmp\" > \"$f\"\n    rm -f \"$tmp\"\n    echo \"Gradle: org.gradle.java.home=$v at ${f#\"$root\"/}:${l%%\t*} is not on this machine; that line now names this build's JDK, $JAVA_HOME, so every Gradle run in this build uses it (a script's ./gradlew and Xcode's build phases as well as the Gradle steps).\"\n  done < <(find \"$root\" -maxdepth 4 \\( -name .git -o -name node_modules -o -name build -o -name .gradle \\) -prune -o -type f -name gradle.properties -print 2>/dev/null)\n}";
-//# sourceMappingURL=gradle-memory.d.ts.map

package/dist/src/yaml/steps/gradle-memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradle-memory.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAmB5C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kCAAkC,smBAgB9C,CAAC;AAEF,eAAO,MAAM,uBAAuB,gjgBAsVlC,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACjC,UAAU,SAAK,GACd,MAAM,EAAE,CAOV;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,y0DAwBzC,CAAC"}

package/dist/src/yaml/steps/gradle-memory.js

@@ -1,495 +0,0 @@
-/**
- * Gradle's daemon heaps, fitted to the machine the build runs on.
- *
- * A project's `gradle.properties` sizes its heaps for a developer laptop. On a
- * 10 GiB build guest, `org.gradle.jvmargs=-Xmx8G` (which the Kotlin daemon
- * inherits) or `-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g` asks for more
- * than the machine has, and the kernel kills a daemon mid-build. All the log
- * then says is "Gradle build daemon disappeared unexpectedly". IacobIonut01/ReFra
- * and vitorpamplona/amethyst are the two measured cases; ReFra's own CI lowers
- * its heap to 4g before building.
- *
- * Two things, both at run time, in the Gradle project directory:
- *
- *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
- *     daemon and the Kotlin daemon. When their sum is past
- *     `GRADLE_HEAP_SHARE_PERCENT` of memory, run one heap instead: the Gradle
- *     daemon gets the whole budget (`-Dorg.gradle.jvmargs=`) and Kotlin
- *     compiles in it (`-Pkotlin.compiler.execution.strategy=in-process`). One
- *     line names the old values and the new. Two heaps did not fit: halved,
- *     ReFra's Kotlin compile ran out of heap; split 60/40, its Kotlin daemon
- *     was lost mid-compile, and mifos-mobile's Gradle daemon ran out of its
- *     40 % on a 6 GiB guest.
- *  2. **Say so.** When a Gradle run exits 137, its output says the daemon
- *     disappeared, or the Kotlin daemon was lost mid-compile, print the
- *     kernel's out-of-memory lines and one sentence with the machine's memory
- *     and what the build asked for.
- *  3. **Workers.** A heap cap does not bound what runs beside the heaps:
- *     off-heap memory, and native compilers run in parallel. IacobIonut01/ReFra
- *     was killed again at a capped -Xmx3712m, one JVM holding ~5.1 GiB
- *     resident; its own CI also sets `org.gradle.workers.max=2`. A pipeline
- *     may ask for a worker count, passed as `--max-workers=<n>`.
- *
- * Precedence, measured with Gradle 8.14.3 and 9.5.0 (daemon and --no-daemon):
- * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
- * home's and the project's `gradle.properties` for the daemon's heap, and
- * `-P` beats `gradle.properties` for a Gradle property, which is how the
- * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs` and
- * `kotlin.compiler.execution.strategy`: with
- * `-Pkotlin.compiler.execution.strategy=in-process`, no Kotlin daemon starts
- * even where the project's file says `daemon`. `--max-workers` beats
- * `org.gradle.workers.max` in both files (`gradle.startParameter.maxWorkerCount`).
- * `GRADLE_OPTS` is not used: it sizes the client JVM, not the daemon.
- *
- * Written as shell functions so what ships is what the tests run. Its lines
- * start with "Gradle memory:", never with a step-progress marker.
- */
-/** The share of the machine's memory the two daemon heaps may take together. */
-export const GRADLE_HEAP_SHARE_PERCENT = 75;
-/** Reads one key of a .properties file, as Java does: the last assignment wins. */
-const GRADLE_PROP_LINE_FUNCTION = `# $1 a .properties file, $2 a key. Prints "<line number><TAB><value>" for the
-# last assignment of the key, or nothing.
-cibuild_prop_line() {
-  [ -f "$1" ] || return 0
-  awk -v key="$2" '
-    { line = $0; sub(/^[ \\t]+/, "", line) }
-    line ~ /^[#!]/ { next }
-    {
-      k = line; sub(/[ \\t]*[=:].*$/, "", k)
-      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, "", v); sub(/[ \\t\\r]+$/, "", v); found = NR "\\t" v }
-    }
-    END { if (found != "") print found }
-  ' "$1"
-}`;
-/**
- * Sends a Kotlin Multiplatform project's metadata compiles
- * (compile*KotlinMetadata, the KotlinCompileCommon tasks) to the Kotlin daemon
- * while every other Kotlin compile stays in-process. With
- * -Pkotlin.compiler.execution.strategy=in-process, Kotlin 2.2.0 compiled
- * DroidKaigi/conference-app-2025's common metadata in K1 mode and rejected its
- * context parameters; the same task on the daemon passed (nightly-baseline 95).
- *
- * The Kotlin plugin's classes are not on an init script's classpath, so the
- * task is matched by class name and the strategy enum is loaded through the
- * task's own classloader. A Kotlin plugin without the property (older than the
- * strategy API) is left alone: this script must never fail a build. Lazy
- * (configureEach where Gradle has it), so it is configuration-cache safe and
- * realizes no task. It runs once per build, included builds as well; they
- * have no metadata compiles to touch.
- */
-export const KOTLIN_METADATA_DAEMON_INIT_SCRIPT = `// cibuild: Kotlin metadata compiles run in the Kotlin daemon (nightly-baseline 95).
-allprojects {
-  def hook = { t ->
-    if (!t.class.name.startsWith('org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon')) return
-    try {
-      def strategy = t.class.classLoader.loadClass('org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy')
-      t.compilerExecutionStrategy.set(strategy.enumConstants.find { it.name() == 'DAEMON' })
-    } catch (Throwable ignored) {
-    }
-  }
-  try {
-    tasks.configureEach(hook)
-  } catch (MissingMethodException ignored) {
-    tasks.all(hook)
-  }
-}
-`;
-export const GRADLE_MEMORY_FUNCTIONS = `# This machine's memory in MiB, or nothing when it cannot be read.
-cibuild_mem_mib() {
-  if [ -r /proc/meminfo ]; then
-    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo
-  else
-    local bytes
-    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)
-    if [ -n "$bytes" ]; then echo $(( bytes / 1048576 )); fi
-  fi
-}
-
-${GRADLE_PROP_LINE_FUNCTION}
-
-# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),
-# or nothing when it has none.
-cibuild_xmx_mib() {
-  printf '%s\\n' "$1" | tr ' \\t' '\\n\\n' | awk '
-    /^-Xmx[0-9]+[kKmMgGtT]?$/ {
-      n = substr($0, 5); u = substr(n, length(n))
-      if (u ~ /[0-9]/) { v = n / 1048576 }
-      else {
-        n = substr(n, 1, length(n) - 1)
-        if (u ~ /[kK]/) v = n / 1024
-        else if (u ~ /[mM]/) v = n
-        else if (u ~ /[gG]/) v = n * 1024
-        else v = n * 1048576
-      }
-      r = int(v)
-    }
-    END { if (r != "") print r }'
-}
-
-# The -XX:MaxMetaspaceSize of a JVM argument string in MiB (the last one
-# wins), or nothing when it has none.
-cibuild_metaspace_mib() {
-  printf '%s\\n' "$1" | tr ' \\t,' '\\n\\n\\n' | awk '
-    /^-XX:MaxMetaspaceSize=[0-9]+[kKmMgGtT]?$/ {
-      n = substr($0, 22); u = substr(n, length(n))
-      if (u ~ /[0-9]/) { v = n / 1048576 }
-      else {
-        n = substr(n, 1, length(n) - 1)
-        if (u ~ /[kK]/) v = n / 1024
-        else if (u ~ /[mM]/) v = n
-        else if (u ~ /[gG]/) v = n * 1024
-        else v = n * 1048576
-      }
-      r = int(v)
-    }
-    END { if (r != "") print r }'
-}
-
-# $1 a JVM argument string, $2 a size in MiB: the same arguments with every
-# -XX:MaxMetaspaceSize replaced by that one.
-cibuild_with_metaspace() (
-  set -f
-  out=""
-  replaced=0
-  for arg in $1; do
-    case "$arg" in
-      -XX:MaxMetaspaceSize=*) if [ "$replaced" -eq 0 ]; then out="$out -XX:MaxMetaspaceSize=\${2}m"; replaced=1; fi ;;
-      *) out="$out $arg" ;;
-    esac
-  done
-  printf '%s' "\${out# }"
-)
-
-# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every
-# -Xmx replaced by that one (added in front when there was none).
-cibuild_with_xmx() (
-  set -f
-  out=""
-  replaced=0
-  for arg in $1; do
-    case "$arg" in
-      -Xmx*) if [ "$replaced" -eq 0 ]; then out="$out -Xmx\${2}m"; replaced=1; fi ;;
-      *) out="$out $arg" ;;
-    esac
-  done
-  [ "$replaced" -eq 1 ] || out=" -Xmx\${2}m$out"
-  printf '%s' "\${out# }"
-)
-
-# MiB as GiB with one decimal.
-cibuild_gib() {
-  awk -v m="$1" 'BEGIN { printf "%.1f", m / 1024 }'
-}
-
-# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.
-cibuild_scaled_heap() {
-  local v=$(( $1 * $2 / $3 / 64 * 64 ))
-  [ "$v" -ge 512 ] || v=512
-  echo "$v"
-}
-
-# The Kotlin daemon heap a multiplatform project's metadata compiles get out
-# of a budget in MiB: an eighth, rounded down to 64 MiB, from 512 MiB to 1 GiB.
-cibuild_metadata_daemon_heap() {
-  local v=$(( $1 / 8 / 64 * 64 ))
-  [ "$v" -ge 512 ] || v=512
-  [ "$v" -le 1024 ] || v=1024
-  echo "$v"
-}
-
-# Whether the Gradle project here applies Kotlin Multiplatform: a build script
-# or version catalog that names the plugin. Convention plugins in buildSrc or
-# an included build sit a few directories down; build outputs are not read.
-cibuild_applies_kotlin_multiplatform() {
-  local f
-  while IFS= read -r -d '' f; do
-    if grep -q -E 'kotlin\\("multiplatform"\\)|org\\.jetbrains\\.kotlin\\.multiplatform|kotlin-multiplatform|kotlinMultiplatform' "$f" 2>/dev/null; then return 0; fi
-  done < <(find . -maxdepth 6 \\( -name .git -o -name node_modules -o -name build -o -name .gradle \\) -prune -o -type f \\( -name '*.gradle' -o -name '*.gradle.kts' -o -name '*.versions.toml' \\) -print0 2>/dev/null)
-  return 1
-}
-
-# The plan, from its inputs only, so a test can run it:
-#   $1 this machine's memory in MiB (empty when unknown)
-#   $2 the project's gradle.properties   $3 the Gradle user home's
-#   $4 JVM arguments the pipeline asks for instead (may be empty)
-#   $5 the metadata init script, when the project applies Kotlin
-#      Multiplatform (empty otherwise)
-# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),
-# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when
-# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a
-# daemon is killed).
-#
-# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's
-# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of
-# its own inherits the Gradle daemon's, and in-process compilation has no
-# Kotlin daemon at all.
-cibuild_gradle_memory_plan() {
-  local mem="$1" project="$2" user="$3" preferred="$4" init="\${5:-}" l
-  local jvm="" jvm_at="" kd="" kd_at="" strategy=""
-  CIBUILD_GRADLE_MEMORY_ARGS=()
-  CIBUILD_GRADLE_MEMORY_LINE=""
-  CIBUILD_GRADLE_MEMORY_SENTENCE=""
-
-  if [ -n "$preferred" ]; then jvm="$preferred"; jvm_at="the pipeline"; fi
-  for f in "$user" "$project"; do
-    if [ -z "$jvm_at" ]; then
-      l=$(cibuild_prop_line "$f" org.gradle.jvmargs)
-      if [ -n "$l" ]; then jvm="\${l#*	}"; jvm_at="$f:\${l%%	*}"; fi
-    fi
-    if [ -z "$kd_at" ]; then
-      l=$(cibuild_prop_line "$f" kotlin.daemon.jvmargs)
-      if [ -n "$l" ]; then kd="\${l#*	}"; kd_at="$f:\${l%%	*}"; fi
-    fi
-    if [ -z "$strategy" ]; then
-      l=$(cibuild_prop_line "$f" kotlin.compiler.execution.strategy)
-      strategy="\${l#*	}"
-    fi
-  done
-
-  local g k kd_own=""
-  g=$(cibuild_xmx_mib "$jvm")
-  [ -n "$g" ] || g=512
-  if [ "$strategy" = "in-process" ]; then
-    k=0
-  else
-    kd_own=$(cibuild_xmx_mib "$kd")
-    k="\${kd_own:-$g}"
-  fi
-  local total=$(( g + k ))
-
-  local asked
-  if [ -n "$jvm_at" ]; then asked="org.gradle.jvmargs=$jvm at \${jvm_at}"; else asked="Gradle's default -Xmx512m"; fi
-  if [ "$k" -eq 0 ]; then
-    asked="$asked; Kotlin compiles in-process"
-  elif [ -n "$kd_own" ]; then
-    asked="$asked, kotlin.daemon.jvmargs=$kd at \${kd_at}"
-  else
-    asked="$asked; the Kotlin daemon inherits its -Xmx"
-  fi
-
-  if [ -z "$mem" ]; then
-    CIBUILD_GRADLE_MEMORY_SENTENCE="This build's Gradle and Kotlin daemons asked for $(cibuild_gib "$total") GiB ($asked); this machine's memory could not be read."
-    if [ -n "$preferred" ]; then CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$preferred"); fi
-    return 0
-  fi
-
-  local budget=$(( mem * ${GRADLE_HEAP_SHARE_PERCENT} / 100 ))
-  CIBUILD_GRADLE_MEMORY_SENTENCE="The build machine has $(cibuild_gib "$mem") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib "$total") GiB ($asked)."
-
-  if [ "$total" -le "$budget" ]; then
-    if [ -n "$preferred" ]; then
-      CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$preferred")
-      CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line)."
-    fi
-    return 0
-  fi
-
-  case "$jvm" in
-    *\\\\)
-      CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: the declared heaps ask for $(cibuild_gib "$total") GiB of this machine's $(cibuild_gib "$mem") GiB, but org.gradle.jvmargs at \${jvm_at} continues onto another line, so it is left as it is."
-      return 0
-      ;;
-  esac
-
-  # One heap, the whole budget. Two did not fit: ReFra's Kotlin daemon was
-  # lost mid-compile at a 60/40 split, and mifos-mobile's Gradle daemon ran out
-  # of its 40 %. In-process, Kotlin compiles in the Gradle daemon's heap.
-  # A multiplatform project's metadata compiles are the exception: they go to
-  # a small Kotlin daemon (the init script), carved out of the same budget.
-  local ng now newjvm mg mk md=""
-  if [ "$k" -gt 0 ] && [ -n "$init" ]; then md=$(cibuild_metadata_daemon_heap "$budget"); fi
-  ng=$(cibuild_scaled_heap $(( budget - \${md:-0} )) 1 1)
-  newjvm=$(cibuild_with_xmx "$jvm" "$ng")
-  now="Gradle -Xmx\${ng}m"
-  if [ "$k" -gt 0 ]; then
-    # One JVM now holds what two did, so a Metaspace cap Gradle declared must
-    # hold Kotlin's too: the Kotlin daemon's own (kotlin.daemon.jvmargs, or
-    # -Dkotlin.daemon.jvm.options in Gradle's), else the Gradle one it
-    # inherits. GetStream/whatsApp-clone-compose capped Gradle at 512m and gave
-    # Kotlin 1g, and in-process compileDebugKotlin ran out of Metaspace
-    # (nightly-baseline 79). No Gradle cap, nothing to raise.
-    mg=$(cibuild_metaspace_mib "$jvm")
-    if [ -n "$mg" ]; then
-      mk=$(cibuild_metaspace_mib "$kd")
-      [ -n "$mk" ] || mk=$(cibuild_metaspace_mib "$(printf '%s\\n' "$jvm" | tr ' \\t' '\\n\\n' | sed -n 's/^-Dkotlin\\.daemon\\.jvm\\.options=//p')")
-      [ -n "$mk" ] || mk="$mg"
-      newjvm=$(cibuild_with_metaspace "$newjvm" $(( mg + mk )))
-      now="$now with -XX:MaxMetaspaceSize=$(( mg + mk ))m (Gradle's \${mg}m and Kotlin's \${mk}m, in one JVM now)"
-    fi
-    now="$now and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon)"
-  fi
-  if [ -n "$md" ]; then
-    now="$now, and Kotlin metadata compiles (compile*KotlinMetadata) in a Kotlin daemon of -Xmx\${md}m beside it (in-process, Kotlin 2.2 compiled them in K1 mode)"
-  fi
-  CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$newjvm")
-  if [ "$k" -gt 0 ]; then
-    CIBUILD_GRADLE_MEMORY_ARGS+=("-Pkotlin.compiler.execution.strategy=in-process")
-  fi
-  if [ -n "$md" ]; then
-    CIBUILD_GRADLE_MEMORY_ARGS+=("-Pkotlin.daemon.jvmargs=-Xmx\${md}m" --init-script "$init")
-  fi
-  CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: this machine has $(cibuild_gib "$mem") GiB and the declared heaps ask for $(cibuild_gib "$total") GiB ($asked), past the $(cibuild_gib "$budget") GiB this build allows them. Running with $now, set on the command line."
-  CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now."
-}
-
-# $1 the project's gradle.properties, $2 the Gradle user home's. A JDK path the
-# project pins with org.gradle.java.home that is not on this machine — a
-# developer's own, like SEAbdulbasit/MusicApp-KMP's
-# /Users/abdulbasit/Library/Java/... (nightly-baseline 83) — stops Gradle
-# before it starts: "given for org.gradle.java.home Gradle property is
-# invalid". On the command line, -Dorg.gradle.java.home beats both files
-# (measured, Gradle 8.14.3), so the build's own JDK is passed instead. A path
-# that exists is left alone. Sets CIBUILD_GRADLE_JAVA_HOME_LINE.
-cibuild_gradle_java_home_plan() {
-  local l v="" at=""
-  CIBUILD_GRADLE_JAVA_HOME_LINE=""
-  for f in "$2" "$1"; do
-    l=$(cibuild_prop_line "$f" org.gradle.java.home)
-    if [ -n "$l" ]; then v="\${l#*	}"; at="$f:\${l%%	*}"; break; fi
-  done
-  [ -n "$v" ] || return 0
-  [ -d "$v" ] && return 0
-  [ -n "\${JAVA_HOME:-}" ] && [ -d "$JAVA_HOME" ] || return 0
-  CIBUILD_GRADLE_MEMORY_ARGS+=("-Dorg.gradle.java.home=$JAVA_HOME")
-  CIBUILD_GRADLE_JAVA_HOME_LINE="Gradle: org.gradle.java.home=$v at $at is not on this machine; running with this build's JDK, $JAVA_HOME (-Dorg.gradle.java.home on the command line)."
-}
-
-# $1 the number of Gradle workers the pipeline asks for (may be empty). Adds
-# --max-workers to the plan's arguments; run after cibuild_gradle_memory_plan.
-# Sets CIBUILD_GRADLE_WORKERS_LINE (what to print; empty when nothing asked).
-cibuild_gradle_workers_plan() {
-  CIBUILD_GRADLE_WORKERS_LINE=""
-  [ -n "$1" ] || return 0
-  case "$1" in
-    *[!0-9]*|0*)
-      CIBUILD_GRADLE_WORKERS_LINE="Gradle memory: max_workers=$1 is not a positive whole number, so it is not passed and Gradle picks its own worker count."
-      return 0
-      ;;
-  esac
-  CIBUILD_GRADLE_MEMORY_ARGS+=("--max-workers=$1")
-  CIBUILD_GRADLE_WORKERS_LINE="Gradle memory: running with --max-workers=$1, as the pipeline asks (set on the command line, over any org.gradle.workers.max)."
-  CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE Gradle ran with --max-workers=$1."
-}
-
-# The kernel's out-of-memory lines, if this user may read the kernel log.
-# Linux guests restrict dmesg to root by default; their build user has
-# non-interactive sudo, so that is the second try.
-cibuild_kernel_oom_lines() {
-  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |
-    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true
-}
-
-# $1 Gradle's exit status, $2 a file holding its output. Says so when the
-# failure is a killed daemon rather than a failed build.
-cibuild_gradle_memory_report() {
-  local kotlin_lost=""
-  if grep -q "Connection to the Kotlin daemon has been unexpectedly lost" "$2" 2>/dev/null; then kotlin_lost=1; fi
-  if [ "$1" -ne 137 ] && [ -z "$kotlin_lost" ] && ! grep -q "daemon disappeared unexpectedly" "$2" 2>/dev/null; then
-    return 0
-  fi
-  local oom
-  oom=$(cibuild_kernel_oom_lines)
-  echo ""
-  if [ -n "$kotlin_lost" ]; then
-    echo "Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit $1). Kotlin then compiled without it, in the Gradle daemon's heap."
-  else
-    echo "Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1)."
-  fi
-  if [ -n "$oom" ]; then
-    echo "The kernel's out-of-memory lines:"
-    printf '%s\\n' "$oom" | sed 's/^/    /'
-  else
-    echo "The kernel log shows no out-of-memory kill, or this machine does not let the build read it."
-  fi
-  if [ -n "$CIBUILD_GRADLE_MEMORY_SENTENCE" ]; then echo "$CIBUILD_GRADLE_MEMORY_SENTENCE"; fi
-}
-
-# Runs Gradle with the plan's arguments, and reports a killed daemon.
-cibuild_gradle() {
-  local log rc
-  log=$(mktemp)
-  set +e
-  "$CIBUILD_GRADLE_BIN" "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}" "$@" 2>&1 | tee "$log"
-  rc=\${PIPESTATUS[0]}
-  set -e
-  if [ "$rc" -ne 0 ]; then cibuild_gradle_memory_report "$rc" "$log" || true; fi
-  rm -f "$log"
-  return "$rc"
-}
-
-# $1 JVM arguments the pipeline asks for, $2 the Gradle workers it asks for
-# (either may be empty). Run in the Gradle project directory, after GRADLE_CMD
-# is chosen.
-cibuild_gradle_memory_cap() {
-  local metadata_init=""
-  if cibuild_applies_kotlin_multiplatform; then
-    metadata_init="$(mktemp -d)/cibuild-kotlin-metadata-daemon.init.gradle"
-    cat > "$metadata_init" <<'CIBUILD_KOTLIN_METADATA_INIT'
-${KOTLIN_METADATA_DAEMON_INIT_SCRIPT}CIBUILD_KOTLIN_METADATA_INIT
-  fi
-  cibuild_gradle_memory_plan "$(cibuild_mem_mib || true)" "gradle.properties" \\
-    "\${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties" "$1" "$metadata_init"
-  cibuild_gradle_workers_plan "$2"
-  cibuild_gradle_java_home_plan "gradle.properties" "\${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties"
-  if [ -n "$CIBUILD_GRADLE_MEMORY_LINE" ]; then echo "$CIBUILD_GRADLE_MEMORY_LINE"; fi
-  if [ -n "$CIBUILD_GRADLE_WORKERS_LINE" ]; then echo "$CIBUILD_GRADLE_WORKERS_LINE"; fi
-  if [ -n "$CIBUILD_GRADLE_JAVA_HOME_LINE" ]; then echo "$CIBUILD_GRADLE_JAVA_HOME_LINE"; fi
-  CIBUILD_GRADLE_BIN="$GRADLE_CMD"
-  GRADLE_CMD=cibuild_gradle
-}`;
-/**
- * The commands a Gradle step runs once it has chosen `GRADLE_CMD` and is in
- * the project directory. Afterwards `$GRADLE_CMD` runs Gradle with the plan's
- * arguments and reports a killed daemon.
- *
- * `jvmargs` is what the pipeline asks for instead of the project's
- * `org.gradle.jvmargs` (a value the repository's own CI sets, say); the cap
- * still applies to it. `maxWorkers` is the worker count it asks for (the
- * repository CI's `org.gradle.workers.max`), passed as `--max-workers`.
- */
-export function gradleMemoryCommands(jvmargs, escape, maxWorkers = '') {
-    return [
-        '',
-        GRADLE_MEMORY_FUNCTIONS,
-        '',
-        `cibuild_gradle_memory_cap '${escape(jvmargs)}' '${escape(maxWorkers)}'`,
-    ];
-}
-/**
- * A pinned org.gradle.java.home that is not on this machine, made to name the
- * build's JDK for every Gradle run in the build. The Gradle steps already pass
- * -Dorg.gradle.java.home on their own command line; a script step's
- * ./gradlew and a build phase Xcode runs do not, and they read the checkout's
- * gradle.properties. SEAbdulbasit/MusicApp-KMP's Android step went on with the
- * override and its KMM "Prepare the iOS build" script stopped on the same
- * "given for org.gradle.java.home Gradle property is invalid"
- * (nightly-baseline 92). So the line itself is rewritten, in every
- * gradle.properties of the checkout, once the build's JDK is chosen. A path
- * that exists, an empty value or a commented-out line is left alone.
- */
-export const GRADLE_JAVA_HOME_PIN_FUNCTIONS = `${GRADLE_PROP_LINE_FUNCTION}
-
-# Run once JAVA_HOME is the build's JDK. Searches the checkout
-# (CIBUILD_SOURCE_DIR, else the current directory) to the depth a nested
-# Gradle project sits at, and prints one line per file it rewrites.
-cibuild_gradle_java_home_pin() {
-  [ -n "\${JAVA_HOME:-}" ] && [ -d "$JAVA_HOME" ] || return 0
-  local root f l v tmp
-  root="\${CIBUILD_SOURCE_DIR:-.}"
-  while IFS= read -r f; do
-    l=$(cibuild_prop_line "$f" org.gradle.java.home)
-    [ -n "$l" ] || continue
-    v="\${l#*	}"
-    [ -n "$v" ] || continue
-    [ -d "$v" ] && continue
-    tmp=$(mktemp)
-    awk -v key=org.gradle.java.home -v home="$JAVA_HOME" '
-      { line = $0; sub(/^[ \\t]+/, "", line) }
-      line !~ /^[#!]/ { k = line; sub(/[ \\t]*[=:].*$/, "", k); if (k == key) { print key "=" home; next } }
-      { print }
-    ' "$f" > "$tmp" && cat "$tmp" > "$f"
-    rm -f "$tmp"
-    echo "Gradle: org.gradle.java.home=$v at \${f#"$root"/}:\${l%%	*} is not on this machine; that line now names this build's JDK, $JAVA_HOME, so every Gradle run in this build uses it (a script's ./gradlew and Xcode's build phases as well as the Gradle steps)."
-  done < <(find "$root" -maxdepth 4 \\( -name .git -o -name node_modules -o -name build -o -name .gradle \\) -prune -o -type f -name gradle.properties -print 2>/dev/null)
-}`;
-//# sourceMappingURL=gradle-memory.js.map

package/dist/src/yaml/steps/gradle-memory.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=gradle-memory.test.d.ts.map

package/dist/src/yaml/steps/gradle-memory.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradle-memory.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.test.ts"],"names":[],"mappings":""}