Skip to content

Test Composer hosted and agent modes under Bazel on real Bazel - #2146

Merged
Mikola Lysenko (mikolalysenko) merged 2 commits into
mainfrom
bazel-small/c1-composer
Nov 19, 2026
Merged

Mikola Lysenko (mikolalysenko) merged 2 commits into
mainfrom
bazel-small/c1-composer

Conversation

@mikolalysenko

@mikolalysenko Mikola Lysenko (mikolalysenko) commented Nov 18, 2026 •

Copy link
Copy Markdown
Collaborator

No user-visible change.

What this is

Tests only. No Bazel ruleset builds PHP or takes Composer packages, and the Bazel Central Registry has none, so a PHP project under Bazel brings its packages into the build with a few lines of its own. socket-patch has no Bazel-specific code for Composer, and until now no test held what it does in such a workspace. This pull request adds the composer:: module of e2e_bazel_build: three flows on a real Bazel, for the two modes that put a patch into such a build today, each read from what Bazel builds.

Contents

Part Lines
Product code (crates/*/src) 0
Tests: crates/socket-patch-cli/tests/e2e_bazel_build/composer.rs (1,302) and one mod line in main.rs 1,303
Fixture: crates/socket-patch-cli/tests/fixtures/bazel/composer/bzlmod, 12 files 185
Workflow: .github/workflows/bazel-composer.yml 140
Shared test harness: e2e_bazel_build/harness.rs +10
Shared workflow: .github/workflows/bazel-compatibility.yml +3, -1

Two shared files change, each by one edit:

  • bazel-compatibility.yml gains one condition: its macOS job is skipped when a caller passes an empty macos list. GitHub fails a job whose matrix is empty, so until now a caller could not leave the macOS leg out.
  • harness.rs now removes COMPOSER and every COMPOSER_* variable of the shell from every Bazel child, in the lists that already do this for pip, uv and bazelisk. The hermetic test that guards those lists has the new names. The Composer that a repository rule starts reads the environment of the Bazel client, so without this a developer's Composer settings changed what a flow did.

The other ecosystems' modules, fixtures and workflows are untouched.

The fixture is one workspace with three PHP projects below its root, as a monorepo has them. Each stands for one shape a project writes by hand:

  • services/api: a repository rule (composer.bzl, 50 lines) runs composer install from the committed composer.lock. It takes the lock with rctx.read, so Bazel fetches the repository again when the lock changes.
  • services/worker: a genrule runs composer install from the lock in a build action.
  • services/legacy: the project commits its vendor/ tree, and Bazel reads the packages as source files.

The harness builds //:consumer, so each test writes a root BUILD.bazel that points that label at its project. The fixture commits no lock and no vendor/ tree: a test has real Composer make them for the run, against the loopback stand-in.

What it proves, and where

Test Mode Shape
composer::hosted_repository_rule hosted repository rule
composer::hosted_genrule hosted genrule
composer::agent_committed_vendor agent committed vendor/

Each flow is one #[ignore]d test:

  1. The build prints the unpatched marker. The upstream archive is new for every run and comes from the stand-in.
  2. The one command of the mode runs in the project and is held to the exact files it may write. scan --mode hosted --yes rewrites composer.lock and nothing else: the package's dist becomes the patched archive with its sha1, and its git source goes. scan --mode agent --yes patches the one file under vendor/ and writes .socket/manifest.json and two blobs.
  3. The same build, with no step in between, prints the patched marker, which carries an id made in this run. Bazel changed no file, a --lockfile_mode=error build passes, and vex attests the package.
  4. The undo. rollback --yes restores the lock byte for byte from the registry's metadata, and the build is the unpatched one again. In agent mode it restores the file byte for byte.
  5. A second machine gets other bytes. Hosted: the patch host serves another archive at the pinned URL, Composer refuses it on the sha1 of the lock, the build fails, and the upstream archive is not fetched in its place. Agent: a patch service hands out another blob, scan refuses it and writes nothing, and the build stays unpatched.

A flow does the same in every shell and in every checkout. Its Composers get their settings from the test and none from the shell: five for the developer's Composer and the repository rule's, and the Composer home alone for the build action's. One of the five is a fixed version for the project itself: without it Composer asks git, and the committed vendor/ tree would name the branch and the commit of this repository's checkout. The agent flow asserts that the tree names no commit but the package's.

Results at this commit, on macOS arm64 with PHP 8.4.23 and Composer 2.11.2, each release with a fresh output root and an empty repository cache. Seconds per test:

Test Bazel 9.3.2 Bazel 8.8.2 Bazel 7.7.2
composer::hosted_repository_rule 11.4 12.7 11.1
composer::hosted_genrule 14.8 17.2 13.3
composer::agent_committed_vendor 13.0 15.1 11.4

All nine pass. Earlier rounds on the same machine took up to 56 seconds per test while other builds ran.

The three flows also pass on 9.3.2 with COMPOSER_DISABLE_NETWORK=1, COMPOSER_AUTH=not-json and COMPOSER=/nonexistent/composer.json exported in the shell.

Because the shared harness changed, the flows of the other ecosystems ran once on Bazel 9.3.2 at this commit, and pass: go::hosted_go_deps (72 s), npm::hosted_npm_translate_lock (19 s), npm::vendored_npm_translate_lock (19 s), pypi::hosted_pip_parse (21 s) and ruby::hosted_bundle_fetch (35 s).

Before the code review, each assertion was checked by breaking it: 17 changes to the test, one at a time on Bazel 9.3.2, and every one failed the flows it should. Among them: the scan left out, upstream bytes served under the patched name, a patched archive that holds no patched file, and the other-bytes step left out. Those 17 were not run again after the review. What the review added was checked the same way at this commit:

  • With the Composer names taken out of the harness's lists, the hermetic test fails (a child sees COMPOSER), and with the three variables above exported the repository rule flow fails on the malformed COMPOSER_AUTH.
  • With a release below the floor taken as usable, the hermetic test of that decision fails. With the PHP floor raised above this machine's PHP, the three flows print SKIP and pass, and fail under SOCKET_PATCH_BAZEL_E2E_REQUIRED.
  • Without the fixed project version, the agent flow fails: the tree names the head commit of this checkout twice.
  • The check for a Composer home under /tmp applies on Linux only. Pointed at this machine's paths instead, it stops the genrule flow at its start with its message.

On Linux, on GitHub's runners, the three Composer legs of this pull request pass at its head on Bazel 9.3.2, 8.8.2 and 7.7.2 (158 to 171 seconds per leg; the three flows together take 32 seconds on 9.3.2). The runner had PHP 8.3.6 and Composer 2.10.3, so the flows have now run on two Composer releases. The Go, npm, PyPI and RubyGems legs, which the harness edit starts, pass too, with the other checks (69 in all). The macOS job shows as skipped, as it does for every caller on a pull request; the first nightly evaluates the empty list.

What starts on main

bazel-composer.yml calls bazel-compatibility.yml for three Linux legs: Bazel 9.3.2, 8.8.2 and 7.7.2.

  • On a pull request it runs when the change touches the Composer flows and their fixture, the harness and the two workflows, the Bazel installer and its pins, any source file or directory with composer in its name, or patch/user_patches.rs.
  • On a push to main it also runs for the root of the test target, the shared engine code the flows run through (patch/redirect, the apply and rollback engines, manifest, hosted, vex, commands), the shared test helpers and the toolchain files.
  • Every night (17 5 * * *) and on demand (workflow_dispatch), so a main change outside the push list gets a run within a day.
  • No macOS leg. The caller passes an empty macos list, and bazel-compatibility.yml skips its macOS job for an empty list.
  • PHP and Composer are the runner's own, found on PATH. Nothing installs or pins them. The legs run on the runner that bazel-compatibility.yml names: depot-ubuntu-24.04-4, or ubuntu-latest when the repository variable DISABLE_DEPOT_RUNNERS is true. This pull request's run shows what that runner holds today: PHP 8.3.6 and Composer 2.10.3. GitHub's description of its own ubuntu-24.04 image lists PHP 8.3.6 and Composer 2.11.2. A test prints the two releases it found at its start, so the first run of this pull request shows them. Without one of the tools, or with one older than the flows take (PHP 7.2.5, Composer 2.0.0), a test fails under SOCKET_PATCH_BAZEL_E2E_REQUIRED, which the legs set, and prints SKIP otherwise.
  • Outside hosts of a leg with an empty cache: bcr.bazel.build, github.com and release-assets.githubusercontent.com, for what Bazel resolves for its own modules. That is 1.7 MB on 9.3.2, 26 MB on 8.8.2 and 0.7 MB on 7.7.2. There is no ruleset archive and no toolchain. The package under test, the Socket API, the patch host and Packagist are one loopback server.
  • Cache: the repository cache of the legs workflow, about 1 MB on 9.3.2, 13 MB on 8.8.2 and under 1 MB on 7.7.2.
  • Not required for merge: no merge_group trigger, and no job is a needs of ci-ok.

Known behaviour

What a user with PHP under Bazel meets today. The first three are not tested here.

  • There is no Bazel ruleset for Composer. These flows are hand-written shapes, and other shapes may behave differently.
  • Vendored mode breaks the two builds that run Composer: the command exits 0 and the next build fails, because the lock's relative path is not there where Composer runs. A later pull request declines it.
  • A rule that takes the lock with rctx.symlink instead of rctx.read keeps the old tree on a developer's warm output base, on Bazel 9.3.2 and 8.8.2, after a scan and after a rollback alike.
  • A hosted pin does not survive composer update or composer update --lock. The test asserts the second: Composer puts the upstream entry back without a word, the next build is unpatched, and vex attests nothing until the next scan.
  • In a monorepo the commands run per project. scan --json at the workspace root patches nothing and names the directory to scan (asserted). vex and rollback at the root exit non-zero and name --cwd <project>.
  • The other-bytes check is one of an empty Composer cache. A machine whose cache already holds the patched archive does not ask the host again and builds the bytes it verified before (asserted).
  • Nothing at build time holds a committed vendor/ tree to a sum. In agent mode the check is the command's own refusal of a blob that does not match the patch.
  • After rollback in agent mode, .socket/manifest.json stays, listing no patch.
  • On Bazel 9 a build action gets a fixed PATH. A project whose genrule runs the machine's php and composer needs --action_env=PATH and a Composer home for the action, as the fixture's .bazelrc has.
  • vex needs --product in a checkout with no git remote whose composer.json has no name and version.

Not claimed

  • Windows, and macOS.
  • Composer other than 2.11.2 (macOS) and 2.10.3 (the Linux runner), and PHP other than 8.4.23 and 8.3.6.
  • The new condition of the macOS job on a nightly or an on-demand run. Those two events start only once the workflow is on main. actionlint accepts the expression.
  • The real patch host and https: the stand-in is plain http, which only the test's own Composer home allows.
  • Real Packagist, and a registry that lists a security advisory for the package (first decision below).
  • A project at the workspace root, a WORKSPACE-only workspace, a transitive or dev dependency, remote execution, a remote cache.
  • Vendored mode, and agent mode where Bazel does not read vendor/.

Left open

  • A macOS leg, and pinned PHP and Composer. Both need a setup step in the reusable workflow, which takes none from a caller today. That is a later pull request. Until then the legs test whatever PHP and Composer their runner has, and print which.
  • Code this module repeats from the harness and from another module. The test that the workflow's listed files exist is a copy of the PyPI module's. The hosted-scan step repeats most of the harness's step for a finished scan. The release parser, the SKIP rule and the loopback host list repeat helpers that are private to the harness. They belong to one harness change for all modules.
  • A listener thread per test machine. Every Composer machine of a test starts the thread of its connection-counting proxy, also where no Composer of the test uses it. It costs one parked thread.

Decisions for the owner

  1. Composer's security blocking. Found while building this, and not about Bazel. Composer 2.11.2 refuses to resolve a version that its registry lists an advisory for (composer update exits 2 unless --no-security-blocking), while composer install from a lock still installs. The relock caveat above was seen with a registry that lists no advisory. On real Packagist a relock of a package Socket has patched may fail instead of dropping the pin. Worth one run against production.
  2. The package's name. socketsecurity/bazel-fixture-upstream follows the npm fixture. On Packagist a vendor name belongs to whoever publishes under it first, and I did not check who holds this one. The tests do not depend on it: every Composer of a flow reads a home that knows only the stand-in, and the one that resolves by name runs behind a proxy that counts connections and fails the test on any.

Code review

A code review of this pull request made nine findings. Four are fixed, one led to a corrected comment and is otherwise left open, and four are left open for the reasons given.

  • Composer settings of the shell reached the Composer that the repository rule starts. A rule's execute inherits the environment of the Bazel client, and the harness removed no Composer name, so COMPOSER_DISABLE_NETWORK=1 or a malformed COMPOSER_AUTH in the shell failed composer::hosted_repository_rule. Fixed in the harness, for every ecosystem: COMPOSER and every COMPOSER_* name are removed from every Bazel child, and the hermetic test of the removal lists has the names. A flow sets the names it needs after the removal. To see that they still arrive, the fixture's rule and action were made to print the Composer variables they see, on Bazel 9.3.2 with COMPOSER_DISABLE_NETWORK, COMPOSER_AUTH and COMPOSER exported as above: the rule saw the test's five and none of the shell's, and the action saw the test's COMPOSER_HOME and COMPOSER_CACHE_DIR=/dev/null.
  • A PHP or Composer older than the floor failed a test even without the required setting, against the module's rule that a missing prerequisite prints SKIP and passes. Fixed: a release below the floor counts as a tool that is not there. The SKIP line names the release found, the floor and the releases the flows were run on, and the test fails only under SOCKET_PATCH_BAZEL_E2E_REQUIRED. Each flow now prints the releases it found beside the ones it was run on, so a failure on an untested release has a first hint. One hermetic test holds the decision.
  • The legs run whatever PHP and Composer their runner has, and the workflow's comment gave the releases of GitHub's ubuntu-24.04 image as if they were the runner's. Not fixed here: pinning needs a setup step in the reusable workflow (see "Left open"). The comment now says only what is known: which runner the legs use, that the two releases come from GitHub's description of its own image and were not confirmed on that runner, and that a test prints what it found.
  • The Composer that makes the lock and the vendor/ tree wrote this checkout's branch and commit into the tree. It runs under the target directory, inside the checkout, and had no version for the project, so it asked git. Confirmed by a run: vendor/composer/installed.php named dev-main and the head commit. Fixed: the flows give Composer a fixed project version. With it Composer starts no git at all: a trial of composer update in the same place, with a logging git first on PATH, counted three git commands without the version and none with it. The agent flow asserts that the tree names no commit but the package's.
  • Nothing checked that the Composer home is outside /tmp. It is under the target directory because a build action in Bazel's Linux sandbox has a /tmp of its own. Fixed: on Linux the genrule flow fails at its start when the home is under /tmp, and says to give cargo a target directory outside it.
  • The test that the workflow's listed files exist is a copy of the PyPI module's. Not changed here (see "Left open").
  • The hosted-scan step repeats most of the harness's step for a finished scan. Not changed here (see "Left open").
  • The release parser, the SKIP rule and the loopback host list repeat private helpers of the harness. Not changed here (see "Left open").
  • Every test machine starts a listener thread it may not need. Not changed: one parked thread per machine (see "Left open").

Generated by Claude Code

No Bazel ruleset builds PHP or takes Composer packages, and the Bazel
registry holds none, so a PHP project under Bazel brings its packages
into the build with a few lines of its own. socket-patch has no Bazel
code for Composer, and no test held what it does in such a workspace.
This adds the `composer::` module of e2e_bazel_build: three flows on a
real Bazel, each read from what Bazel builds.

The fixture is one workspace with three projects below its root, as a
monorepo has them, one per hand-written shape:

- services/api: a repository rule (composer.bzl) runs `composer install`
  from the committed lock, which it takes with rctx.read, so Bazel
  fetches the repository again when the lock changes. Hosted mode.
- services/worker: a genrule runs `composer install` from the lock in a
  build action. Hosted mode.
- services/legacy: the project commits vendor/, and Bazel reads the
  packages as source files. Agent mode.

A flow builds the unpatched marker, runs the one command of its mode and
holds it to the exact files it may write, builds the patched marker,
which carries an id of the run, and has `vex` attest the package. It
undoes the patch: `rollback` restores the lock byte for byte from the
registry's metadata, and in agent mode restores the file and leaves a
manifest that lists no patch. Then a second machine gets other bytes:
Composer refuses the archive on the sha1 of the lock and the build
fails without a fetch of the upstream archive, or `scan --mode agent`
refuses the blob, writes nothing, and the build stays unpatched.

The flows also record what a user meets today:

- `scan --json` at the workspace root of a monorepo patches nothing and
  names the directory to scan.
- A relock (`composer update --lock`) puts the upstream entry back over
  a hosted pin without a word. The next build is unpatched and `vex`
  attests nothing until the next scan.
- The second-machine check is one of an empty Composer cache. With a
  cache that holds the patched archive, Composer does not ask the host
  and builds the patch while the host serves other bytes.

Vendored mode is in no flow: it breaks the first two builds today.

PHP and Composer are the machine's own, from PATH, since no ruleset
brings them. A test prints SKIP without one of them, or with one older
than the flows take (PHP 7.2.5, Composer 2.0.0), and fails under
SOCKET_PATCH_BAZEL_E2E_REQUIRED. At its start it prints the two releases
it found beside the two the flows were run on. Every Composer of a flow
reads one home that knows the loopback stand-in as its only repository
and is the one place that allows plain http, so a Composer on its
defaults cannot fetch the package. The Composer that resolves the lock
runs behind a proxy that counts connections, and a test fails when it
sent a request beyond loopback.

A flow does the same in every shell. A repository rule's Composer reads
the environment of the Bazel client, so with COMPOSER_AUTH or
COMPOSER_DISABLE_NETWORK set in the shell the repository rule flow
failed. The harness now removes `COMPOSER` and every `COMPOSER_*`
variable from every Bazel child, as it does for pip and uv, and the
hermetic test that guards its lists has the names. A flow then sets the
five names its Composers need. One of them is COMPOSER_ROOT_VERSION:
the Composer that makes the committed vendor/ tree runs under the
target directory, inside this repository's checkout, and without a
version it asked git for one and wrote the branch and the commit of
that checkout into the tree. The agent flow now asserts that the tree
names no commit but the package's. In Bazel's Linux sandbox a build
action has a /tmp of its own, so the genrule flow fails at its start,
with the remedy, when the Composer home is under /tmp.

bazel-composer.yml runs the legs on Bazel 9.3.2, 8.8.2 and 7.7.2 for
pull requests and pushes to main that touch the Composer files, every
night and on demand. The legs take the PHP and the Composer of their
runner, and nothing pins them. GitHub's description of its ubuntu-24.04
image lists PHP 8.3.6 and Composer 2.11.2; what the runner of the legs
holds is not confirmed before their first run. There is no macOS leg:
GitHub's description of the macOS image lists neither tool. A caller
says so with an empty `macos` list, and bazel-compatibility.yml now
skips its macOS job for an empty list instead of failing on an empty
matrix. Two shared files change: bazel-compatibility.yml by that one
condition, and harness.rs by the Composer names in its removal lists.

On macOS arm64 with PHP 8.4.23 and Composer 2.11.2 the three flows pass
on the three releases. With an empty repository cache a flow takes 11
to 19 seconds on an idle machine, and took up to 56 while other builds
ran. A leg downloads nothing but what Bazel resolves for its own
modules: 1.7 MB on 9.3.2, 26 MB on 8.8.2 and 0.7 MB on 7.7.2. Because
the harness changed, the Go, npm, PyPI and RubyGems flows ran once on
Bazel 9.3.2, and pass. Nothing ran on Linux yet. No file under
crates/*/src changes.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
@cursor

cursor Bot commented Nov 18, 2026 •

Copy link
Copy Markdown

PR Summary

Low Risk
Test and CI workflow changes only; no runtime product code. Harness env scrubbing affects all Bazel e2e runs but aligns with existing hermetic patterns for other package managers.

Overview
Adds Composer to the real-Bazel e2e_bazel_build suite: a new composer:: module with three ignored tests (hosted via repository rule, hosted via genrule, agent on committed vendor/), plus a monorepo fixture that mirrors hand-written PHP/Composer integration under Bazel (composer.bzl, .bazelrc action env, three services/* projects).

Introduces bazel-composer.yml, which reuses bazel-compatibility.yml on Linux for Bazel 9.3.2 / 8.8.2 / 7.7.2, path-filtered PR/push triggers, nightly and workflow_dispatch, and macos: '[]' (no macOS legs). bazel-compatibility.yml now skips the macOS job when the caller’s macos matrix is empty so GitHub doesn’t fail on an empty matrix.

The shared harness strips COMPOSER and COMPOSER_* from every Bazel child so shell Composer settings don’t leak into repository rules; flows set the env they need. No product (crates/*/src) changes—tests, fixture, workflow, and harness only.

Reviewed by Cursor Bugbot for commit 9a374f6. Configure here.

@mikolalysenko

Mikola Lysenko (mikolalysenko) commented Nov 19, 2026 •

Copy link
Copy Markdown
Collaborator Author

[agent] PR shepherd: review brief for the approver

What it does. Adds three real-Bazel Composer flows: hosted mode, and agent mode with a genrule. They show that a patched package is pinned in composer.lock and fetched from the patch host, and that other bytes are refused. A new bazel-composer.yml workflow runs them. The shared harness also strips COMPOSER/COMPOSER_* variables from Bazel's child processes. Only tests, fixtures and workflows change.

Risk: low. No product code changes. The real-Bazel flows are #[ignore] and the new workflow isn't required. The shared changes are small: more variables in the harness's strip lists, and one guard on the macOS job in bazel-compatibility.yml so a caller that passes an empty macOS list skips that job.

Look here

  • [harness.rs:61](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/e2e_bazel_build/harness.rs#L61): the shared variable lists every Bazel flow uses.
  • bazel-compatibility.yml:205: the new fromJSON(inputs.macos)[0] != null guard.
  • [composer.rs:746](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/e2e_bazel_build/composer.rs#L746) pins: the exact rewrite of the lock.
  • [composer.rs:785](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/e2e_bazel_build/composer.rs#L785) refuses: checks that the patch host was asked and the upstream archive was not.
  • [composer.bzl:20](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/fixtures/bazel/composer/bzlmod/common/composer.bzl#L20): the fixture's repository rule.

Verified

  • cargo check -p socket-patch-cli --tests passes.
  • cargo test -p socket-patch-cli --test e2e_bazel_build: 13 passed, 8 ignored (real Bazel isn't installed here). The four new hermetic Composer tests pass.
  • cargo fmt --all -- --check is clean, and scripts/check-tool-pins.py passes on both workflows.
  • The new workflow has contents: read permission, no secrets and no new actions. There is no CRLF or leftover debug code, and CHANGELOG.md is untouched.
  • CI on 9a374f62: ci-ok and clippy are green, along with all 72 checks.

Changes I made: none.

Open questions (minor, none blocking):

  • The version range starts at Bazel 7.0.0 ([composer.rs:142](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/e2e_bazel_build/composer.rs#L142)). The lock-change refetch depends on Bazel watching files that rctx.read reads, and that may have arrived after 7.0. Only 7.7.2 is tested. Should the floor go up?
  • Nit: the comment at bazel-composer.yml:18 and RAN_ON ([composer.rs:186](https://github.com/SocketDev/socket-patch/blob/9a374f62839718f5dc86bf6a45764c3896fb917c/crates/socket-patch-cli/tests/e2e_bazel_build/composer.rs#L186)) don't record the Linux PHP and Composer versions that CI ran.
  • Siblings Test Cargo hosted and vendored modes under rules_rust on real Bazel #2147 and Test NuGet hosted mode under rules_csharp on real Bazel #2140 each add a mod line to e2e_bazel_build/main.rs and an entry to the harness lists. Whichever lands second will need a trivial merge.

Generated by Claude Code

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

[agent] Reviewed at 9a374f6. Tests, fixture and workflow only, plus the harness scrubbing COMPOSER and COMPOSER_*. All three flows ran and passed on 7.7.2, 8.8.2 and 9.3.2, asserting the exact composer.lock rewrite, the patched marker from the build, no upstream fetch and a checksum refusal. The bazel-compatibility.yml change only lets a caller passing an empty macOS list skip that job. Non-blocking: PHP and Composer come unpinned from the runner image, so an image update could break these legs; the mod composer; line in main.rs will conflict with #2147.

@github-merge-queue
github-merge-queue Bot removed this pull request from the merge queue due to a conflict with the base branch Nov 19, 2026
Keep both test modules: main added `mod cargo;`, this branch `mod composer;`.

Assisted-by: Claude Code:claude-opus-5-5
Merged via the queue into main with commit d1f4f32 Nov 19, 2026
79 checks passed
@mikolalysenko
Mikola Lysenko (mikolalysenko) deleted the bazel-small/c1-composer branch November 19, 2026 16:29
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Ready for review Agent-verified: mergeable, CI green, Bugbot clean — awaiting human review

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants