Skip to content

feat: check the map body's two stated budgets - #452

Merged
rubenhensen merged 4 commits into
mainfrom
dobby/map-budget-445
Sep 23, 2026
Merged

rubenhensen merged 4 commits into
mainfrom
dobby/map-budget-445

Conversation

@dobby-coder

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

Copy link
Copy Markdown
Contributor

What this does

Implements #445: two checks on issue #247's stated budgets, which #442
rewrote and capped but left unenforced.

  • scripts/map-budget.sh <path-to-body-file>: checks a body file against
    the 153,600-byte (150 KiB) total budget (## Notes) and the 400-byte
    per-entry cap on ## Decisions so far (that section's own header
    comment). Both are UTF-8 byte counts. Exit 0 means within budget, 1 a
    real finding, 2 could not determine; the three are never conflated.
  • scripts/map-budget-test.sh: an offline self-test, 13 cases, including
    the em-dash case (400 characters, over 400 bytes), a heading-level typo
    that must not satisfy the section check, and a permanent known-good
    fixture.
  • scripts/testdata/map-247-body.md: a byte-for-byte snapshot of Wayfinder: fleet remediation — enforce the seams, kill silent failure (2026-07 audit) #247's
    real body, taken via gh issue view 247 -R encryption4all/postguard --json body -q .body on 2026-09-23 (68,356 bytes). A snapshot, not a
    live copy.
  • One new assertion in pg-core/tests/ci_wiring.rs,
    the_map_budget_checkers_self_test_runs_in_ci, modeled on
    the_wasm_package_checkers_self_test_runs_in_ci per the issue's
    pre-flight amendment.

Why this assertion is RED on this branch

dobby-coder has no workflows: write, so it cannot push under
.github/workflows/. The new ci_wiring.rs assertion expects
build.yml's ruleset-drift job to run scripts/map-budget-test.sh
alongside its four existing self-tests; that step is posted below for a
maintainer to apply, not pushed here. This is deliberate, not an oversight:
see the issue's §3 and the test's own doc comment.

git diff --name-only origin/main...HEAD -- .github/workflows/ is empty on
this branch. Confirmed nothing else regressed: every other check on this PR
is green except the four cascading from this one via the test job's
matrix (no fail-fast: false) -- Test workspace (pg-ffi), (pg-cli),
(pg-pkg) and (cryptify) all show cancelled at the API level, not a
second failure. Nothing here is fixable from this container; this is the
"cannot be fixed from here" case, not an oversight left unaddressed.

This PR's two comments below are a ready-to-apply handover, not just the
diffs in this description: each posts the full resulting file (so a
maintainer reviews exactly what will run with the repo's secrets, not a
diff) followed by one gh api -X PUT command that computes its own current
sha and needs no checkout to run.

CI on this PR

Test workspace (pg-core) fails on exactly the one assertion above (18/19
pass). build.yml's test job is a crate matrix with no fail-fast: false, so that one failure cancels its still-running matrix siblings.
Test workspace (cryptify), Test workspace (pg-cli) and Test workspace (pg-pkg) show red/cancelled as a result, not because of anything they ran
themselves; the same cancellation pattern is present on the pre-title-fix
run too, so it is not something this push introduced. Wire compat, the
ruleset's one required check, is green. The PR title also failed
Conventional Commit on open (no type prefix) and has since been
retitled; that check is green now.

Revised since review

Three findings from review of this PR.

Two fixed in 1295b8a:

  • scripts/map-budget.sh's BODY_BUDGET_BYTES was 150000 (decimal-KB
    math), while its own comment claimed that figure came from Wayfinder: fleet remediation — enforce the seams, kill silent failure (2026-07 audit) #247's
    header. The header only says "keep the body under 150 KB", never an
    exact byte count -- and that same sentence states GitHub's hard cap as
    an exact binary-KB conversion (262,144 = 256*1024). Read the same
    way, "150 KB" is 153,600 bytes, not 150,000 -- a body sized
    150,000-153,600 bytes was being flagged over budget despite being
    within the issue's actual intended budget. Constant, comment,
    scripts/map-budget-test.sh, and this description all updated to
    match.
  • The posted (not committed here -- no workflows: write) map-budget.yml
    patch's dedup step read gh api repos/.../comments --jq '.[-1].body'
    with no pagination, so once Wayfinder: fleet remediation — enforce the seams, kill silent failure (2026-07 audit) #247 crosses the API's default 30-comment
    page size the dedup silently stops seeing the true most recent comment,
    reintroducing the edit-storm spam it exists to prevent. The patch below
    now paginates and round-trips the comment body through base64 -- a
    plain tail -n 1 on unencoded, multi-line jq output would grab only
    the last line of the last page's comment, not the whole last comment.
    Verified locally against a stubbed gh returning a multi-page,
    multi-line response. Also revised in the matching patch comment on
    check the map body's two stated budgets: 150 KB total, 400 bytes per index entry #445.

Fixed in e1710db:

  • scripts/map-budget.sh's heading-existence check (grep -qF '## Decisions so far') and the awk section-extractor just below it (^## Decisions so far) disagreed on what counts as the heading: the existence check is
    unanchored, so it matched the string anywhere in a line, including inside
    a heading-level typo like ### Decisions so far; the extractor is
    anchored and never matches that line, so the section came back empty and
    every entry inside it was silently skipped. A body with that typo and a
    450-byte entry inside it exited 0 "OK" -- the exact "reported as 0 when
    it can't parse" case the module comment disclaims. Anchored the existence
    check the same way as the extractor (grep -qE '^## Decisions so far').
    Added a committed regression case to scripts/map-budget-test.sh; the
    existing 12 cases are unaffected.

The two workflow patches (posted on #445, not committed here)

Both are also posted as a comment on the issue, per §4 of the ticket, and as
two ready-to-apply comments on this PR itself (full file + one-paste gh api
command each): build.yml,
new map-budget.yml.

(a) build.yml: adds the self-test step to ruleset-drift, after the
existing five.

--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -515,3 +515,7 @@ jobs:
       - name: Test the ruleset-drift reporter
         shell: bash
         run: scripts/ruleset-drift-report-test.sh
+
+      - name: Test the map-budget checker
+        shell: bash
+        run: scripts/map-budget-test.sh

(b) A new .github/workflows/map-budget.yml: the live check, gated on
the wayfinder:map label, triggered on issues: edited (plus
workflow_dispatch), never a push. Writes github.event.issue.body to a
file via env:, never interpolated into run:. Runs
scripts/map-budget.sh as a bare command; on exit 1 comments on the issue
(deduped against the most recent comment); on exit 2 prints ::error:: and
comments nothing. Not wired into any required context.

diff --git a/.github/workflows/map-budget.yml b/.github/workflows/map-budget.yml
new file mode 100644
index 0000000..f18cd53
--- /dev/null
+++ b/.github/workflows/map-budget.yml
@@ -0,0 +1,93 @@
+name: Map budget
+#
+# Checks #247's two stated budgets on every edit to its body (#442, #445):
+# the whole body <=153,600 bytes (150 KiB), every "Decisions so far" entry
+# <=400 bytes. See scripts/map-budget.sh for the full rule, and why both
+# are byte counts rather than character counts.
+#
+# `issues: edited`, not a schedule: the event being budgeted is the body
+# changing, and that event exists. No `push` trigger either -- a push says
+# nothing about an issue body.
+#
+# Deliberately NOT a required context. It watches an issue body, which no PR
+# can fix, so making it required would block every merge on an edit nobody
+# on that PR could act on.
+
+on:
+  issues:
+    types: [edited]
+  workflow_dispatch:
+
+jobs:
+  map-budget:
+    name: Map body stays within budget
+    runs-on: ubuntu-latest
+    # The label, not the issue number, so a second wayfinder map is covered
+    # for free and no number is hardcoded in two places. `workflow_dispatch`
+    # carries no `issue`, so a manual run of this workflow as it stands
+    # always evaluates false and skips -- that is #445's decided shape, not
+    # an oversight; wiring a manual re-run to a specific issue would need an
+    # `issue_number` input this ticket does not ask for.
+    if: contains(github.event.issue.labels.*.name, 'wayfinder:map')
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Write the issue body to a file
+        env:
+          # Never interpolated into a `run:` block: the body is a Markdown
+          # document full of backticks and $(...) shell examples, and
+          # interpolating it would execute them.
+          ISSUE_BODY: ${{ github.event.issue.body }}
+        run: printf '%s' "$ISSUE_BODY" >"$RUNNER_TEMP/map-body.md"
+
+      - name: Check the map body's budgets
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+        run: |
+          # `if cmd; then ... else code=$?; fi` rather than
+          # `out=$(cmd); code=$?`: this step has no `shell:` key, so it runs
+          # as `bash -e {0}`, and a bare command substitution's own non-zero
+          # exit would abort the step before a following `code=$?` line was
+          # ever reached (#429, #422). `if`'s condition is exempt from `-e`,
+          # so this survives the failure -- but `$?` must be captured as the
+          # *first* thing in the `else` branch: bash resets `$?` to 0 for the
+          # `if` statement itself once the `then` branch is skipped, so a
+          # `code=$?` placed after `fi` instead would always read 0.
+          if output=$(scripts/map-budget.sh "$RUNNER_TEMP/map-body.md" 2>&1); then
+            echo "map-budget: OK -- within both stated budgets"
+            exit 0
+          else
+            code=$?
+          fi
+
+          if [[ $code -eq 2 ]]; then
+            echo "::error::scripts/map-budget.sh could not determine the map body's budgets (exit 2) -- the checker did not run to completion, this is not a finding"
+            printf '%s\n' "$output"
+            exit 2
+          fi
+
+          # Only 1 (a real finding) remains. Dedupe against the most recent
+          # comment so an edit storm does not spam the issue with the same
+          # finding repeatedly. `--paginate` walks every page -- without it,
+          # a plain `.[-1]` reads only the API's first page (30 comments by
+          # default), and once #247 crosses that count the dedup silently
+          # stops seeing the true most recent comment, reintroducing the
+          # edit-storm spam this step exists to prevent. The body
+          # round-trips through base64 because `--paginate` applies the
+          # `--jq` filter once per page and prints one result per page: a
+          # multi-line comment body would otherwise span multiple output
+          # lines, and `tail -n 1` would grab only its last line rather than
+          # the whole last comment.
+          last_comment=$(gh api --paginate "repos/$GH_REPO/issues/$ISSUE_NUMBER/comments" --jq '.[-1].body // "" | @base64' | tail -n 1 | base64 -d)
+          if [[ $last_comment == "$output" ]]; then
+            echo "map-budget: over budget, but the most recent comment already says so -- not reposting"
+          else
+            gh issue comment "$ISSUE_NUMBER" --body "$output"
+          fi
+          printf '%s\n' "$output"
+          exit 1

Verification

  • bash scripts/map-budget-test.sh: 13/13 pass, offline, no GH_TOKEN.
  • cargo test --manifest-path pg-core/Cargo.toml --features test,rust,stream:
    91 passed, 1 failed (the_map_budget_checkers_self_test_runs_in_ci,
    the expected RED assertion).
  • cargo fmt --manifest-path pg-core/Cargo.toml --all -- --check: clean.
  • cargo clippy --manifest-path pg-core/Cargo.toml --all-targets --features test,rust,stream -- -D warnings: clean. The bare --all-targets
    command from the issue's acceptance list needs the same test,rust,stream
    features the test command uses; that gap is pre-existing on origin/main
    and unrelated to this change.
  • scripts/map-budget.sh scripts/testdata/map-247-body.md exits 0.
  • Fail-open proof against a copy of the real fixture:
    • +90,000 bytes → exit 1, names 158356 against the 153600 budget.
    • one 401-byte - [ entry inside the section → exit 1, names 401 and
      the entry text.
    • the same entry placed after the section (past ## Not yet specified)
      → exit 0.
    • ## Decisions so far heading deleted → exit 2.
    • ## Decisions so far replaced with ### Decisions so far (heading-level
      typo) plus a 450-byte entry inside it → exit 2, not the 0 it returned
      before e1710db.
    • nonexistent path → exit 2.
  • Fail-open proof on the ci_wiring.rs assertion itself: applied the
    build.yml patch above locally (uncommitted) → cargo test --test ci_wiring goes green (19/19); deleted just the new step → reds again on
    exactly the_map_budget_checkers_self_test_runs_in_ci; reverted the local
    edit entirely (git checkout -- .github/workflows/build.yml).
  • Simulated the live workflow's bash locally against a stubbed gh: within
    budget → exit 0, no gh calls; over budget → exit 1, comment posted;
    over budget with an identical most-recent comment → exit 1, no repost;
    undetermined → exit 2, ::error::, no gh calls at all.

Part of #247.

🤖 Generated with Claude Code

Adds scripts/map-budget.sh, checking #247's body against its own stated
150,000-byte total budget and 400-byte-per-entry cap on "Decisions so
far", plus scripts/map-budget-test.sh pinning its 0/1/2 exit contract
offline. Graduated from #442's rewrite, which stated the numbers but
left them unchecked.

pg-core/tests/ci_wiring.rs gets one new assertion that build.yml's
ruleset-drift job runs the checker's self-test. It is RED on this
branch: dobby-coder has no workflows: write, so the build.yml step and
the new map-budget.yml live check are posted on #445 for a maintainer
to apply, not pushed here.

Part of #247.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
@dobby-coder
dobby-coder Bot requested a review from rubenhensen September 23, 2026 07:42
@dobby-coder dobby-coder Bot changed the title check the map body's two stated budgets feat: check the map body's two stated budgets Sep 23, 2026

@dobby-coder dobby-coder Bot left a comment

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Verdict: request-changes (posted as a COMMENT review — GitHub does not allow REQUEST_CHANGES/APPROVE on a PR authored by this same dobby-coder identity, so the event type below is a technical fallback, not the actual verdict).

Rule check: 5 rules bound this task (atomic-commits, code-comments, draft-pull-requests, no-summary-issues, test-suite-before-submit) — all compliant. Single well-described commit, comment density in the two new scripts matches their established neighbours (scripts/ruleset-drift.sh, scripts/wasm-package-check.sh), the PR is a draft, no summary issue was created, and the full pg-core suite plus fmt/clippy ran clean apart from the one documented, expected-red ci_wiring assertion.

Review findings: one bug in the committed script, one bug in the posted-but-not-committed map-budget.yml patch (can't be fixed by pushing here — no workflows: write — but the patch text itself, posted in this PR's description and on #445, can and should be revised before a maintainer applies it), and one non-blocking nit.

  • .github/workflows/map-budget.yml (posted as a patch in the PR description / on #445, not part of this diff): its dedup step reads gh api repos/$GH_REPO/issues/$ISSUE_NUMBER/comments --jq '.[-1].body // ""' with no --paginate/per_page, so it only ever sees the API's first page (30 comments). #247 already has 26 comments and is the project's active running map; once it crosses 30, .[-1] silently stops being the true most-recent comment and the dedup this step exists for breaks, reintroducing the edit-storm spam it was built to prevent. Please revise the posted patch (in the PR body and the #445 comment) to paginate or use per_page + a proper "last page" fetch before a maintainer applies it.

The scripts/map-budget.sh comment/constant mismatch below is the blocking finding; the nit on ci_wiring.rs is informational only.

Comment thread scripts/map-budget.sh Outdated
set -euo pipefail

# 150,000 bytes, stated in #247's "## Notes" header comment.
readonly BODY_BUDGET_BYTES=150000

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

BODY_BUDGET_BYTES=150000's comment (line 48) claims "150,000 bytes, stated in #247's own 'Notes' header comment" — but the header comment (gh issue view 247 --json body) only ever says "keep the body under 150 KB", never an exact byte figure. That same header sentence states GitHub's hard cap as an exact 262,144 bytes (= 256*1024), i.e. binary-KB math; under that same convention 150 KB reads as 153,600 bytes, 3,600 more than this constant. A body sized 150,000–153,600 bytes would be flagged over-budget here despite plausibly being within the issue's actual intended budget. Either fix the comment to stop claiming the header states an exact byte count (it's this script's own decimal-KB interpretation), or use 153600 if binary was intended. The same ambiguity applies to the out-of-scope 16,000-byte "Notes" figure mentioned at line 20 of this file.

fn the_map_budget_checkers_self_test_runs_in_ci() {
let job = job(&workflow(BUILD_WORKFLOW), "ruleset-drift", BUILD_WORKFLOW);
let steps = steps(&job);

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nit, not blocking: the_map_budget_checkers_self_test_runs_in_ci is the one cargo-test failure (18/19 pass) — fully expected and documented in both the test's own doc comment and the PR description: dobby-coder can't push .github/workflows/*.yml, so the build.yml step this asserts on is posted as a patch instead of committed. Needs a maintainer to apply the posted build.yml patch; no action needed here.

…header

#247's "## Notes" header comment says "keep the body under 150 KB", not an
exact byte figure, but that same sentence states GitHub's hard cap as an
exact binary-KB conversion (262,144 = 256*1024). Reading "150 KB" the same
way gives 153,600 bytes, not the 150,000 this script assumed -- a body
sized 150,000-153,600 bytes was being flagged over budget despite being
within the issue's actual intended budget.

Also fixes the comment that overclaimed the header states an exact byte
count.

Found in review of #452.
@dobby-coder

dobby-coder Bot commented Sep 23, 2026

Copy link
Copy Markdown
Contributor Author

Workflow handover (1/2): build.yml

dobby-coder has no workflows: write, so this can't be pushed to this branch from here — it needs a maintainer to apply it directly. This is the only thing keeping Test workspace (pg-core) red (the_map_budget_checkers_self_test_runs_in_ci, 18/19 pass otherwise); every other red/cancelled check on this PR is that one failure cascading through the test job's matrix (no fail-fast: false), not a separate problem.

The change is four lines appended to the end of the ruleset-drift job: a new self-test step for scripts/map-budget.sh, same shape as the four self-test steps already there. Full resulting file below, so you're reviewing exactly what would run with the repo's secrets, not a diff:

Full contents of .github/workflows/build.yml after the change
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
      # For the reporter's `gh issue create` below (#422). Only the
      # required_status_checks half of the ruleset is asserted anywhere in
      # this job: the review-requirement half lives in classic protection
      # (`required_approving_review_count`), and `/branches/main/protection`
      # 403s for the Actions token, so it cannot be read from CI at all.
      # `postguard-js` asserts its review rule only because it keeps that
      # rule in a ruleset instead.
      issues: write
    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 }}
          GH_REPO: ${{ github.repository }}
        run: scripts/ruleset-drift-report.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

      - name: Test the ruleset-drift reporter
        shell: bash
        run: scripts/ruleset-drift-report-test.sh

      - name: Test the map-budget checker
        shell: bash
        run: scripts/map-budget-test.sh

Applying it is one paste (computes the current sha itself, so it works whether or not this exact command has already been tried):

gh api -X PUT repos/encryption4all/postguard/contents/.github/workflows/build.yml -f branch=dobby/map-budget-445 -f message="ci: apply the workflow half of the map-budget patch (#445)" -f sha="$(gh api "repos/encryption4all/postguard/contents/.github/workflows/build.yml?ref=dobby/map-budget-445" --jq .sha)" -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
      # For the reporter's `gh issue create` below (#422). Only the
      # required_status_checks half of the ruleset is asserted anywhere in
      # this job: the review-requirement half lives in classic protection
      # (`required_approving_review_count`), and `/branches/main/protection`
      # 403s for the Actions token, so it cannot be read from CI at all.
      # `postguard-js` asserts its review rule only because it keeps that
      # rule in a ruleset instead.
      issues: write
    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 }}
          GH_REPO: ${{ github.repository }}
        run: scripts/ruleset-drift-report.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

      - name: Test the ruleset-drift reporter
        shell: bash
        run: scripts/ruleset-drift-report-test.sh

      - name: Test the map-budget checker
        shell: bash
        run: scripts/map-budget-test.sh


@dobby-coder

dobby-coder Bot commented Sep 23, 2026

Copy link
Copy Markdown
Contributor Author

Workflow handover (2/2): new map-budget.yml

The live check (#445): a new workflow, gated on the wayfinder:map label, triggered on issues: edited plus workflow_dispatch, never push. Reads github.event.issue.body via env: only (never interpolated into run:), runs scripts/map-budget.sh, comments on the issue on a real finding (deduped, paginated, against the most recent comment), and is not wired into any required context. Same reasoning as posted on #445; full file below since this is a new workflow that will run with the repo's secrets, not a diff:

Full contents of new .github/workflows/map-budget.yml
name: Map budget
#
# Checks #247's two stated budgets on every edit to its body (#442, #445):
# the whole body <=153,600 bytes (150 KiB), every "Decisions so far" entry
# <=400 bytes. See scripts/map-budget.sh for the full rule, and why both
# are byte counts rather than character counts.
#
# `issues: edited`, not a schedule: the event being budgeted is the body
# changing, and that event exists. No `push` trigger either -- a push says
# nothing about an issue body.
#
# Deliberately NOT a required context. It watches an issue body, which no PR
# can fix, so making it required would block every merge on an edit nobody
# on that PR could act on.

on:
  issues:
    types: [edited]
  workflow_dispatch:

jobs:
  map-budget:
    name: Map body stays within budget
    runs-on: ubuntu-latest
    # The label, not the issue number, so a second wayfinder map is covered
    # for free and no number is hardcoded in two places. `workflow_dispatch`
    # carries no `issue`, so a manual run of this workflow as it stands
    # always evaluates false and skips -- that is #445's decided shape, not
    # an oversight; wiring a manual re-run to a specific issue would need an
    # `issue_number` input this ticket does not ask for.
    if: contains(github.event.issue.labels.*.name, 'wayfinder:map')
    permissions:
      contents: read
      issues: write
    steps:
      - uses: actions/checkout@v4

      - name: Write the issue body to a file
        env:
          # Never interpolated into a `run:` block: the body is a Markdown
          # document full of backticks and $(...) shell examples, and
          # interpolating it would execute them.
          ISSUE_BODY: ${{ github.event.issue.body }}
        run: printf '%s' "$ISSUE_BODY" >"$RUNNER_TEMP/map-body.md"

      - name: Check the map body's budgets
        env:
          GH_TOKEN: ${{ github.token }}
          GH_REPO: ${{ github.repository }}
          ISSUE_NUMBER: ${{ github.event.issue.number }}
        run: |
          # `if cmd; then ... else code=$?; fi` rather than
          # `out=$(cmd); code=$?`: this step has no `shell:` key, so it runs
          # as `bash -e {0}`, and a bare command substitution's own non-zero
          # exit would abort the step before a following `code=$?` line was
          # ever reached (#429, #422). `if`'s condition is exempt from `-e`,
          # so this survives the failure -- but `$?` must be captured as the
          # *first* thing in the `else` branch: bash resets `$?` to 0 for the
          # `if` statement itself once the `then` branch is skipped, so a
          # `code=$?` placed after `fi` instead would always read 0.
          if output=$(scripts/map-budget.sh "$RUNNER_TEMP/map-body.md" 2>&1); then
            echo "map-budget: OK -- within both stated budgets"
            exit 0
          else
            code=$?
          fi

          if [[ $code -eq 2 ]]; then
            echo "::error::scripts/map-budget.sh could not determine the map body's budgets (exit 2) -- the checker did not run to completion, this is not a finding"
            printf '%s\n' "$output"
            exit 2
          fi

          # Only 1 (a real finding) remains. Dedupe against the most recent
          # comment so an edit storm does not spam the issue with the same
          # finding repeatedly. `--paginate` walks every page -- without it,
          # a plain `.[-1]` reads only the API's first page (30 comments by
          # default), and once #247 crosses that count the dedup silently
          # stops seeing the true most recent comment, reintroducing the
          # edit-storm spam this step exists to prevent. The body
          # round-trips through base64 because `--paginate` applies the
          # `--jq` filter once per page and prints one result per page: a
          # multi-line comment body would otherwise span multiple output
          # lines, and `tail -n 1` would grab only its last line rather than
          # the whole last comment.
          last_comment=$(gh api --paginate "repos/$GH_REPO/issues/$ISSUE_NUMBER/comments" --jq '.[-1].body // "" | @base64' | tail -n 1 | base64 -d)
          if [[ $last_comment == "$output" ]]; then
            echo "map-budget: over budget, but the most recent comment already says so -- not reposting"
          else
            gh issue comment "$ISSUE_NUMBER" --body "$output"
          fi
          printf '%s\n' "$output"
          exit 1

Applying it is one paste (this is a new file, so the sha lookup resolves empty and is ignored):

gh api -X PUT repos/encryption4all/postguard/contents/.github/workflows/map-budget.yml -f branch=dobby/map-budget-445 -f message="ci: add the map-budget live check workflow (#445)" -f sha="$(gh api "repos/encryption4all/postguard/contents/.github/workflows/map-budget.yml?ref=dobby/map-budget-445" --jq .sha)" -f content=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

@dobby-coder dobby-coder Bot left a comment

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Rule-compliance check against ~/dobby-rules.md (5 binding rules: atomic-commits, code-comments, draft-pull-requests, no-summary-issues, test-suite-before-submit) found no violations — the PR is a draft, its two commits are atomic and well-described (the second is a documented fix-up found in review), the full pg-core test suite plus fmt/clippy/offline self-tests were run and reported, no summary/report issues were created, and comment density in the new scripts matches its siblings (ruleset-drift.sh, changelog-coverage.sh) and ci_wiring.rs's existing assertions.

One bug survives from review: scripts/map-budget.sh's heading-existence check and its section-extraction disagree on what counts as the ## Decisions so far heading, which lets a heading-level typo silently defeat the entry budget check — exactly the case the script's own header disclaims ("Never reported as 0 -- a body that cannot be parsed is not a body within budget"). See inline comment for a reproduction and a verified one-line fix that keeps the existing 12/12 map-budget-test.sh suite green.

Verdict: changes requested (posted as a COMMENT review, not REQUEST_CHANGES — GitHub rejects that event on a PR authored by this same bot identity). That one fix is needed before this is ready to apply the posted workflow patches; leaving in draft.

Comment thread scripts/map-budget.sh Outdated
exit 2
fi

if ! grep -qF '## Decisions so far' "$path"; then

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This existence check and the section-extractor just below it (line 84, /^## Decisions so far/) disagree on what counts as the heading. grep -qF here is unanchored, so it matches ## Decisions so far as a substring anywhere in a line — including inside a heading-level typo like ### Decisions so far (three #s: drop the leading # and the rest is an exact substring match). But the awk extractor's ^## Decisions so far is anchored, and a three-# line never matches it, so found stays 0 and section comes back empty. Every entry inside that (mistyped) section is then silently skipped by the byte-cap loop below, and the script falls through to reporting exit 0 "OK" even when an entry in the section is well over the 400-byte cap — the exact case the module comment above disclaims ("Never reported as 0 -- a body that cannot be parsed is not a body within budget").

Reproduced: a body with a ### Decisions so far heading and a 450-byte entry inside it exits 0 today. Anchoring the existence check the same way as the awk extraction fixes it — the same input then correctly exits 2 (heading not found), and the full map-budget-test.sh suite (12/12) still passes unmodified.

Suggested change
if ! grep -qF '## Decisions so far' "$path"; then
if ! grep -qE '^## Decisions so far' "$path"; then

grep -qF '## Decisions so far' matched the string anywhere in a line,
including inside a heading-level typo like '### Decisions so far'. The
awk section-extractor right below it is anchored (^## Decisions so
far), so that typo left `found` unset there: the section came back
empty, every entry inside it was silently skipped, and the script fell
through to exit 0 "OK" -- the exact "reported as 0 when it can't
parse" case the module comment disclaims.

Anchor the existence check the same way as the extractor. Adds a
committed regression case to map-budget-test.sh: a '### Decisions so
far' typo with a 450-byte entry inside it now exits 2, not 0; the
existing 12 cases are unaffected.

Found in review of PR #452.

@dobby-coder dobby-coder Bot left a comment

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Verdict: APPROVE (posted as COMMENT — GitHub blocks self-approval; this PR's author is app/dobby-coder, the same identity as this review)

Rule check (5 binding rules) and review findings both clean.

Rule compliance (~/dobby-rules.md):

  • atomic-commits — three focused commits: add the checker + tests, fix the KB-budget arithmetic, fix the heading-anchor bug with a regression test.
  • code-comments — comment density in ci_wiring.rs and map-budget.sh matches their established siblings; no restated-obvious comments found.
  • draft-pull-requests — PR is open as a draft.
  • no-summary-issues — no issues created by dobby-coder; only comments on the pre-existing tracking issue (#445) and this PR carrying the workflow-patch handover.
  • test-suite-before-submit — scripts/map-budget-test.sh (13/13) and cargo test/fmt/clippy results are documented in the PR description, with the one expected-red assertion (the_map_budget_checkers_self_test_runs_in_ci) explained and pre-existing.

Review findings (from the prior review cycle, verified at head e1710db): the grep -qF → grep -qE '^## Decisions so far' fix correctly aligns the heading-existence check with the awk section extractor's anchor, closing the heading-typo false-pass. The new regression test is well-built and the full suite passes. CI red is confirmed pre-existing and out of this container's reach (no workflows: write), documented both in-code and in the PR body; the other three Test workspace failures are matrix cancellations cascading from that one red job, not independent findings.

No blocking issues. Staying in draft per the two workflow patches awaiting a maintainer to apply them (posted on #445 and on this PR).

)

Applies the two workflow patches posted on #445, which dobby-coder cannot
push without workflows: write:

- build.yml: a 'Test the map-budget checker' step in the ruleset-drift job,
  which turns the_map_budget_checkers_self_test_runs_in_ci green.
- map-budget.yml: checks the wayfinder:map issue body on every edit; comments
  on exit 1 (deduped against the latest comment), ::error:: on exit 2.
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.

1 participant