Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
ci: native arm64 runners — drop QEMU, cut wheel + docker build time
chopratejased36676c9cf7
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.ymlindex 069f91a71..1cb15119a 100644--- a/.github/workflows/docker.yml+++ b/.github/workflows/docker.yml@@ -1,220 +1,380 @@-name: Docker--on:- workflow_call:- inputs:- version:- description: "Version to stamp into the image contents and exact image tag"- required: false- type: string- enable_ref_tags:- description: "Whether to emit branch/PR ref tags"- required: false- default: true- type: boolean- workflow_dispatch:- inputs:- version:- description: "Version to stamp into the image contents and exact image tag"- required: false- release:- types: [published]--env:- REGISTRY: ghcr.io--permissions:- contents: read- packages: write- id-token: write # For cosign keyless signing via Sigstore OIDC--jobs:- docker-variant-tags:- runs-on: ubuntu-latest- strategy:- fail-fast: false- matrix:- include:- - variant: ""- bake_target: runtime- - variant: nonroot- bake_target: runtime-nonroot- - variant: code- bake_target: runtime-code- - variant: code-nonroot- bake_target: runtime-code-nonroot- - variant: slim- bake_target: runtime-slim- - variant: slim-nonroot- bake_target: runtime-slim-nonroot- - variant: code-slim- bake_target: runtime-code-slim- - variant: code-slim-nonroot- bake_target: runtime-code-slim-nonroot-- steps:- - uses: actions/checkout@v6-- - name: Normalize image name- id: image-name- run: |- image_name="$(printf '%s' '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"- printf 'image_name=%s\n' "$image_name" >> "$GITHUB_OUTPUT"-- - name: Determine image version- id: version- env:- MANUAL_VERSION: ${{ inputs.version || github.event.inputs.version }}- RELEASE_TAG: ${{ github.event.release.tag_name }}- run: |- version="${MANUAL_VERSION#v}"- if [ -z "$version" ] && [ -n "$RELEASE_TAG" ]; then- version="${RELEASE_TAG#v}"- fi- printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"-- - name: Set up Python- if: steps.version.outputs.version != ''- uses: actions/setup-python@v5- with:- python-version: "3.12"-- - name: Sync versioned files for image build- if: steps.version.outputs.version != ''- run: |- python scripts/version-sync.py --version ${{ steps.version.outputs.version }}-- - name: Set up QEMU- uses: docker/setup-qemu-action@v4-- - name: Set up Docker Buildx- uses: docker/setup-buildx-action@v4-- - name: Log in to GHCR- uses: docker/login-action@v4- with:- registry: ${{ env.REGISTRY }}- username: ${{ github.actor }}- password: ${{ secrets.GITHUB_TOKEN }}-- - name: Compute short SHA- id: short-sha- run: printf 'sha=%s\n' "${GITHUB_SHA:0:7}" >> "$GITHUB_OUTPUT"-- - name: Extract metadata (variant)- id: meta- uses: docker/metadata-action@v6- with:- images: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}- tags: |- type=ref,event=branch,enable=${{ inputs.enable_ref_tags != 'false' && github.event_name != 'release' }},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=ref,event=pr,enable=${{ inputs.enable_ref_tags != 'false' && github.event_name != 'release' }},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=raw,value=${{ steps.version.outputs.version }},enable=${{ steps.version.outputs.version != '' }},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=raw,value=${{ steps.version.outputs.version }}-${{ steps.short-sha.outputs.sha }},enable=${{ steps.version.outputs.version != '' && matrix.variant == '' }}- type=raw,value=${{ steps.version.outputs.version }}-${{ matrix.variant }}-${{ steps.short-sha.outputs.sha }},enable=${{ steps.version.outputs.version != '' && matrix.variant != '' }}- type=semver,pattern={{version}},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=semver,pattern={{major}}.{{minor}},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=semver,pattern={{major}},suffix=${{ matrix.variant != '' && format('-{0}', matrix.variant) || '' }}- type=sha,format=short,prefix=${{ matrix.variant != '' && format('{0}-', matrix.variant) || 'sha-' }}- type=raw,value=${{ matrix.variant }},enable=${{ matrix.variant != '' }}-- - name: Build and push variant (bake)- id: bake- uses: docker/bake-action@v7- with:- files: |- ./docker-bake.hcl- cwd://${{ steps.meta.outputs.bake-file-tags }}- cwd://${{ steps.meta.outputs.bake-file-labels }}- targets: ${{ matrix.bake_target }}- push: true- set: |- *.cache-from=type=gha- *.cache-to=type=gha,mode=max-- - name: Install cosign- uses: sigstore/cosign-installer@v3-- - name: Sign images with cosign (keyless via Sigstore OIDC)- env:- # Route signatures to a sibling GHCR package so the main image's- # package version list stays clean. GHCR does not implement the OCI 1.1- # referrers API yet (community discussion #163029, June 2025), so- # cosign's OCI 1.1 mode falls back to writing referrer tags into the- # *image's* repo. Using legacy signature mode here lets COSIGN_REPOSITORY- # actually relocate the artifacts. Verifiers must export the same- # COSIGN_REPOSITORY value when running 'cosign verify'.- COSIGN_REPOSITORY: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}-signatures- run: |- # Write bake metadata to a file rather than pass it through- # the `env:` block. The `code-nonroot` and `runtime-code-nonroot`- # bake targets emit metadata blobs large enough that combined- # argv+env at bash spawn exceeds Linux ARG_MAX (~128 KiB on- # ubuntu-latest), failing with `E2BIG: Argument list too long`- # before the script can run. The heredoc puts the JSON in the- # script body (which is read from a temp file by bash, no- # ARG_MAX limit) and we read it back via `jq -f`-style file- # input. Sentinel chosen long enough that no JSON payload is- # plausibly going to collide with it.- cat > "${RUNNER_TEMP}/bake_meta.json" <<'__HEADROOM_BAKE_META_EOF__'- ${{ steps.bake.outputs.metadata }}- __HEADROOM_BAKE_META_EOF__-- jq -r 'to_entries[].value."containerimage.digest" // empty' \- "${RUNNER_TEMP}/bake_meta.json" | while read -r digest; do- image="${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}@${digest}"- echo "Signing ${image} (signatures -> ${COSIGN_REPOSITORY})"- cosign sign --yes "${image}"- done-- promote-latest:- # Re-push the :latest tag pointing at the root variant *after* every- # variant matrix job has finished, so GHCR's package version listing- # (sorted by created_at) shows the root image with :latest at the top- # instead of whichever variant happened to finish last.- needs: docker-variant-tags- runs-on: ubuntu-latest- steps:- - name: Normalize image name- id: image-name- run: |- image_name="$(printf '%s' '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"- printf 'image_name=%s\n' "$image_name" >> "$GITHUB_OUTPUT"-- - name: Determine image version- id: version- env:- MANUAL_VERSION: ${{ inputs.version || github.event.inputs.version }}- RELEASE_TAG: ${{ github.event.release.tag_name }}- run: |- version="${MANUAL_VERSION#v}"- if [ -z "$version" ] && [ -n "$RELEASE_TAG" ]; then- version="${RELEASE_TAG#v}"- fi- printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"-- - name: Set up Docker Buildx- uses: docker/setup-buildx-action@v4-- - name: Log in to GHCR- uses: docker/login-action@v4- with:- registry: ${{ env.REGISTRY }}- username: ${{ github.actor }}- password: ${{ secrets.GITHUB_TOKEN }}-- - name: Re-tag root image as :latest- if: steps.version.outputs.version != ''- env:- IMAGE: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}- VERSION: ${{ steps.version.outputs.version }}- run: |- # Add a unique annotation so the resulting image index manifest gets- # a new digest, which makes GHCR record a fresh package version with- # current timestamp (otherwise the existing root manifest is reused- # and stays where it was in the version listing).- promoted_at="$(date -u +%Y-%m-%dT%H:%M:%SZ)"- docker buildx imagetools create \- --annotation "index:io.headroom.promoted-at=${promoted_at}" \- --tag "${IMAGE}:latest" \- "${IMAGE}:${VERSION}"+name: Docker++on:+ workflow_call:+ inputs:+ version:+ description: "Version to stamp into the image contents and exact image tag"+ required: false+ type: string+ enable_ref_tags:+ description: "Whether to emit branch/PR ref tags"+ required: false+ default: true+ type: boolean+ workflow_dispatch:+ inputs:+ version:+ description: "Version to stamp into the image contents and exact image tag"+ required: false+ release:+ types: [published]++env:+ REGISTRY: ghcr.io++permissions:+ contents: read+ packages: write+ id-token: write # For cosign keyless signing via Sigstore OIDC++jobs:+ # ─── Per-arch fan-out ──────────────────────────────────────────────────────+ # Build each variant on its native architecture in parallel:+ # linux/amd64 → ubuntu-24.04 (native x86_64)+ # linux/arm64 → ubuntu-24.04-arm (native aarch64, GA Jan 2025)+ #+ # Pre-#377 we ran a single matrix job per variant on `ubuntu-latest` and+ # let bake's `platforms = ["linux/amd64", "linux/arm64"]` do multi-arch+ # via QEMU emulation — ~1h per variant. Native arm64 runners drop QEMU+ # entirely and cut each variant to ~10 min on each arch in parallel.+ #+ # Each per-arch build pushes by digest only (no tags). The+ # `docker-manifest` job below combines the per-arch digests into the+ # final multi-arch tagged manifest, which is what users pull by tag.+ docker-build:+ runs-on: ${{ matrix.arch.runs_on }}+ strategy:+ fail-fast: false+ matrix:+ variant:+ - { name: "", bake_target: runtime }+ - { name: nonroot, bake_target: runtime-nonroot }+ - { name: code, bake_target: runtime-code }+ - { name: code-nonroot, bake_target: runtime-code-nonroot }+ - { name: slim, bake_target: runtime-slim }+ - { name: slim-nonroot, bake_target: runtime-slim-nonroot }+ - { name: code-slim, bake_target: runtime-code-slim }+ - { name: code-slim-nonroot, bake_target: runtime-code-slim-nonroot }+ arch:+ - { name: amd64, runs_on: ubuntu-24.04, platform: linux/amd64 }+ - { name: arm64, runs_on: ubuntu-24.04-arm, platform: linux/arm64 }++ steps:+ - uses: actions/checkout@v6++ - name: Normalize image name+ id: image-name+ run: |+ image_name="$(printf '%s' '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"+ printf 'image_name=%s\n' "$image_name" >> "$GITHUB_OUTPUT"++ - name: Determine image version+ id: version+ env:+ MANUAL_VERSION: ${{ inputs.version || github.event.inputs.version }}+ RELEASE_TAG: ${{ github.event.release.tag_name }}+ run: |+ version="${MANUAL_VERSION#v}"+ if [ -z "$version" ] && [ -n "$RELEASE_TAG" ]; then+ version="${RELEASE_TAG#v}"+ fi+ printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"++ - name: Set up Python+ if: steps.version.outputs.version != ''+ uses: actions/setup-python@v5+ with:+ python-version: "3.12"++ - name: Sync versioned files for image build+ if: steps.version.outputs.version != ''+ run: |+ python scripts/version-sync.py --version ${{ steps.version.outputs.version }}++ - name: Set up Docker Buildx+ uses: docker/setup-buildx-action@v4++ - name: Log in to GHCR+ uses: docker/login-action@v4+ with:+ registry: ${{ env.REGISTRY }}+ username: ${{ github.actor }}+ password: ${{ secrets.GITHUB_TOKEN }}++ # Labels (not tags) for the per-arch image. Tags belong on the+ # multi-arch index manifest and are applied in docker-manifest.+ - name: Extract image labels+ id: meta+ uses: docker/metadata-action@v6+ with:+ images: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}++ - name: Build and push by digest (single platform)+ id: bake+ uses: docker/bake-action@v7+ with:+ files: |+ ./docker-bake.hcl+ cwd://${{ steps.meta.outputs.bake-file-labels }}+ targets: ${{ matrix.variant.bake_target }}+ push: true+ # `*.platform` overrides the [amd64,arm64] default in+ # docker-bake.hcl. `push-by-digest=true,name-canonical=true`+ # tells buildx to push the per-platform manifest with no tags+ # — only the digest is recorded — so multiple per-arch builds+ # can coexist in the registry until the manifest job stitches+ # them. GHA cache is scoped per (variant, arch) so the two+ # arches don't fight over the same cache key.+ set: |+ *.platform=${{ matrix.arch.platform }}+ *.output=type=image,push-by-digest=true,name-canonical=true,push=true+ *.cache-from=type=gha,scope=${{ matrix.variant.name || 'root' }}-${{ matrix.arch.name }}+ *.cache-to=type=gha,mode=max,scope=${{ matrix.variant.name || 'root' }}-${{ matrix.arch.name }}++ - name: Export digest+ id: digest+ env:+ BAKE_METADATA: ${{ steps.bake.outputs.metadata }}+ run: |+ # Bake's metadata is one entry per target; for a single-target+ # single-platform build it has exactly one digest. Pipe the+ # JSON through a file (same ARG_MAX rationale as before) and+ # extract that digest.+ cat > "${RUNNER_TEMP}/bake_meta.json" <<'__HEADROOM_BAKE_META_EOF__'+ ${{ steps.bake.outputs.metadata }}+ __HEADROOM_BAKE_META_EOF__+ digest="$(jq -r 'to_entries[0].value."containerimage.digest" // empty' \+ "${RUNNER_TEMP}/bake_meta.json")"+ if [ -z "$digest" ]; then+ echo "ERROR: no digest in bake metadata" >&2+ cat "${RUNNER_TEMP}/bake_meta.json" >&2+ exit 1+ fi+ printf 'digest=%s\n' "$digest" >> "$GITHUB_OUTPUT"+ # Stage a marker file named after the bare hex digest. The+ # manifest job downloads all per-arch markers for a variant+ # and reconstructs `IMAGE@sha256:<digest>` references from+ # the filenames.+ mkdir -p "${RUNNER_TEMP}/digests"+ touch "${RUNNER_TEMP}/digests/${digest#sha256:}"++ - name: Upload digest marker+ uses: actions/upload-artifact@v4+ with:+ # Variant + arch in the artifact name so the manifest job can+ # download with `pattern: digests-<variant>-*` to gather all+ # arches for one variant. `root` substitutes the empty-string+ # variant since GHA artifact names can't end in a hyphen.+ name: digests-${{ matrix.variant.name || 'root' }}-${{ matrix.arch.name }}+ path: ${{ runner.temp }}/digests/*+ if-no-files-found: error+ retention-days: 1++ # ─── Per-variant manifest merge ────────────────────────────────────────────+ # One job per variant, after both arch builds for that variant complete.+ # `docker buildx imagetools create` stitches the two per-arch digests+ # into a single multi-arch index manifest, applies the metadata-action+ # tags, and that manifest is what users pull by `:tag`.+ docker-manifest:+ needs: docker-build+ runs-on: ubuntu-24.04+ strategy:+ fail-fast: false+ matrix:+ variant:+ - { name: "", bake_target: runtime }+ - { name: nonroot, bake_target: runtime-nonroot }+ - { name: code, bake_target: runtime-code }+ - { name: code-nonroot, bake_target: runtime-code-nonroot }+ - { name: slim, bake_target: runtime-slim }+ - { name: slim-nonroot, bake_target: runtime-slim-nonroot }+ - { name: code-slim, bake_target: runtime-code-slim }+ - { name: code-slim-nonroot, bake_target: runtime-code-slim-nonroot }++ steps:+ # No `actions/checkout` here: the manifest job only calls+ # `docker buildx imagetools` against the registry and runs+ # cosign — neither needs the repo on disk. Skipping checkout+ # saves a few seconds across 8 parallel manifest jobs.+ - name: Normalize image name+ id: image-name+ run: |+ image_name="$(printf '%s' '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"+ printf 'image_name=%s\n' "$image_name" >> "$GITHUB_OUTPUT"++ - name: Determine image version+ id: version+ env:+ MANUAL_VERSION: ${{ inputs.version || github.event.inputs.version }}+ RELEASE_TAG: ${{ github.event.release.tag_name }}+ run: |+ version="${MANUAL_VERSION#v}"+ if [ -z "$version" ] && [ -n "$RELEASE_TAG" ]; then+ version="${RELEASE_TAG#v}"+ fi+ printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"++ - name: Compute short SHA+ id: short-sha+ run: printf 'sha=%s\n' "${GITHUB_SHA:0:7}" >> "$GITHUB_OUTPUT"++ - name: Set up Docker Buildx+ uses: docker/setup-buildx-action@v4++ - name: Log in to GHCR+ uses: docker/login-action@v4+ with:+ registry: ${{ env.REGISTRY }}+ username: ${{ github.actor }}+ password: ${{ secrets.GITHUB_TOKEN }}++ - name: Download per-arch digests for this variant+ uses: actions/download-artifact@v4+ with:+ pattern: digests-${{ matrix.variant.name || 'root' }}-*+ path: ${{ runner.temp }}/digests+ merge-multiple: true++ # Same tag rules as the pre-fan-out workflow — preserve every+ # tag flavor (semver, ref, sha-prefixed, version-suffixed,+ # bare variant) so existing pull URLs keep working.+ - name: Extract metadata (variant)+ id: meta+ uses: docker/metadata-action@v6+ with:+ images: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}+ tags: |+ type=ref,event=branch,enable=${{ inputs.enable_ref_tags != 'false' && github.event_name != 'release' }},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=ref,event=pr,enable=${{ inputs.enable_ref_tags != 'false' && github.event_name != 'release' }},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=raw,value=${{ steps.version.outputs.version }},enable=${{ steps.version.outputs.version != '' }},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=raw,value=${{ steps.version.outputs.version }}-${{ steps.short-sha.outputs.sha }},enable=${{ steps.version.outputs.version != '' && matrix.variant.name == '' }}+ type=raw,value=${{ steps.version.outputs.version }}-${{ matrix.variant.name }}-${{ steps.short-sha.outputs.sha }},enable=${{ steps.version.outputs.version != '' && matrix.variant.name != '' }}+ type=semver,pattern={{version}},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=semver,pattern={{major}}.{{minor}},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=semver,pattern={{major}},suffix=${{ matrix.variant.name != '' && format('-{0}', matrix.variant.name) || '' }}+ type=sha,format=short,prefix=${{ matrix.variant.name != '' && format('{0}-', matrix.variant.name) || 'sha-' }}+ type=raw,value=${{ matrix.variant.name }},enable=${{ matrix.variant.name != '' }}++ - name: Create multi-arch manifest+ id: manifest+ env:+ IMAGE: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}+ DIGEST_DIR: ${{ runner.temp }}/digests+ run: |+ # Reconstruct full image references from the digest marker+ # filenames (each file is named after the bare hex digest+ # of one per-arch manifest).+ if ! ls "${DIGEST_DIR}"/* >/dev/null 2>&1; then+ echo "ERROR: no digests downloaded for variant '${{ matrix.variant.name || 'root' }}'" >&2+ exit 1+ fi+ digest_refs=()+ for f in "${DIGEST_DIR}"/*; do+ digest="$(basename "$f")"+ digest_refs+=("${IMAGE}@sha256:${digest}")+ done++ # Build `--tag` args from the metadata-action JSON output.+ # Empty tags array is valid (PR builds without ref-tags+ # enabled emit nothing); skip manifest creation in that case.+ tag_args=()+ while IFS= read -r tag; do+ [ -n "$tag" ] && tag_args+=("--tag" "$tag")+ done < <(jq -r '.tags[]?' <<< '${{ steps.meta.outputs.json }}')++ if [ "${#tag_args[@]}" -eq 0 ]; then+ echo "No tags to apply for variant '${{ matrix.variant.name || 'root' }}'; skipping manifest."+ exit 0+ fi++ docker buildx imagetools create \+ "${tag_args[@]}" \+ "${digest_refs[@]}"++ # Resolve the index manifest digest of the freshly pushed+ # multi-arch manifest so cosign can sign it directly. We+ # ask the registry via `imagetools inspect` and read the+ # `.manifest.digest` field — that's the registry's own+ # record of the index digest (no client-side hashing).+ first_tag="$(jq -r '.tags[0]' <<< '${{ steps.meta.outputs.json }}')"+ index_digest="$(docker buildx imagetools inspect "${first_tag}" \+ --format '{{ json . }}' | jq -r '.manifest.digest')"+ if [ -z "$index_digest" ] || [ "$index_digest" = "null" ]; then+ echo "ERROR: could not resolve index digest for ${first_tag}" >&2+ exit 1+ fi+ printf 'index_digest=%s\n' "$index_digest" >> "$GITHUB_OUTPUT"+ printf 'first_tag=%s\n' "$first_tag" >> "$GITHUB_OUTPUT"++ - name: Install cosign+ if: steps.manifest.outputs.index_digest != ''+ uses: sigstore/cosign-installer@v3++ - name: Sign multi-arch index manifest with cosign+ if: steps.manifest.outputs.index_digest != ''+ env:+ # Same routing as before: keep signature artifacts in a+ # sibling GHCR package so the main image's version listing+ # stays clean. Verifiers must export the same+ # COSIGN_REPOSITORY when running 'cosign verify'. See the+ # pre-#377 workflow for the GHCR/OCI-1.1 referrers context.+ COSIGN_REPOSITORY: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}-signatures+ IMAGE: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}+ INDEX_DIGEST: ${{ steps.manifest.outputs.index_digest }}+ run: |+ target="${IMAGE}@${INDEX_DIGEST}"+ echo "Signing ${target} (signatures -> ${COSIGN_REPOSITORY})"+ cosign sign --yes "${target}"++ promote-latest:+ # Re-push the :latest tag pointing at the root variant *after* every+ # variant manifest job has finished, so GHCR's package version+ # listing (sorted by created_at) shows the root image with :latest+ # at the top instead of whichever variant happened to finish last.+ needs: docker-manifest+ runs-on: ubuntu-24.04+ steps:+ - name: Normalize image name+ id: image-name+ run: |+ image_name="$(printf '%s' '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"+ printf 'image_name=%s\n' "$image_name" >> "$GITHUB_OUTPUT"++ - name: Determine image version+ id: version+ env:+ MANUAL_VERSION: ${{ inputs.version || github.event.inputs.version }}+ RELEASE_TAG: ${{ github.event.release.tag_name }}+ run: |+ version="${MANUAL_VERSION#v}"+ if [ -z "$version" ] && [ -n "$RELEASE_TAG" ]; then+ version="${RELEASE_TAG#v}"+ fi+ printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"++ - name: Set up Docker Buildx+ uses: docker/setup-buildx-action@v4++ - name: Log in to GHCR+ uses: docker/login-action@v4+ with:+ registry: ${{ env.REGISTRY }}+ username: ${{ github.actor }}+ password: ${{ secrets.GITHUB_TOKEN }}++ - name: Re-tag root image as :latest+ if: steps.version.outputs.version != ''+ env:+ IMAGE: ${{ env.REGISTRY }}/${{ steps.image-name.outputs.image_name }}+ VERSION: ${{ steps.version.outputs.version }}+ run: |+ # Add a unique annotation so the resulting image index manifest gets+ # a new digest, which makes GHCR record a fresh package version with+ # current timestamp (otherwise the existing root manifest is reused+ # and stays where it was in the version listing).+ promoted_at="$(date -u +%Y-%m-%dT%H:%M:%SZ)"+ docker buildx imagetools create \+ --annotation "index:io.headroom.promoted-at=${promoted_at}" \+ --tag "${IMAGE}:latest" \+ "${IMAGE}:${VERSION}"diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex 706199727..87c3c524f 100644--- a/.github/workflows/release.yml+++ b/.github/workflows/release.yml@@ -186,10 +186,18 @@ jobs:# compiles OpenSSL from source so the system version doesn't# matter, but pinning the floor keeps us off CentOS 7's ancient# gcc/glibc surface anyway.- - os: ubuntu-latest+ - os: ubuntu-24.04target: x86_64-unknown-linux-gnumanylinux: 2_28- - os: ubuntu-latest+ # Native arm64 runner (`ubuntu-24.04-arm`, GA Jan 2025, free+ # for public repos) replaces the previous `ubuntu-latest` ++ # QEMU path. Building inside `manylinux_2_28_aarch64` natively+ # on an ARM host cuts the aarch64 wheel build from ~50–60 min+ # (emulated) to ~10 min. Wheel ABI is unchanged — the+ # `manylinux: 2_28` field still pins the runtime glibc floor;+ # `cargo tree` regression in tests/test_release_workflows.py+ # keeps the resolved build graph identical.+ - os: ubuntu-24.04-armtarget: aarch64-unknown-linux-gnumanylinux: 2_28# NOTE: `macos-15-intel` (x86_64-apple-darwin) is intentionallydiff --git a/tests/test_release_workflows.py b/tests/test_release_workflows.pyindex 1337bb279..8392cb9e5 100644--- a/tests/test_release_workflows.py+++ b/tests/test_release_workflows.py@@ -297,6 +297,114 @@ def test_build_wheels_matrix_excludes_intel_macos() -> None:assert "macos-15-intel" not in matrix_os+def test_aarch64_wheel_uses_native_arm64_runner() -> None:+ """STRUCTURAL INVARIANT: the aarch64 wheel matrix row must run on a+ native arm64 runner (`ubuntu-24.04-arm`), NOT a QEMU-emulated x64+ runner (`ubuntu-latest`).++ Pre-#377 we built the aarch64 wheel on `ubuntu-latest` (x86_64) inside+ `manylinux_2_28_aarch64` via QEMU emulation, taking ~50–60 min. Native+ arm64 GitHub-hosted runners (GA Jan 2025, free for public repos) drop+ QEMU and complete the same build in ~10 min.++ A future "let me unify all wheel rows on `ubuntu-latest`" refactor+ would silently re-introduce QEMU and slow CI back down — this test+ pins the runner.+ """+ content = (ROOT / ".github" / "workflows" / "release.yml").read_text(encoding="utf-8")++ bw_start = content.index("\n build-wheels:")+ bw_end = content.index("\n collect-dist:")+ body = content[bw_start:bw_end]++ # Walk the matrix.include rows. Each row is a contiguous block of+ # `key: value` lines starting with `os:` (the first key in our+ # convention). Pair `os:` with the immediately-following `target:`+ # so we can assert per-row.+ rows: list[dict[str, str]] = []+ current: dict[str, str] = {}+ for raw in body.splitlines():+ stripped = raw.lstrip()+ if stripped.startswith("#"):+ continue+ if stripped.startswith("- os:"):+ if current:+ rows.append(current)+ current = {"os": stripped.split(":", 1)[1].strip()}+ elif stripped.startswith("target:") and current:+ current["target"] = stripped.split(":", 1)[1].strip()+ elif stripped.startswith("manylinux:") and current:+ current["manylinux"] = stripped.split(":", 1)[1].strip()+ if current:+ rows.append(current)++ aarch64_linux = [r for r in rows if r.get("target") == "aarch64-unknown-linux-gnu"]+ assert len(aarch64_linux) == 1, f"expected exactly one aarch64-linux row; got {aarch64_linux}"+ assert aarch64_linux[0]["os"] == "ubuntu-24.04-arm", (+ f"aarch64-unknown-linux-gnu must run on native arm64 runner "+ f"`ubuntu-24.04-arm`, not {aarch64_linux[0]['os']!r}. Reverting "+ f"to `ubuntu-latest` re-introduces QEMU emulation and ~6× slower "+ f"wheel builds."+ )++ # The amd64 Linux row should also be pinned to ubuntu-24.04 (not+ # `ubuntu-latest`, which is a moving target). Pinning keeps the+ # wheel-build environment reproducible across runner image rolls.+ amd64_linux = [r for r in rows if r.get("target") == "x86_64-unknown-linux-gnu"]+ assert len(amd64_linux) == 1+ assert amd64_linux[0]["os"] == "ubuntu-24.04", (+ f"x86_64-unknown-linux-gnu should pin `ubuntu-24.04`, not "+ f"{amd64_linux[0]['os']!r} — `ubuntu-latest` is a moving alias "+ f"and reproducibility benefits from explicit pinning."+ )+++def test_docker_workflow_builds_on_native_arch_runners() -> None:+ """STRUCTURAL INVARIANT: the docker variant build must fan out per+ arch onto native runners — `linux/amd64` on `ubuntu-24.04`,+ `linux/arm64` on `ubuntu-24.04-arm`. No QEMU.++ Pre-#377 each variant ran `docker bake` with+ `platforms = ["linux/amd64","linux/arm64"]` on a single x64 runner+ using QEMU for arm64 emulation — ~1h per variant. Splitting into+ 16 native single-arch builds (8 variants × 2 arches) + a manifest+ merge job per variant cuts wall-clock to ~10 min and removes the+ QEMU surface that contributed to transient build failures.+ """+ content = (ROOT / ".github" / "workflows" / "docker.yml").read_text(encoding="utf-8")++ # The fan-out job must exist with both runners in its arch matrix.+ assert "docker-build:" in content, "docker-build fan-out job missing"+ assert "runs_on: ubuntu-24.04, platform: linux/amd64" in content, (+ "amd64 arch matrix entry must bind ubuntu-24.04 (native x86_64)"+ )+ assert "runs_on: ubuntu-24.04-arm, platform: linux/arm64" in content, (+ "arm64 arch matrix entry must bind ubuntu-24.04-arm (native aarch64)"+ )++ # Per-arch builds must push by digest only — tags belong on the+ # multi-arch manifest, applied later by docker-manifest.+ assert "push-by-digest=true,name-canonical=true,push=true" in content, (+ "per-arch builds must push by digest only; tags applied at manifest merge step"+ )++ # The QEMU action must NOT be invoked anywhere — its presence would+ # mean someone re-introduced an emulated build path.+ non_comment = "\n".join(+ line for line in content.splitlines() if not line.lstrip().startswith("#")+ )+ assert "docker/setup-qemu-action" not in non_comment, (+ "docker.yml must not invoke `docker/setup-qemu-action` — native "+ "arm64 runners replaced QEMU. A new reference here means someone "+ "re-emulated arm64 on an x64 runner."+ )++ # Manifest merge job must exist and depend on docker-build.+ assert "docker-manifest:" in content+ assert "needs: docker-build" in content+ assert "docker buildx imagetools create" in content++def test_npm_publish_jobs_do_not_download_dist_artifact() -> None:"""`publish-npm` and `publish-github-packages` `npm pack`+`npm publish`directly from the checked-out source tree; they never read the