Skip to content

fix(ci): pin test-wasm-browsers' timeout and retry-wrapper shape in ci_wiring - #440

Merged
rubenhensen merged 2 commits into
mainfrom
dobby/issue-432-wasm-browser-ci-timeout
Sep 10, 2026
Merged

rubenhensen merged 2 commits into
mainfrom
dobby/issue-432-wasm-browser-ci-timeout

Conversation

@dobby-coder

@dobby-coder dobby-coder Bot commented Sep 10, 2026 •

Copy link
Copy Markdown
Contributor

Resolves the implementation half of #416, part of #247. Closes #432.

CI status

Test workspace (pg-core) is red because the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper fails — on purpose, see below. Test workspace (pg-pkg), Test workspace (pg-cli) and Test workspace (cryptify) show red alongside it, but that's test's matrix (crate: [pg-core, pg-pkg, pg-cli, pg-ffi, cryptify]) fail-fast cancelling the other legs the moment pg-core goes red — each job log ends mid-compile with ##[error]The operation was canceled., not a test that ran and failed. pg-ffi finished compiling before the cancellation reached it, which is why that one leg still shows green. None of the four are required checks: only the two Wire compat contexts are (scripts/ruleset-drift.sh reads the ruleset back and confirms that set). There's nothing left to fix from this container — the one real failure is the pin, and it stays red until a maintainer applies the workflow patch below, since dobby-coder has no workflows: write.

What this PR does

test-wasm-browsers is wrapped in nick-fields/retry@v3 with retry_on: error and a 20-minute per-attempt timeout, and its command: input carries a literal backslash (--\${{ matrix.browser }}). Both are defects #416 found and settled:

  • The retry is inverted. A timeout is not error in that action's taxonomy, so max_attempts: 2 never engaged on the only failure shape this job has hit — three wedged safari sessions on 2026-09-03, ~22 minutes each with ~17 minutes of total silence. Meanwhile a genuine non-zero exit does get retried, hiding a real failure behind a second roll.
  • The backslash only worked because the action handed its command: string to a shell that stripped it before wasm-pack ever saw it.

Since dobby-coder has no workflows: write, .github/workflows/build.yml isn't touched by this PR. This PR adds the pin: the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper in pg-core/tests/ci_wiring.rs, asserting against test-wasm-browsers' job block:

  1. it carries a job-level timeout-minutes
  2. no step uses nick-fields/retry
  3. the test step is the bare, backslash-free run: wasm-pack test --release --headless --${{ matrix.browser }} ./pg-wasm
  4. all three browsers (chrome, firefox, safari) stay in the matrix

These assertions are RED on this branch, on purpose, until the workflow half below is applied — same shape as #429/#438.

The workflow patch (a maintainer applies this)

A one-paste gh api -X PUT command that applies this directly to this PR's branch (no checkout needed) is in this comment — also posted on #432 per @rubenhensen's amendment there.

Replace the whole test-wasm-browsers job (currently build.yml:81-107) with:

  test-wasm-browsers:
    name: Run wasm tests in browsers
    strategy:
      matrix:
        include:
          - browser: chrome
            os: ubuntu-latest
          - browser: firefox
            os: ubuntu-latest
          - browser: safari
            os: macos-latest
    runs-on: ${{ matrix.os }}
    # The suite is 16 tests and finishes in ~25s; a passing job is 2-6 minutes,
    # almost all of it `cargo install wasm-pack` and the release build. 12
    # minutes is ~2x the slowest observed success. The previous budget was 20
    # minutes inside a `nick-fields/retry` wrapper, which on 2026-09-03 turned
    # three wedged safari sessions into ~22-minute jobs with ~17 minutes of
    # silence each (#416).
    timeout-minutes: 12
    env:
      # ~6x the slowest single test (~5s). This is a per-test timer running
      # inside the browser page, so it does NOT bound a wedged safaridriver
      # session -- that is what `timeout-minutes` above is for. It was 120,
      # which is both 24x the slowest test and, at 16 tests, a 32-minute
      # worst case that the job budget could never reach.
      WASM_BINDGEN_TEST_TIMEOUT: 30
    steps:
      - uses: actions/checkout@v4
      - name: Install
        run: cargo install wasm-pack
      - if: ${{ matrix.browser == 'firefox' }}
        run: sudo apt update && sudo apt install firefox
      # A plain `run:`, not `nick-fields/retry`. The wrapper retried genuine
      # non-zero exits (hiding a real failure behind a second roll) and did
      # NOT retry a timeout, which is the only shape this job has ever hit
      # -- `retry_on: error` excludes timeouts, so `max_attempts: 2` never
      # engaged. Dropping it also removes the literal backslash the action
      # input required (`--\${{ matrix.browser }}`), which survived into the
      # resolved command and only worked because a shell stripped it.
      - name: Run wasm-pack browser tests
        run: wasm-pack test --release --headless --${{ matrix.browser }} ./pg-wasm

Three substantive changes: timeout-minutes: 12 at job level, WASM_BINDGEN_TEST_TIMEOUT 120 → 30, and the retry action replaced by a bare run: with the backslash gone. The matrix, runs-on, checkout, cargo install wasm-pack and the firefox apt step are unchanged. no_workflow_step_captures_dollar_question_mark still passes against it — no step here captures $?.

Verification

cargo test --manifest-path pg-core/Cargo.toml --features test,rust,stream --test ci_wiring:

  • On this branch (unpatched build.yml): 15/16 pass, the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper fails as expected (no job-level timeout-minutes yet).
  • Against a local, uncommitted copy of build.yml with the patch above applied: all 16 pass, nothing else broke.

Checked each assertion is neither fail-open nor fail-closed-for-the-wrong-reason, against the same local patched copy:

  • delete timeout-minutes: 12 → assertion 1 (job-level timeout) goes red
  • restore it, re-add a nick-fields/retry@v3 step → assertion 2 (no retry wrapper) goes red
  • restore it, put the backslash back in --\${{ matrix.browser }} → assertion 3 (bare run, no backslash) goes red
  • restore it, drop the safari matrix entry → assertion 4 (all three browsers) goes red

One thing this caught along the way: the patch's own explanatory comments mention nick-fields/retry by name in prose (e.g. "not nick-fields/retry"), so a naive job.contains("nick-fields/retry") check false-reds even after the correct patch lands. Assertion 2 checks for the literal uses: nick-fields/retry invocation instead.

After verifying, the local workflow edit was fully reverted — git diff --name-only origin/main...HEAD -- .github/workflows/ prints nothing; no .github/workflows/ changes are part of this PR.

cargo fmt/cargo clippy (--features test,rust,stream -- -D warnings) pass clean on pg-core.

Explicitly out of scope, per #432: filing an issue when this job goes red — deferred to the fleet-wide issue-filing convergence question (#416).

Done when

  • .github/workflows/build.yml on main carries the job exactly as in the patch above (maintainer action)
  • The four assertions exist in pg-core/tests/ci_wiring.rs
  • A Run wasm tests in browsers run on main is green on all three legs after the patch lands

Reviewed by dobby: code-comments rule (only rule in force) and Review Dobby 2 findings, over the full PR diff (pg-core/tests/ci_wiring.rs) — pg-core built clean, cargo fmt --check and cargo clippy --features test,rust,stream -- -D warnings pass, cargo test --test ci_wiring independently reproduced 15/16 passing with the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper failing at line 1028 exactly as documented — approve.
Attention: pg-core/tests/ci_wiring.rs:1028 — that failing assertion is RED by design (dobby-coder lacks workflows: write) pending a maintainer applying the build.yml patch already posted on this PR and on #432; independently reverified against a local patched copy (16/16 pass), then reverted. No PR Dobby action needed.

…i_wiring

The `nick-fields/retry@v3` wrapper around `test-wasm-browsers` inverted its
own failure handling: `retry_on: error` never retries a timeout, the only
failure shape this job has actually hit (three wedged safari sessions on
2026-09-03, ~22 minutes each with ~17 of silence), while it does retry a
genuine non-zero exit that should just have been reported. Its `command:`
input also carried a literal backslash (`--\${{ matrix.browser }}`) that
only worked because the action handed the string to a shell that stripped
it.

`dobby-coder` has no `workflows: write`, so the fix -- a job-level
`timeout-minutes: 12`, `WASM_BINDGEN_TEST_TIMEOUT` 120 -> 30, and the
wrapper replaced by a bare `run:` with the backslash gone -- is posted as
a comment on #432 for a maintainer to apply, not pushed here.

Adds `the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper` to
pg-core/tests/ci_wiring.rs: the job carries a job-level `timeout-minutes`,
no step uses `nick-fields/retry`, the test command is the bare,
backslash-free `run:` line, and all three browsers stay in the matrix.
Verified locally against a scratch copy of the patch: the four checks pass
once applied, and each goes red on its own when the corresponding half of
the regression is reintroduced (timeout removed, retry wrapper restored,
backslash restored, safari dropped from the matrix).

This assertion is red on this branch until the workflow patch lands, same
shape as #429/#438.

Part of #247. Implements #416's decisions for #432.
@dobby-coder
dobby-coder Bot requested a review from rubenhensen September 10, 2026 07:51
@dobby-coder

dobby-coder Bot commented Sep 10, 2026

Copy link
Copy Markdown
Contributor Author

Workflow patch for test-wasm-browsers (.github/workflows/build.yml)

dobby-coder has no workflows: write and cannot push this file, so it's written out in full here for a maintainer to apply — see #440's "CI status" for why the PR's Test workspace (pg-core) check is red until this lands. Applies to dobby/issue-432-wasm-browser-ci-timeout (PR #440), no checkout needed.

Replaces the whole test-wasm-browsers job (currently build.yml:81-107) with:

  test-wasm-browsers:
    name: Run wasm tests in browsers
    strategy:
      matrix:
        include:
          - browser: chrome
            os: ubuntu-latest
          - browser: firefox
            os: ubuntu-latest
          - browser: safari
            os: macos-latest
    runs-on: ${{ matrix.os }}
    # The suite is 16 tests and finishes in ~25s; a passing job is 2-6 minutes,
    # almost all of it `cargo install wasm-pack` and the release build. 12
    # minutes is ~2x the slowest observed success. The previous budget was 20
    # minutes inside a `nick-fields/retry` wrapper, which on 2026-09-03 turned
    # three wedged safari sessions into ~22-minute jobs with ~17 minutes of
    # silence each (#416).
    timeout-minutes: 12
    env:
      # ~6x the slowest single test (~5s). This is a per-test timer running
      # inside the browser page, so it does NOT bound a wedged safaridriver
      # session -- that is what `timeout-minutes` above is for. It was 120,
      # which is both 24x the slowest test and, at 16 tests, a 32-minute
      # worst case that the job budget could never reach.
      WASM_BINDGEN_TEST_TIMEOUT: 30
    steps:
      - uses: actions/checkout@v4
      - name: Install
        run: cargo install wasm-pack
      - if: ${{ matrix.browser == 'firefox' }}
        run: sudo apt update && sudo apt install firefox
      # A plain `run:`, not `nick-fields/retry`. The wrapper retried genuine
      # non-zero exits (hiding a real failure behind a second roll) and did
      # NOT retry a timeout, which is the only shape this job has ever hit
      # -- `retry_on: error` excludes timeouts, so `max_attempts: 2` never
      # engaged. Dropping it also removes the literal backslash the action
      # input required (`--\${{ matrix.browser }}`), which survived into the
      # resolved command and only worked because a shell stripped it.
      - name: Run wasm-pack browser tests
        run: wasm-pack test --release --headless --${{ matrix.browser }} ./pg-wasm

Three substantive changes: timeout-minutes: 12 at job level, WASM_BINDGEN_TEST_TIMEOUT 120 → 30, and the retry action replaced by a bare run: with the backslash gone. The matrix, runs-on, checkout, cargo install wasm-pack and the firefox apt step are unchanged.

Verified locally (applied uncommitted, reverted after): with this patch, cargo test --manifest-path pg-core/Cargo.toml --features test,rust,stream --test ci_wiring goes 16/16, including the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper, which is red without it.

One command applies it directly to the PR branch, no checkout needed:

gh api -X PUT repos/encryption4all/postguard/contents/.github/workflows/build.yml -f branch=dobby/issue-432-wasm-browser-ci-timeout -f message="ci: honest timeout and no retry-wrapper for test-wasm-browsers (#416)" -f sha="35336471dbc70abbca7ac0f220c43646f8852006" -f content=on:
  push:
    branches:
      - main
  pull_request:
    # `edited` included for base retargets (e.g. a stacked PR's base merging):
    # paths-filter's verdict depends on the base, and without `edited` a stale
    # verdict stays attached to the unchanged head sha.
    types: [opened, synchronize, reopened, edited]
    branches:
      - main
  workflow_dispatch:

name: Continuous integration

jobs:
  # sonarqube:
  #   name: SonarQube
  #   runs-on: ubuntu-latest
  #   continue-on-error: true
  #   steps:
  #     - uses: actions/checkout@v4
  #       with:
  #         fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
  #     - name: SonarQube Scan
  #       uses: SonarSource/sonarqube-scan-action@v6
  #       env:
  #         SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
  # The matrix keys on the crate directory rather than a `pg-` suffix, because
  # `cryptify` does not carry that prefix. This renames the check contexts from
  # `Test workspace (core)` to `Test workspace (pg-core)`; nothing required
  # points at them today (only the two `Wire compat` contexts are required), but
  # a ruleset added later must use the new names.
  test:
    name: Test workspace
    strategy:
      matrix:
        crate: [pg-core, pg-pkg, pg-cli, pg-ffi, cryptify]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - if: ${{ matrix.crate == 'pg-core' }}
        run: cargo test --manifest-path pg-core/Cargo.toml --features test,rust,stream
      # cryptify declares no features of its own, so `--all-targets` (what its
      # own CI ran) is the equivalent invocation.
      - if: ${{ matrix.crate == 'cryptify' }}
        run: cargo test --manifest-path cryptify/Cargo.toml --all-targets
      - if: ${{ matrix.crate != 'pg-core' && matrix.crate != 'cryptify' }}
        run: cargo test --manifest-path ${{ matrix.crate }}/Cargo.toml --all-features

  format:
    name: Format workspace
    strategy:
      matrix:
        crate: [pg-core, pg-pkg, pg-cli, pg-ffi, cryptify]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo fmt --manifest-path ${{ matrix.crate }}/Cargo.toml --all -- --check

  clippy:
    name: Clippy workspace
    strategy:
      matrix:
        crate: [pg-core, pg-pkg, pg-cli, pg-ffi, cryptify]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy
      - if: ${{ matrix.crate == 'pg-core' }}
        run: cargo clippy --manifest-path pg-core/Cargo.toml --all-targets --features test,rust,stream -- -D warnings
      - if: ${{ matrix.crate == 'cryptify' }}
        run: cargo clippy --manifest-path cryptify/Cargo.toml --all-targets -- -D warnings
      - if: ${{ matrix.crate != 'pg-core' && matrix.crate != 'cryptify' }}
        run: cargo clippy --manifest-path ${{ matrix.crate }}/Cargo.toml --all-targets --all-features -- -D warnings

  test-wasm-browsers:
    name: Run wasm tests in browsers
    strategy:
      matrix:
        include:
          - browser: chrome
            os: ubuntu-latest
          - browser: firefox
            os: ubuntu-latest
          - browser: safari
            os: macos-latest
    runs-on: ${{ matrix.os }}
    # The suite is 16 tests and finishes in ~25s; a passing job is 2-6 minutes,
    # almost all of it `cargo install wasm-pack` and the release build. 12
    # minutes is ~2x the slowest observed success. The previous budget was 20
    # minutes inside a `nick-fields/retry` wrapper, which on 2026-09-03 turned
    # three wedged safari sessions into ~22-minute jobs with ~17 minutes of
    # silence each (#416).
    timeout-minutes: 12
    env:
      # ~6x the slowest single test (~5s). This is a per-test timer running
      # inside the browser page, so it does NOT bound a wedged safaridriver
      # session -- that is what `timeout-minutes` above is for. It was 120,
      # which is both 24x the slowest test and, at 16 tests, a 32-minute
      # worst case that the job budget could never reach.
      WASM_BINDGEN_TEST_TIMEOUT: 30
    steps:
      - uses: actions/checkout@v4
      - name: Install
        run: cargo install wasm-pack
      - if: ${{ matrix.browser == 'firefox' }}
        run: sudo apt update && sudo apt install firefox
      # A plain `run:`, not `nick-fields/retry`. The wrapper retried genuine
      # non-zero exits (hiding a real failure behind a second roll) and did
      # NOT retry a timeout, which is the only shape this job has ever hit
      # -- `retry_on: error` excludes timeouts, so `max_attempts: 2` never
      # engaged. Dropping it also removes the literal backslash the action
      # input required (`--\${{ matrix.browser }}`), which survived into the
      # resolved command and only worked because a shell stripped it.
      - name: Run wasm-pack browser tests
        run: wasm-pack test --release --headless --${{ matrix.browser }} ./pg-wasm

  # ---------------------------------------------------------------------------
  # Wire compatibility: HEAD-sealed containers must open with published readers
  # (#251 / #260). #261 adds a wire-compat-js job that downloads the artifact
  # this job uploads.
  #
  # The path filter is a step, not an `on: paths:` key, on purpose: a job that
  # is skipped by a path filter never reports, so a required check would sit
  # pending forever on PRs that do not touch the wire surface. This shape always
  # reports and only does the expensive work when it needs to.
  #
  # On `push` the filter is the wrong instrument and is bypassed (#299). It
  # diffs only the push that triggered it, so a commit that reached `main`
  # without this gate ever running is never re-checked afterwards -- and the job
  # still reports green, because "filter said no" and "gate passed" are the same
  # success. That is not hypothetical: #297 changed seven files under
  # `pg-compat/**` and merged during the 2026-08-06 Actions outage with no run
  # at all, and the three `main` runs after it (506144c2, c1682ba7, 1238389b)
  # each reported `Wire compat: success` with `Seal`/`Open` both skipped. So on
  # a push the gate always does the real work: whatever is on `main` is what
  # gets sealed and opened, however it got there.
  # ---------------------------------------------------------------------------
  wire-compat-rust:
    name: Wire compat (published pg-core)
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read # paths-filter reads the PR's changed files
    # wire-compat-js (#261) opens the same bytes with the published npm readers.
    # It downloads the artifact the seal step below produces, so it gates on the
    # same outcome the upload gates on rather than re-running the path filter and
    # drifting out of step with it.
    outputs:
      sealed: ${{ steps.seal.outcome }}
    steps:
      - uses: actions/checkout@v4
      # SHA-pinned as the one action new to this repo; the rest follow the
      # file's existing floating-ref convention.
      - uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
        id: changes
        with:
          filters: |
            wire:
              - 'pg-core/**'
              - 'pg-wasm/**'
              - 'pg-compat/**'
              - 'pg-compat-js/**'
              # pg-core has no lockfile of its own: the bytes HEAD seals are a
              # function of the ROOT lockfile (a bincode-next/ibe/serde bump
              # touches only these two files). Root Cargo.toml also holds the
              # exclude list that keeps pg-compat on crates.io pg-core.
              - 'Cargo.lock'
              - 'Cargo.toml'
              - '.github/workflows/build.yml'

      # One decision, read by every step below, so the push override cannot be
      # applied to the seal but forgotten on the open.
      - name: Decide whether to do the real work
        id: gate
        shell: bash
        env:
          WIRE_CHANGED: ${{ steps.changes.outputs.wire }}
        run: |
          if [[ "$WIRE_CHANGED" == "true" || "$GITHUB_EVENT_NAME" == "push" ]]; then
            echo "run=true" >> "$GITHUB_OUTPUT"
          else
            echo "run=false" >> "$GITHUB_OUTPUT"
          fi

      - if: steps.gate.outputs.run == 'true'
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy, rustfmt

      - name: Seal the sample set with HEAD
        id: seal
        if: steps.gate.outputs.run == 'true'
        shell: bash
        run: |
          cargo run --locked -p pg-core --features stream --example seal-samples \
            -- "$RUNNER_TEMP/wire-compat-artifacts"

      # Hand-off to wire-compat-js (#261). Uploaded before the reader runs so a
      # red gate still leaves the bytes that broke it.
      - name: Upload the sample set
        if: steps.seal.outcome == 'success'
        uses: actions/upload-artifact@v4
        with:
          name: wire-compat-artifacts-${{ github.event.pull_request.head.sha || github.sha }}
          path: ${{ runner.temp }}/wire-compat-artifacts
          retention-days: 7

      - name: Open it with published pg-core
        if: steps.gate.outputs.run == 'true'
        shell: bash
        env:
          PG_COMPAT_ARTIFACTS: ${{ runner.temp }}/wire-compat-artifacts
        run: cargo test --manifest-path pg-compat/Cargo.toml --locked

  # pg-compat is outside the workspace, so the per-crate fmt/clippy matrices do
  # not cover it. Kept separate from wire-compat-rust on purpose: a new stable
  # rustc lint must not red a required check named after wire compatibility,
  # nor pre-empt the seal/read steps that answer it.
  pg-compat-lint:
    name: Lint pg-compat
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
        id: changes
        with:
          filters: |
            wire:
              - 'pg-compat/**'
              - 'Cargo.lock'
              - 'Cargo.toml'
              - '.github/workflows/build.yml'
      - if: steps.changes.outputs.wire == 'true'
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy, rustfmt
      - name: Format pg-compat
        if: steps.changes.outputs.wire == 'true'
        run: cargo fmt --manifest-path pg-compat/Cargo.toml --all -- --check
      - name: Clippy pg-compat
        if: steps.changes.outputs.wire == 'true'
        run: cargo clippy --manifest-path pg-compat/Cargo.toml --all-targets --locked -- -D warnings

  # ---------------------------------------------------------------------------
  # Public-API semver gate (#253). Fails a PR that breaks pg-core's or pg-wasm's
  # public API without declaring the break.
  #
  # Versions here are bumped by release-plz, not by the PR that makes the
  # change, so "declared" means the conventional-commit `!` marker that
  # release-plz turns into a major bump. The marker is read off the PR title
  # into SEMVER_RELEASE_TYPE; `edited` is already in this file's trigger list,
  # so adding the `!` to the title re-runs the gate.
  #
  # Same always-reports shape as wire-compat-rust: the path filter is a step,
  # not an `on: paths:` key, so a required check never sits pending.
  # ---------------------------------------------------------------------------
  semver-checks:
    name: Public API semver
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read # paths-filter reads the PR's changed files
    steps:
      # pg-wasm is not published to crates.io, so its baseline is origin/main
      # rather than a registry version, and the full history has to be here.
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
        id: changes
        with:
          filters: |
            api:
              - 'pg-core/**'
              - 'pg-wasm/**'
              - 'Cargo.toml'
              - 'Cargo.lock'
              - 'scripts/semver-checks.sh'
              - 'scripts/semver-checks-test.sh'
              - '.github/workflows/build.yml'

      # Stubs cargo, so it needs no toolchain and runs in under a second. It
      # covers the 100-vs-101 exit-code mapping the gate depends on: 100 is a
      # semver violation, 101 is the tool or the build failing.
      - name: Test the gate script
        if: steps.changes.outputs.api == 'true'
        shell: bash
        run: ./scripts/semver-checks-test.sh

      - if: steps.changes.outputs.api == 'true'
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-unknown-unknown

      # Pinned release binary rather than `cargo install` (a five-minute build)
      # or a fourth third-party action. Bump the version and the digest together.
      - name: Install cargo-semver-checks
        if: steps.changes.outputs.api == 'true'
        shell: bash
        env:
          VERSION: 0.49.0
          SHA256: 72f6834d75d28a66e02c9fd6a230ce901bb30eee6067b85867a97445df040e4a
        run: |
          curl -sSfL -o "$RUNNER_TEMP/cargo-semver-checks.tar.gz" \
            "https://github.com/obi1kenobi/cargo-semver-checks/releases/download/v${VERSION}/cargo-semver-checks-x86_64-unknown-linux-gnu.tar.gz"
          echo "${SHA256}  $RUNNER_TEMP/cargo-semver-checks.tar.gz" | sha256sum -c -
          tar -xzf "$RUNNER_TEMP/cargo-semver-checks.tar.gz" -C "$HOME/.cargo/bin" cargo-semver-checks

      # The PR title, not the commit subject: PRs are squash-merged here, so the
      # title is what release-plz and the Conventional Commit check read. Passed
      # through the environment rather than interpolated into the script, so a
      # PR title cannot inject shell.
      #
      # The title `!` is the only accepted declaration. A `BREAKING CHANGE:`
      # footer in the PR *body* is deliberately not accepted: this repo's
      # squash_merge_commit_message is COMMIT_MESSAGES, so the body never reaches
      # the squashed commit, and release-plz reads commits. Honouring a body-only
      # footer would pass the gate on a `fix(pg-core):` PR that release-plz then
      # publishes as a patch release of a breaking change.
      - name: Read the breaking-change declaration off the PR title
        id: declared
        if: steps.changes.outputs.api == 'true'
        shell: bash
        env:
          PR_TITLE: ${{ github.event.pull_request.title }}
        run: |
          if [[ "$PR_TITLE" =~ ^[a-zA-Z]+(\([^\)]*\))?!: ]]; then
            echo "Breaking change declared in the PR title; a major bump is allowed."
            echo "release_type=major" >> "$GITHUB_OUTPUT"
          else
            echo "No '!' in the PR title; any breaking change will fail the gate."
          fi

      - name: Check the public API
        if: steps.changes.outputs.api == 'true'
        shell: bash
        env:
          SEMVER_RELEASE_TYPE: ${{ steps.declared.outputs.release_type }}
        run: ./scripts/semver-checks.sh
  # The Node half of the same gate (#261): the containers wire-compat-rust
  # sealed must also open with the published npm readers in COMPATIBILITY.md's
  # support window. It downloads rather than re-seals, so both halves are held
  # to the same bytes and a non-deterministic sealer cannot hide between them.
  #
  # `if: !cancelled()` rather than the default: a red wire-compat-rust is
  # exactly when it is worth knowing whether the JS readers broke the same way,
  # and the artifact is uploaded before that job's read step for this reason.
  # Without it, `needs` would skip this job on the run where it has the most to
  # say.
  # ---------------------------------------------------------------------------
  wire-compat-js:
    name: Wire compat (published pg-wasm/pg-js)
    runs-on: ubuntu-latest
    needs: wire-compat-rust
    if: ${{ !cancelled() }}
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v4

      # Every step below is behind the seal outcome, not just the download.
      # `outcome` is 'skipped' when the path filter said no (nothing to open,
      # report success) and 'failure' when sealing itself broke (wire-compat-rust
      # owns that failure; do not report it twice).
      - if: needs.wire-compat-rust.outputs.sealed == 'success'
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: npm
          cache-dependency-path: pg-compat-js/package-lock.json

      - name: Download the sample set
        if: needs.wire-compat-rust.outputs.sealed == 'success'
        uses: actions/download-artifact@v4
        with:
          name: wire-compat-artifacts-${{ github.event.pull_request.head.sha || github.sha }}
          path: ${{ runner.temp }}/wire-compat-artifacts

      # ci, not install: the readers are pinned by pg-compat-js/package-lock.json,
      # and a gate that quietly resolved a different reader would be measuring
      # something other than the support window.
      - name: Install the published readers
        if: needs.wire-compat-rust.outputs.sealed == 'success'
        shell: bash
        working-directory: pg-compat-js
        run: npm ci

      - name: Open the set with published pg-wasm/pg-js
        if: needs.wire-compat-rust.outputs.sealed == 'success'
        shell: bash
        working-directory: pg-compat-js
        env:
          PG_COMPAT_ARTIFACTS: ${{ runner.temp }}/wire-compat-artifacts
        run: npm test

  # ---------------------------------------------------------------------------
  # Single required check consolidating the two halves above (#262). The
  # repoint happened in #296: "Wire compat" is the one required context, and the
  # two per-language names are no longer required individually. Since #299 it is
  # also the sole context of the `main: required checks` ruleset, whose
  # `bypass_actors` is empty -- so unlike classic protection (`enforce_admins`
  # is still false) this name cannot be merged past with `--admin`. Renaming
  # this job silently disarms that ruleset; rename the ruleset's context in the
  # same change.
  #
  # `if: !cancelled()` for the same reason as wire-compat-js above: this job
  # must still run and report when an upstream half failed, or the required
  # check sits pending forever instead of turning red.
  # ---------------------------------------------------------------------------
  wire-compat:
    name: Wire compat
    runs-on: ubuntu-latest
    needs: [wire-compat-rust, wire-compat-js]
    if: ${{ !cancelled() }}
    permissions:
      contents: read
    steps:
      - name: Require both halves to have passed
        shell: bash
        run: |
          echo "wire-compat-rust: ${{ needs.wire-compat-rust.result }}"
          echo "wire-compat-js: ${{ needs.wire-compat-js.result }}"
          if [[ "${{ needs.wire-compat-rust.result }}" != "success" || "${{ needs.wire-compat-js.result }}" != "success" ]]; then
            exit 1
          fi

  # ---------------------------------------------------------------------------
  # The registry half of the wiring guards (#318).
  #
  # `pg-core/tests/ci_wiring.rs` asserts that the job above is still *named*
  # `Wire compat`. This asserts the other end of that link: that the `main`
  # ruleset still *requires* that context. Neither end is sufficient. A context
  # required but not produced blocks nothing (#299 measured that an absent check
  # is as dangerous as a red one); a context produced but not required enforces
  # nothing while every test stays green.
  #
  # Both #272 and postguard-js#222 declared this end unreachable from CI, on the
  # assumption it needs an admin credential. Measured in #318: it does not. On a
  # public repo the effective-rules endpoint answers 200 to the built-in token
  # at any permission level, so `contents: read` below is already more than this
  # needs, and no secret is involved.
  #
  # Deliberately NOT part of the `Wire compat` aggregator and deliberately not a
  # required context: this reads a live third-party API, and a GitHub API outage
  # must not become an unmergeable repo. Exit 2 (undetermined) is therefore a
  # distinct outcome from exit 1 (drift) -- see scripts/ruleset-drift.sh.
  #
  # And deliberately no `schedule:`. A nightly would detect drift during quiet
  # periods, but a disarmed gate can only do harm when something merges, and
  # every merge here passes through a `pull_request` and a `push` run of this
  # workflow. Running at exactly the moment the gate is relied upon also makes
  # the result unmissable, which a scheduled run is not -- the ticket's own
  # warning was that a drift detector nobody reads is itself a silent gate.
  # ---------------------------------------------------------------------------
  ruleset-drift:
    name: Ruleset still requires the gate
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v4
        with:
          # The changelog-coverage checker's self-test below (#412) runs
          # against fixtures that are real tags in this repo's history, so the
          # job needs full history and tags -- the default shallow checkout
          # makes the coverage script report exit 2 (undetermined) on every
          # one of them instead of exercising the case.
          fetch-depth: 0

      - name: Compare the live ruleset against the guard's constant
        shell: bash
        env:
          # Not required for the read -- unauthenticated works on a public repo.
          # It is passed because the runner's anonymous budget is 60/hour per
          # shared IP, and exhausting it would show up as exit 2 noise.
          GH_TOKEN: ${{ github.token }}
        run: scripts/ruleset-drift.sh

      - name: Exit codes still mean what the gate reports
        shell: bash
        run: scripts/ruleset-drift-test.sh

      - name: Test the changelog-coverage checker
        shell: bash
        run: scripts/changelog-coverage-test.sh

      - name: Test the wasm-package checker
        shell: bash
        run: scripts/wasm-package-check-test.sh

      - name: Test the changelog-coverage reporter
        shell: bash
        run: scripts/changelog-coverage-report-test.sh


`dobby-coder` has no `workflows: write`, so #440 landed the four
`ci_wiring.rs` assertions deliberately RED and posted this build.yml
patch for a maintainer. Applied verbatim from that comment, which is
itself verbatim from #432's section 1.

Three substantive changes to `test-wasm-browsers`: a job-level
`timeout-minutes: 12` (~2x the slowest observed success, against a
20-minute budget that was ~48x the suite's 24.68s runtime),
`WASM_BINDGEN_TEST_TIMEOUT` 120 -> 30, and `nick-fields/retry` replaced
by a bare `run:`. The wrapper was configured backwards -- `retry_on:
error` re-rolled genuine non-zero exits while never engaging for a
timeout, the only shape this job has ever hit. Dropping it also deletes
the literal backslash in `--\${{ matrix.browser }}`, which survived into
the resolved command and worked only because the action handed it to a
shell that stripped it.

The matrix, `runs-on`, checkout, `cargo install wasm-pack` and the
firefox apt step are unchanged; all three browsers stay, safari included.

With this applied, `--test ci_wiring` is 16/16 locally, including
`the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper` and
#429's `no_workflow_step_captures_dollar_question_mark`.
@rubenhensen

Copy link
Copy Markdown
Contributor

Workflow half applied — .github/workflows/build.yml, commit 8b81b1c, taken verbatim from the posted patch (which is itself verbatim from #432 section 1). All 41 checks pass, Test workspace (pg-core) included, so the_wasm_browser_job_has_an_honest_timeout_and_no_retry_wrapper is green and so is #429's no_workflow_step_captures_dollar_question_mark.

The new budget is confirmed honest by this run rather than by argument. All three legs passed well inside timeout-minutes: 12: safari 3m21s, firefox 4m9s, chrome 2m51s. That is against a 20-minute budget which #416 measured at ~48x the suite's 24.68s runtime, and it leaves the slowest leg at about a third of the new ceiling.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

wasm browser job: an honest timeout, no retry wrapper, and ci_wiring pins so the patch cannot be unapplied

1 participant