diff --git a/.github/actionlint.yaml b/.github/actionlint.yaml new file mode 100644 index 000000000..c3aadcc30 --- /dev/null +++ b/.github/actionlint.yaml @@ -0,0 +1,5 @@ +paths: + .github/workflows/check.yml: + ignore: + # Delivered to Actions but missing from its event docs: https://github.com/rhysd/actionlint/issues/726 + - 'invalid activity type "destroyed" for "merge_group" Webhook event' diff --git a/.github/land.test.ts b/.github/land.test.ts deleted file mode 100644 index 2cef57ef7..000000000 --- a/.github/land.test.ts +++ /dev/null @@ -1,34 +0,0 @@ -// The `land` environment holds the key of the App that main's ruleset lets bypass it, -// so only the Land workflow's land job may name an environment. Any other environment -// reference counts, since an expression can spell `land` without the word. -import { deepStrictEqual } from "node:assert"; -import { readdirSync, readFileSync } from "node:fs"; -import { join } from "node:path"; - -type Job = { environment?: unknown; uses?: unknown }; - -/** The `workflow:job` of every job that names an environment or calls another repository's workflow, which could. */ -function users(name: string, text: string): string[] { - const jobs: Record = Bun.YAML.parse(text)?.jobs ?? {}; - return Object.entries(jobs) - .filter(([, job]) => job.environment !== undefined || (typeof job.uses === "string" && !job.uses.startsWith("./"))) - .map(([id]) => `${name}:${id}`); -} - -const fixtures: [string, string[]][] = [ - ["jobs:\n build:\n environment: land\n", ["ci.yml:build"]], - ["jobs:\n build:\n environment:\n name: land\n", ["ci.yml:build"]], - ["jobs:\n build: { environment: { name: land } }\n", ["ci.yml:build"]], - ["jobs:\n build:\n environment: ${{ format('{0}nd', 'la') }}\n", ["ci.yml:build"]], - ["jobs:\n build:\n uses: someone/else/.github/workflows/steal.yml@main\n", ["ci.yml:build"]], - ["jobs:\n build:\n uses: ./.github/workflows/check.yml\n", []], - ["jobs:\n build:\n runs-on: ubuntu-latest\n", []], -]; -for (const [text, expected] of fixtures) deepStrictEqual(users("ci.yml", text), expected, text); - -// GitHub runs both extensions. -const workflows = join(import.meta.dir, "workflows"); -const found = readdirSync(workflows) - .filter((name) => /\.ya?ml$/.test(name)) - .flatMap((name) => users(name, readFileSync(join(workflows, name), "utf8"))); -deepStrictEqual(found, ["land.yml:land"], "only land.yml's land job may name an environment"); diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 172abe403..8c80a0de3 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -3,12 +3,20 @@ name: Check permissions: contents: read -# Not on a push to main: main only fast-forwards to a tree land.yml already checked. +# Main PRs report Check as skipped; the merge queue runs it once on the combined +# tree, so a push to main never needs it. on: pull_request: + merge_group: + # `destroyed` only cancels the dead group's in-flight run. GitHub keeps that + # run queued when the group is rebuilt behind a departed entry, where it + # holds the queue runner ahead of the live groups until they time out. + # Actions delivers this type although its docs omit it. + types: [checks_requested, destroyed] workflow_dispatch: -# Cancel in-flight runs when a new commit lands on the same ref. +# Cancel in-flight runs when a new commit lands on the same ref. Each merge +# group has its own queue ref, shared by its `destroyed` event. concurrency: group: check-${{ github.ref }} cancel-in-progress: true @@ -16,7 +24,11 @@ concurrency: jobs: check: name: Check - runs-on: ubuntu-24.04-arm + # A destroyed-group run exists only to cancel the superseded in-flight build + # via the concurrency group above. + if: github.event_name != 'pull_request' && github.event.action != 'destroyed' + # Leave the variable unset until the self-hosted runner is verified. + runs-on: ${{ github.event_name == 'merge_group' && vars.RUST2_QUEUE_RUNNER || 'ubuntu-24.04-arm' }} # Backstop a hang instead of holding the runner for the 6-hour default. timeout-minutes: 30 @@ -27,9 +39,7 @@ jobs: persist-credentials: false - uses: ./.github/actions/nix + if: runner.environment != 'self-hosted' - name: Check - run: nix develop --command just check - - - name: Test - run: nix develop --command just test + run: nix develop --command just ci diff --git a/.github/workflows/land.yml b/.github/workflows/land.yml deleted file mode 100644 index e5a64684e..000000000 --- a/.github/workflows/land.yml +++ /dev/null @@ -1,107 +0,0 @@ -name: Land - -# `quest land` batches the PRs queued with `quest merge --land`: it squashes them -# onto main, checks the chain once, and fast-forwards main to the passing prefix. -on: - pull_request_target: - types: [auto_merge_enabled] - workflow_dispatch: - -# One run at a time; waiting triggers collapse into one run that reads the whole queue. -concurrency: - group: land - -permissions: {} - -jobs: - resolve: - runs-on: ubuntu-24.04-arm - timeout-minutes: 15 - permissions: { contents: read, pull-requests: read, checks: read, statuses: read } - outputs: - plan: ${{ steps.resolve.outputs.plan }} - steps: - # Every job checks out main, so quest comes from a pin no queued PR can modify. - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - persist-credentials: false - - uses: ./.github/actions/nix - - name: Build quest - run: | - nix build --out-link "$RUNNER_TEMP/quest" .#quest - echo "$RUNNER_TEMP/quest/bin" >> "$GITHUB_PATH" - - id: resolve - env: - GH_TOKEN: ${{ github.token }} - run: echo "plan=$(quest land resolve)" >> "$GITHUB_OUTPUT" - - check: - needs: resolve - runs-on: ubuntu-24.04-arm - # Room for a few runs of Check's steps: a failing chain is bisected until a prefix passes. - timeout-minutes: 90 - # This job runs the queued PRs' code, so it holds only a read token. - permissions: { contents: read } - outputs: - result: ${{ steps.check.outputs.result }} - steps: - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - fetch-depth: 0 - persist-credentials: false - - uses: ./.github/actions/nix - # Built outside the checkout before the chain replaces it. - - name: Build quest - run: | - nix build --out-link "$RUNNER_TEMP/quest" .#quest - echo "$RUNNER_TEMP/quest/bin" >> "$GITHUB_PATH" - # The same steps as check.yml's Check job. - - id: check - env: - PLAN: ${{ needs.resolve.outputs.plan }} - run: | - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - printf '%s' "$PLAN" > "$RUNNER_TEMP/plan.json" - echo "result=$(quest land check "$RUNNER_TEMP/plan.json" -- nix develop --command bash -c 'just check && just test')" >> "$GITHUB_OUTPUT" - - land: - needs: [resolve, check] - runs-on: ubuntu-24.04-arm - timeout-minutes: 15 - # The environment, which only main can deploy to, holds the key of the App - # that main's ruleset lets bypass it. Only this job may use it. - environment: land - # contents: write lets github.token disable auto-merge when it ejects a PR. - permissions: { contents: write, pull-requests: write, issues: write, actions: write, checks: read, statuses: read } - steps: - - id: app - uses: actions/create-github-app-token@64ab729a6294000f5aa4a4bc0b73d1f32bc45510 # v3.3.0 - with: - client-id: ${{ vars.LAND_APP_CLIENT_ID }} - private-key: ${{ secrets.LAND_APP_PRIVATE_KEY }} - # Workflows lets it land PRs that change this directory. - permission-contents: write - permission-workflows: write - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - fetch-depth: 0 - token: ${{ steps.app.outputs.token }} - - uses: ./.github/actions/nix - - name: Build quest - run: | - nix build --out-link "$RUNNER_TEMP/quest" .#quest - echo "$RUNNER_TEMP/quest/bin" >> "$GITHUB_PATH" - - env: - GH_TOKEN: ${{ github.token }} - PLAN: ${{ needs.resolve.outputs.plan }} - RESULT: ${{ needs.check.outputs.result }} - run: | - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - printf '%s' "$PLAN" > "$RUNNER_TEMP/plan.json" - printf '%s' "$RESULT" > "$RUNNER_TEMP/result.json" - quest land push "$RUNNER_TEMP/plan.json" "$RUNNER_TEMP/result.json" > "$RUNNER_TEMP/landing" - cat "$RUNNER_TEMP/landing" - # The queue changed, so run again for the rest. - if [ -s "$RUNNER_TEMP/landing" ]; then gh workflow run land.yml --ref "$GITHUB_REF_NAME"; fi diff --git a/AGENTS.md b/AGENTS.md index 6a0d4bfeb..686be964c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -60,6 +60,7 @@ direnv loads it automatically, but if not: `nix develop --command ...`. ```bash just check # Lint everything, including the quest tree just test # Run the tests +just ci # Both, as the merge queue runs them; run before every push just fix # Auto-fix formatting ``` diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ceebe01aa..cff4b941a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,9 +1,6 @@ # Commits -PRs land on `main` only through `quest land`, each as one squash commit: the PR title becomes the commit subject and the PR's commit messages become the body. -Queue a PR with `quest merge --land ` (`/quest-merge` does this), and the Land workflow runs Check's steps once on the batch, landing the longest passing prefix. -The admin bypass of `main`'s ruleset is for emergencies. -Until the land setup in `quest/m1/land.md` is done, `--land` fails: merge with `gh pr merge --squash --match-head-commit ` instead. +PRs into `main` are squash-merged through the merge queue, so the PR title becomes the commit subject. - Use conventional-commit subjects (`feat(ts): ...`, `fix: ...`, `chore: ...`, `docs: ...`). - AI commit attribution goes in a `Co-Authored-By:` trailer, not the commit body. @@ -21,7 +18,15 @@ Have at least these sections: - **Follow-ups**: any issues encountered or quests created. Never rebase or force-push a pushed branch; merge the base branch in instead. -Open a draft PR while working, run `just check` and `just test` before every push, and mark the PR ready yourself when the work is done. +Open a draft PR while working, run `just ci` before every push, and mark the PR ready yourself when the work is done. + +# Merge queue + +PRs into `main` get no cloud CI: they report **Check** as skipped, and `just ci` runs the same gate locally. +The merge queue runs Check on the PR combined with the latest `main` and the PRs queued ahead of it. +Enqueue the reviewed head with `quest merge --land ` (`/quest-merge` does this). +A dequeued PR failed that combined check, timed out, or no longer meets the ruleset: read why in the PR timeline, fix the cause, and enqueue again. +The admin bypass of `main`'s ruleset is for emergencies. # Reviews diff --git a/README.md b/README.md index ddf80bc4e..80b73e569 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ Rust to other places. - **TypeScript**: an own rustc driver that translates a [documented Rust subset](ts/README.md) to readable TypeScript, without WASM. - **C, then any language**: an [exporter](ffi/README.md) that turns a crate's `pub` API into a C ABI and header with no attributes, sharing the TypeScript driver's front end. - **Any language**: [a hard fork](uniffi/README.md) of [UniFFI](https://github.com/mozilla/uniffi-rs) with every generator [moq](https://github.com/moq-dev/moq) uses. -- **Faster builds**: a reproducible [build-speed benchmark](bench/build/README.md), then a pure-Rust subset (no build scripts, no C linking) that builds faster, and [rust2-lint](driver/src/bin/rust2-lint/main.rs), which fails a build whose generics' copies cost its codegen more than a budget (`nix run github:kixelated/rust2#lint -- --help`). +- **Faster builds**: a reproducible [build-speed benchmark](bench/build/README.md), then a pure-Rust subset (no build scripts, no C linking) that builds faster, and [rust2-lint](driver/src/bin/rust2-lint/main.rs), which fails a build whose generics' copies cost its codegen more than a budget (`nix run github:moq-dev/rust2#lint -- --help`). Everything here is early; the [quest tree](quest/README.md) holds the plan. @@ -13,8 +13,7 @@ Everything here is early; the [quest tree](quest/README.md) holds the plan. ```bash nix develop # or direnv allow -just check -just test +just ci # just check, then just test, as the merge queue runs them # The UniFFI fixture suites need every foreign toolchain. nix develop .#uniffi --command just uniffi fixtures diff --git a/bench/build/README.md b/bench/build/README.md index 48578d400..d71731a33 100644 --- a/bench/build/README.md +++ b/bench/build/README.md @@ -67,7 +67,7 @@ The body edits are functions the program runs, which ra-jit compiles. ra-jit bugs seen on moq at the pinned rev, not reported upstream: - `cargo ra-jit check` with no build loaded reads every crate of the workspace, takes minutes and GBs, and fails on errors rustc does not report (`unresolved macro moq_clock::test` in moq-net's integration tests). -- Async body edits in moq-net go to cargo (every `edit-async` run): "`new` is not compiled by ra-jit and rustc's copy is from before the edit: an instance of it does not compile". The daemon then loads the workspace again: on CI such an edit took 55.7 s and 222 CPU-s, against plain cargo's 9.1 s and 12.3 CPU-s ([run](https://github.com/kixelated/rust2/actions/runs/40285528419)). +- Async body edits in moq-net go to cargo (every `edit-async` run): "`new` is not compiled by ra-jit and rustc's copy is from before the edit: an instance of it does not compile". The daemon then loads the workspace again: on CI such an edit took 55.7 s and 222 CPU-s, against plain cargo's 9.1 s and 12.3 CPU-s ([run](https://github.com/moq-dev/rust2/actions/runs/40285528419)). - A fallback logs `Duplicate definition of identifier ... ::cargo_metadata` while compiling aws-lc-sys's build script. - On a library-only build such as regex, `cargo ra-jit build` returns after `cargo clean` without building anything. @@ -136,7 +136,7 @@ Recommended on 2026-10-25: moq's CI keeps building its tests with LLVM, since 42 The `cranelift` variant's `build` numbers are for that abort build too. Even passing, it would save little where CI spends its time. -CPU seconds from the [PR run](https://github.com/kixelated/rust2/actions/runs/40235946635) (4 CPUs; an A/A control on that run stayed within 3%): +CPU seconds from the [PR run](https://github.com/moq-dev/rust2/actions/runs/40235946635) (4 CPUs; an A/A control on that run stayed within 3%): | CI build | nightly | cranelift | change | | --- | ---: | ---: | ---: | diff --git a/bench/ffi/browser.sh b/bench/ffi/browser.sh index 24a4b8600..a02a7d263 100755 --- a/bench/ffi/browser.sh +++ b/bench/ffi/browser.sh @@ -15,7 +15,7 @@ mkdir -p "$dir" jq -n --arg pkgs "$ubrn/pkgs" --arg playwright "$PLAYWRIGHT_VERSION" '{ name: "moq-ffi-bench", private: true, - repository: {type: "git", url: "https://github.com/kixelated/rust2"}, + repository: {type: "git", url: "https://github.com/moq-dev/rust2"}, dependencies: { "@ubjs/core": "file:\($pkgs)/ubjs-core.tgz", "@ubjs/wasm": "file:\($pkgs)/ubjs-wasm.tgz", diff --git a/driver/Cargo.toml b/driver/Cargo.toml index c7cfc3ba7..95ac2ff56 100644 --- a/driver/Cargo.toml +++ b/driver/Cargo.toml @@ -4,7 +4,7 @@ description = "The rustc driver front end that rust2's drivers share, and rust2- version = "0.0.0" edition = "2024" license = "MIT OR Apache-2.0" -repository = "https://github.com/kixelated/rust2" +repository = "https://github.com/moq-dev/rust2" # A path dependency of the drivers, and rust2-lint through the flake: it only builds on # their pinned nightly. publish = false diff --git a/driver/src/rustc.rs b/driver/src/rustc.rs index 0080a418d..5baec1198 100644 --- a/driver/src/rustc.rs +++ b/driver/src/rustc.rs @@ -7,7 +7,7 @@ use rustc_driver::Callbacks; use rustc_session::EarlyDiagCtxt; use rustc_session::config::ErrorOutputType; -const BUG_REPORT_URL: &str = "https://github.com/kixelated/rust2/issues/new"; +const BUG_REPORT_URL: &str = "https://github.com/moq-dev/rust2/issues/new"; /// Whether cargo ran this binary as its wrapper, which it does with the rustc it would /// have run as the first argument. diff --git a/ffi/Cargo.toml b/ffi/Cargo.toml index 8da848ed9..3a1fb8f58 100644 --- a/ffi/Cargo.toml +++ b/ffi/Cargo.toml @@ -4,7 +4,7 @@ description = "Export a crate's pub API as a C ABI and header" version = "0.0.0" edition = "2024" license = "MIT OR Apache-2.0" -repository = "https://github.com/kixelated/rust2" +repository = "https://github.com/moq-dev/rust2" # Distributed through the flake: it only builds on the pinned nightly. publish = false diff --git a/justfile b/justfile index ab666ed27..d91bf3ae5 100644 --- a/justfile +++ b/justfile @@ -31,10 +31,14 @@ check: just driver check just uniffi check +# Run what CI's Check runs: the lints, then the tests. +ci: + just check + just test + # Run the tests. test: bash .claude/hooks/direnv.test.sh - bun .github/land.test.ts just ts test just ffi test just driver test diff --git a/quest/m1/README.md b/quest/m1/README.md index f442f6c3a..4e955715d 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -8,7 +8,7 @@ that replaces it. ## Plan Decided with the maintainer on 2026-10-25, from the -[spike](https://github.com/kixelated/rust2/pull/41): the [exporter](/ffi/README.md), which +[spike](https://github.com/moq-dev/rust2/pull/41): the [exporter](/ffi/README.md), which turns a crate's `pub` API into bindings with no attributes, replaces the UniFFI fork. The fork stays in maintenance and keeps building moq's bindings until then; its feature quests are folded into the [exporter's](/quest/m1/ffi-export/README.md). The @@ -18,4 +18,3 @@ are folded into the [exporter's](/quest/m1/ffi-export/README.md). The - [Waiting: publish the UniFFI fork](/quest/m1/uniffi-release.md) - the fork publishes to crates.io under `rust2-*` names, once the maintainer decides it should - [Exporter](/quest/m1/ffi-export/README.md) - moq's bindings exported from its crates' `pub` API, replacing the fork -- [Land main through quest land](/quest/m1/land.md) - every queued PR lands as one tested batch through the shared gate diff --git a/quest/m1/ffi-export/README.md b/quest/m1/ffi-export/README.md index cdc4dbf01..c48a608d0 100644 --- a/quest/m1/ffi-export/README.md +++ b/quest/m1/ffi-export/README.md @@ -11,7 +11,7 @@ until then. ## Plan Decided with the maintainer on 2026-10-25, from the spike -([kixelated/rust2#41](https://github.com/kixelated/rust2/pull/41)): adopt the exporter, and fold +([moq-dev/rust2#41](https://github.com/moq-dev/rust2/pull/41)): adopt the exporter, and fold the fork's paused feature quests into it. Decided with the maintainer on 2026-10-27: this is an epic, with each item a child ranked by diff --git a/quest/m1/ffi-export/kotlin-android.md b/quest/m1/ffi-export/kotlin-android.md index caad462a8..bc8e73f7f 100644 --- a/quest/m1/ffi-export/kotlin-android.md +++ b/quest/m1/ffi-export/kotlin-android.md @@ -8,7 +8,7 @@ CI. ## Plan -Found by [#184](https://github.com/kixelated/rust2/pull/184) on 2026-10-28, which builds and +Found by [#184](https://github.com/moq-dev/rust2/pull/184) on 2026-10-28, which builds and tests the Kotlin on the JVM only. - R8 and ProGuard rename or strip `Native`'s dispatchers, which the JNI glue finds by name. diff --git a/quest/m1/ffi-export/kotlin-reads.md b/quest/m1/ffi-export/kotlin-reads.md index fa4b39b2a..6c253de1a 100644 --- a/quest/m1/ffi-export/kotlin-reads.md +++ b/quest/m1/ffi-export/kotlin-reads.md @@ -4,7 +4,7 @@ A payload read through the generated Kotlin costs what its JNI crossings must: `just ffi bench`'s "payload read" line closes most of its gap to C, each cut measured. After -[#231](https://github.com/kixelated/rust2/pull/231), Kotlin takes 147-176 ns per 100 B +[#231](https://github.com/moq-dev/rust2/pull/231), Kotlin takes 147-176 ns per 100 B payload read against C's 15-16. The semantics stay as they are: `close()` is idempotent and frees exactly once, and the GC diff --git a/quest/m1/ffi-export/session-quic.md b/quest/m1/ffi-export/session-quic.md index 7a5c1d691..a871f78f9 100644 --- a/quest/m1/ffi-export/session-quic.md +++ b/quest/m1/ffi-export/session-quic.md @@ -19,7 +19,7 @@ moq-tokio, which `moq/moq.c` proves with moq-tokio's fallback runtime. It suits with their own event loop or sockets. Decided with the maintainer on 2026-10-28, from -[#215](https://github.com/kixelated/rust2/pull/215): at moq `30f25c04`, only moq-tokio's +[#215](https://github.com/moq-dev/rust2/pull/215): at moq `30f25c04`, only moq-tokio's and moq-uring's drivers join moq-quic to moq-net's `poll::Session`, and each brings a runtime. The runtime-free driver that joins them is moq's change, not the exporter's. Datagrams move by pull: the binding passes in each one it receives, polls on each wake and diff --git a/quest/m1/ffi-export/tuples.md b/quest/m1/ffi-export/tuples.md index f0fb0f805..e9258de15 100644 --- a/quest/m1/ffi-export/tuples.md +++ b/quest/m1/ffi-export/tuples.md @@ -8,7 +8,7 @@ parameter. hang's `catalog::Audio::ranked` and `catalog::Video::ranked` are the consumer. They return `impl Iterator` (and `&VideoConfig`), which -[#213](https://github.com/kixelated/rust2/pull/213) collects into an array but refuses for +[#213](https://github.com/moq-dev/rust2/pull/213) collects into an array but refuses for the tuple. They export as an array of pairs, each a string and a clone of the config object. The same refusal holds back moq-net's `stats::Snapshot::{control, traffic, sessions}` (`Vec`s of 2- and 3-tuples) and moq-mux's `codec::annexb::find_start_code` (`Option<(usize, usize)>`), diff --git a/quest/m1/land.md b/quest/m1/land.md deleted file mode 100644 index 6e004a654..000000000 --- a/quest/m1/land.md +++ /dev/null @@ -1,35 +0,0 @@ -# [XS] Land main through quest land - -## Goal - -PRs to `main` land only through `quest land` on a hosted runner: every queued -PR goes into one chain of squash commits, checked once with the repository's -Check steps, and `main` fast-forwards to the longest passing prefix. GitHub's -merge button cannot land around it. - -## Plan - -Decided 2026-10-26 (maintainer), planning moq-dev/moq's merge throughput -([moq-dev/moq#6854](https://github.com/moq-dev/moq/pull/6854)): the batched -gate is shared through kixelated/quest, and this repository adopts it. - -[kixelated/rust2#137](https://github.com/kixelated/rust2/pull/137) added the -Land workflow, a test that only its land job names an environment, and -`CONTRIBUTING.md`'s landing rule. What remains is the maintainer's setup and -the live verification. - -- **Push credential (maintainer).** A GitHub App installed on this repository - is the `main` ruleset's bypass actor, with Contents and Workflows write - (Workflows lets it land PRs that change `.github/workflows`) and no - webhook. GitHub Actions cannot be: rulesets refused it as a bypass actor on - a personal repository, kixelated/quest, on 2026-10-27. The `land` - environment, deployable only from `main`, holds the App's client ID as the - variable `LAND_APP_CLIENT_ID` and its key as the secret - `LAND_APP_PRIVATE_KEY`. -- **Ruleset (maintainer).** A new `main` ruleset blocks deletion and - non-fast-forward pushes and requires two checks: `Check` from GitHub - Actions, and `quest land` pinned to the land App, which has no checks or - statuses permission and so never reports it. Its bypass actors are the land - App and the admin role, which keeps an emergency bypass. Ruleset writes are - the maintainer's. -- The PR that finishes this quest lands through the gate, verifying it. diff --git a/quest/m1/uniffi-release.md b/quest/m1/uniffi-release.md index 3cbf1972e..30670c14f 100644 --- a/quest/m1/uniffi-release.md +++ b/quest/m1/uniffi-release.md @@ -16,7 +16,7 @@ needs this before it releases. library names, so code and cherry-picks stay unchanged. Consumers write `uniffi = { package = "rust2-uniffi", ... }`. - **Versions and tags**: decide then. The crates sit at 0.1.0 with no tag. -- **Release**: [the import PR](https://github.com/kixelated/rust2/pull/3) +- **Release**: [the import PR](https://github.com/moq-dev/rust2/pull/3) drafted release-plz with one version group, one `uniffi-v{version}` tag and changelog, and a Release workflow reading `APP_CLIENT_ID`, `APP_PRIVATE_KEY`, and `CARGO_REGISTRY_TOKEN`. The first publish of a new diff --git a/quest/m2/ts-async.md b/quest/m2/ts-async.md index ae3088d1b..7176802f8 100644 --- a/quest/m2/ts-async.md +++ b/quest/m2/ts-async.md @@ -8,7 +8,7 @@ Differential tests against native Rust prove the same polls, wakes, drops, and r ## Plan -Decided by the MIR spike ([#36](https://github.com/kixelated/rust2/pull/36)): an async +Decided by the MIR spike ([#36](https://github.com/moq-dev/rust2/pull/36)): an async body is the state machine rustc's coroutine transform makes, lowered from MIR. Each coroutine instance is a class of its state, its captures, and the locals it keeps across an `.await`; its `poll` is the transform's resume function, a loop over a @@ -30,8 +30,8 @@ moq-net still needs, by its census from MIR at the pinned revision: - `kio::Waiter::poll_future::<()>` does not normalize in moq-net's census, since `()` is no `Future`. It is reached from `util.rs`'s `future_task` closure, itself refused as a `Box`, and the same call translates in the fixture - ([#141](https://github.com/kixelated/rust2/pull/141), - [#183](https://github.com/kixelated/rust2/pull/183)). Find where polymorphic lowering + ([#141](https://github.com/moq-dev/rust2/pull/141), + [#183](https://github.com/moq-dev/rust2/pull/183)). Find where polymorphic lowering makes the `()`. An async block that captures part of a variable, which THIR refused 47 times, is a diff --git a/quest/m2/ts-byte-views/arguments.md b/quest/m2/ts-byte-views/arguments.md index 46a95102f..4b8776fbc 100644 --- a/quest/m2/ts-byte-views/arguments.md +++ b/quest/m2/ts-byte-views/arguments.md @@ -10,7 +10,7 @@ passing. ## Plan Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/kixelated/rust2/pull/138): its per-function scratch return made +[#138](https://github.com/moq-dev/rust2/pull/138): its per-function scratch return made Chrome slower than `main` (varint quic/1B 12.0 to 15.2 ns, frames 3B-reads 152 to 208 ns), since V8 already removes most of `main`'s temporaries once it inlines. A hand edit that also passed slices as parts looked 20-40% faster on varint and 30% on frames lite-06, but diff --git a/quest/m2/ts-byte-views/fields.md b/quest/m2/ts-byte-views/fields.md index 422248c9d..9ad7dbdb3 100644 --- a/quest/m2/ts-byte-views/fields.md +++ b/quest/m2/ts-byte-views/fields.md @@ -10,7 +10,7 @@ differential test passing. ## Plan The [epic's](/quest/m2/ts-byte-views/README.md) hand edit with all three pieces measured -Chrome 2.3-2.9x on varint decode and 2.0-2.2x on frames against [#120](https://github.com/kixelated/rust2/pull/120), Firefox 2.6-3.5x, +Chrome 2.3-2.9x on varint decode and 2.0-2.2x on frames against [#120](https://github.com/moq-dev/rust2/pull/120), Firefox 2.6-3.5x, Node and Bun 1.9-3.4x. Decided with the maintainer on 2026-10-27: private fields split even on root types such as diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index a0655d749..07167df9b 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -10,10 +10,10 @@ alone, with every differential test passing. ## Plan The [epic's](/quest/m2/ts-byte-views/README.md) hand edit measured Chrome 1.84x on varint -decode and 1.65x on frames with locals and returns, against [#120](https://github.com/kixelated/rust2/pull/120). +decode and 1.65x on frames with locals and returns, against [#120](https://github.com/moq-dev/rust2/pull/120). Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/kixelated/rust2/pull/138): remeasure after +[#138](https://github.com/moq-dev/rust2/pull/138): remeasure after [arguments as parts](/quest/m2/ts-byte-views/arguments.md). #138 built a per-function scratch object (the function returns which variant it made and writes the parts into its module-level scratch), and it measured slower than `main` in Chrome (varint quic/1B 12.0 diff --git a/quest/m2/ts-model/floats.md b/quest/m2/ts-model/floats.md index ef0dee83f..15bb1ce2c 100644 --- a/quest/m2/ts-model/floats.md +++ b/quest/m2/ts-model/floats.md @@ -11,10 +11,10 @@ them. ## Plan Decided with the maintainer on 2026-10-27, from -[#135](https://github.com/kixelated/rust2/pull/135): this quest owns float formatting; the +[#135](https://github.com/moq-dev/rust2/pull/135): this quest owns float formatting; the other types' format specs already translate. The rest of `f64`, its arithmetic, casts, methods, and `Duration`'s `f64` methods, landed in -[#165](https://github.com/kixelated/rust2/pull/165). +[#165](https://github.com/moq-dev/rust2/pull/165). - `Display` and `Debug` without a precision print the shortest digits that read back as the value. JS's `Number.prototype.toString` picks the same digits, which leaves only the diff --git a/quest/m2/ts-model/hashbrown.md b/quest/m2/ts-model/hashbrown.md index ede730c7a..fb29ea4dd 100644 --- a/quest/m2/ts-model/hashbrown.md +++ b/quest/m2/ts-model/hashbrown.md @@ -8,7 +8,7 @@ proven by differential tests against native Rust. ## Plan -Found by [#201](https://github.com/kixelated/rust2/pull/201) on 2026-10-28: with hashlink's +Found by [#201](https://github.com/moq-dev/rust2/pull/201) on 2026-10-28: with hashlink's raw pointers translated, hashbrown is the model's largest source of refusals left (251 lines of its census), its SIMD groups, raw allocation, and byte reinterpretation being what JS has no counterpart of. diff --git a/quest/m2/ts-model/std-rest.md b/quest/m2/ts-model/std-rest.md index f0fedc62c..87ff080e7 100644 --- a/quest/m2/ts-model/std-rest.md +++ b/quest/m2/ts-model/std-rest.md @@ -9,7 +9,7 @@ default hasher does, proven by differential tests against native Rust. ## Plan -Left by [#168](https://github.com/kixelated/rust2/pull/168) on 2026-10-28, which translated +Left by [#168](https://github.com/moq-dev/rust2/pull/168) on 2026-10-28, which translated the rest of what the census refused in std. Decided with the maintainer on 2026-10-28: - **Capacity: std's exact growth, everywhere.** moq-net reads `capacity` to decide when to diff --git a/quest/m2/ts-shared.md b/quest/m2/ts-shared.md index 8cf310653..92607cf13 100644 --- a/quest/m2/ts-shared.md +++ b/quest/m2/ts-shared.md @@ -14,7 +14,7 @@ Decided with the maintainer on 2026-10-23: deterministic reference counts in `rt.ts`, not GC-backed `WeakRef`. kio's `WaiterList` frees slots when `Weak::upgrade` fails and reads `weak_count`, so drop timing is observable. -The async spike ([#16](https://github.com/kixelated/rust2/pull/16)) landed what its +The async spike ([#16](https://github.com/moq-dev/rust2/pull/16)) landed what its kio-shaped fixture needs, in `rt/task.ts`: `rt.Arc`, an `Arc` or an `Rc`, counts strong and weak references and drops its value with the last strong one, `rt.Weak` upgrades while one is left, and `rt.Mutex` is its own guard, which a lock gives as diff --git a/quest/m2/ts-std-build.md b/quest/m2/ts-std-build.md index c3ee432ef..28883bb96 100644 --- a/quest/m2/ts-std-build.md +++ b/quest/m2/ts-std-build.md @@ -3,7 +3,7 @@ ## Goal Decide, by measurement, whether rust2-ts still needs `-Zbuild-std` now that it aborts on -panic ([#187](https://github.com/kixelated/rust2/pull/187)), and drop it if not, making the +panic ([#187](https://github.com/moq-dev/rust2/pull/187)), and drop it if not, making the translator's builds faster and simpler. ## Plan diff --git a/quest/m2/uniffi-swift-arm.md b/quest/m2/uniffi-swift-arm.md index db80e9377..968487a0e 100644 --- a/quest/m2/uniffi-swift-arm.md +++ b/quest/m2/uniffi-swift-arm.md @@ -12,7 +12,7 @@ after a bump. ## Plan Decided with the maintainer on 2026-10-26, from -[#93](https://github.com/kixelated/rust2/pull/93): swiftc 6.3.3 is marked broken on +[#93](https://github.com/moq-dev/rust2/pull/93): swiftc 6.3.3 is marked broken on aarch64-linux in the pinned nixpkgs, where its gold link fails, so the job moved to x86_64. Then bump the `nixpkgs` input in its own change, move the job back, and drop the workflow comment. Never allow the broken package. diff --git a/quest/m3/ffi-from-chains.md b/quest/m3/ffi-from-chains.md index 38ff760e3..9dd2f6e02 100644 --- a/quest/m3/ffi-from-chains.md +++ b/quest/m3/ffi-from-chains.md @@ -11,7 +11,7 @@ parameter falls back to `String`, `Bytes`, or `Vec`, or is refused. ## Plan -Suggested by [#197](https://github.com/kixelated/rust2/pull/197) on 2026-10-29. No consumer +Suggested by [#197](https://github.com/moq-dev/rust2/pull/197) on 2026-10-29. No consumer needs it yet: moq's `impl Into>` is one level. Start once a consumer's parameter goes through two. diff --git a/quest/m3/ffi-instance-rename.md b/quest/m3/ffi-instance-rename.md index e4b1231b8..260a7b950 100644 --- a/quest/m3/ffi-instance-rename.md +++ b/quest/m3/ffi-instance-rename.md @@ -9,7 +9,7 @@ path, which renames every instance. ## Plan -Suggested by [#152](https://github.com/kixelated/rust2/pull/152) on 2026-10-27. No consumer +Suggested by [#152](https://github.com/moq-dev/rust2/pull/152) on 2026-10-27. No consumer needs it yet: a clash between an instance and an unrelated item is fixed today by renaming the unrelated item or the generic one. Start once a consumer's clash can't be fixed that way. diff --git a/quest/m3/quest-workflow-guard.md b/quest/m3/quest-workflow-guard.md index b66b6ba1a..af39f7274 100644 --- a/quest/m3/quest-workflow-guard.md +++ b/quest/m3/quest-workflow-guard.md @@ -2,14 +2,14 @@ ## Goal -kixelated/quest's `test/workflows.test.ts` parses workflows as YAML, as -[`.github/land.test.ts`](/.github/land.test.ts) does here, so an environment named through -an expression, a flow mapping, or another repository's reusable workflow can't slip past -its guard on the `land` environment. +kixelated/quest's `test/workflows.test.ts` parses workflows as YAML, as rust2's +[former `land.test.ts`](https://github.com/moq-dev/rust2/blob/f78c588fe61bd9ea0db8f98f1b774cf42280a046/.github/land.test.ts) +did, so an environment named through an expression, a flow mapping, or another +repository's reusable workflow can't slip past its guard on the `land` environment. ## Plan -Found by [#137](https://github.com/kixelated/rust2/pull/137) on 2026-10-26: quest's guard +Found by [#137](https://github.com/moq-dev/rust2/pull/137) on 2026-10-26: quest's guard has the gaps this repository's closed. The work lands in kixelated/quest, through its own review; this quest tracks it here and is deleted once it merges there. diff --git a/quest/m3/relink.md b/quest/m3/relink.md index a5eb16ae7..3d9ace055 100644 --- a/quest/m3/relink.md +++ b/quest/m3/relink.md @@ -12,7 +12,7 @@ variant on moq's edits. Check with `rustc -Z help` (a public API hash, as in ## Plan It is the one upstream lever the moq-net edit leaves room for. The benchmark's -attribution ([run](https://github.com/kixelated/rust2/actions/runs/40093020939)) +attribution ([run](https://github.com/moq-dev/rust2/actions/runs/40093020939)) puts 4.5 s of that edit's 6.95 s critical path in crates rebuilt only because moq-net changed, 0.6 s of it the final link that would remain. Cranelift and the parallel frontend move the edit within noise; the backend is 6% of its @@ -37,7 +37,7 @@ What decides whether this lever ever pays on moq: the pinned nightly, and a different rust#156940 hash, so a cutoff keyed on either needs that fixed first. -The [semantic API hash replay](https://github.com/kixelated/rust2/pull/62) +The [semantic API hash replay](https://github.com/moq-dev/rust2/pull/62) (2026-10-25) hashed only what a dependent can reach and observe, over the same edits. Differential tests show it sound, and it held on 18 of 250 non-test edits under moq's dev profile (17 of 169 on PR branches, 1 of 81 squash merges): diff --git a/quest/m3/ts-arc-mut.md b/quest/m3/ts-arc-mut.md index 95a31a782..9e8548d7c 100644 --- a/quest/m3/ts-arc-mut.md +++ b/quest/m3/ts-arc-mut.md @@ -8,7 +8,7 @@ leaves when it clones. ## Plan -Found by [#220](https://github.com/kixelated/rust2/pull/220) on 2026-10-29, where each is +Found by [#220](https://github.com/moq-dev/rust2/pull/220) on 2026-10-29, where each is refused as an unmapped call. A `&mut Arc` is an `rt.Place` since #220, so `make_mut`'s clone goes into the place's `v` when the count is above one, and `get_mut` gives the value only when the strong count is one and no `Weak` is left. diff --git a/quest/m3/ts-bind-gaps.md b/quest/m3/ts-bind-gaps.md index e7a967601..b2c4a259c 100644 --- a/quest/m3/ts-bind-gaps.md +++ b/quest/m3/ts-bind-gaps.md @@ -3,7 +3,7 @@ ## Goal rust2-ts's [bindings](/ts/README.md) cover a bound type as a collection key, through its -binding's `Hash`, `Eq`, and `Ord`, which [#127](https://github.com/kixelated/rust2/pull/127) +binding's `Hash`, `Eq`, and `Ord`, which [#127](https://github.com/moq-dev/rust2/pull/127) refuses. ## Plan diff --git a/quest/m3/ts-bytes-capacity.md b/quest/m3/ts-bytes-capacity.md index 1ad61442c..3b4827e1f 100644 --- a/quest/m3/ts-bytes-capacity.md +++ b/quest/m3/ts-bytes-capacity.md @@ -9,7 +9,7 @@ against native Rust. ## Plan -Found by [#222](https://github.com/kixelated/rust2/pull/222) on 2026-10-29: `bytes` +Found by [#222](https://github.com/moq-dev/rust2/pull/222) on 2026-10-29: `bytes` reclaims a `BytesMut`'s storage in `reserve` once no other handle of it is alive, so its capacity depends on whether the `Bytes` it froze and the handles it split off dropped. `rt.ByteSlice`, which a `Bytes` is, is a value JS copies and counts no drops, so #222 diff --git a/quest/m3/ts-drop-order.md b/quest/m3/ts-drop-order.md index 85cb3725f..ec62f27ef 100644 --- a/quest/m3/ts-drop-order.md +++ b/quest/m3/ts-drop-order.md @@ -10,7 +10,7 @@ all of std. ## Plan Moved from the m2 drop quest on 2026-10-27, once moq-net, its model, and kio had no -drop refusal left ([#139](https://github.com/kixelated/rust2/pull/139)). Each is refused +drop refusal left ([#139](https://github.com/moq-dev/rust2/pull/139)). Each is refused with a span where std's order is one JS's can't follow yet: - A closure that owns a value that drops given to a std function that takes another diff --git a/quest/m3/ts-f32.md b/quest/m3/ts-f32.md index 890dfc45a..eebcd11b3 100644 --- a/quest/m3/ts-f32.md +++ b/quest/m3/ts-f32.md @@ -10,7 +10,7 @@ native Rust. Decided with the maintainer on 2026-10-27: rust2 aims to support all of std, so this is planned without a moq consumer. The decisions of [float formatting](/quest/m2/ts-model/floats.md) -and of `f64`, which [#165](https://github.com/kixelated/rust2/pull/165) landed, carry over. +and of `f64`, which [#165](https://github.com/moq-dev/rust2/pull/165) landed, carry over. - An `f32` is a JS number rounded with `Math.fround` after every operation. A 64- or 128-bit integer rounds to `f32` once, never through `f64`, which would round twice. diff --git a/quest/m3/ts-fmt-wrappers.md b/quest/m3/ts-fmt-wrappers.md index 8fdc5a61f..de1773454 100644 --- a/quest/m3/ts-fmt-wrappers.md +++ b/quest/m3/ts-fmt-wrappers.md @@ -8,8 +8,8 @@ Proven by differential tests against native Rust. ## Plan -Suggested by [#177](https://github.com/kixelated/rust2/pull/177) (`Arc`, refused for every -`T`) and [#179](https://github.com/kixelated/rust2/pull/179) (ranges) on 2026-10-27. rust2 +Suggested by [#177](https://github.com/moq-dev/rust2/pull/177) (`Arc`, refused for every +`T`) and [#179](https://github.com/moq-dev/rust2/pull/179) (ranges) on 2026-10-27. rust2 aims to support all of std. A drained `RangeInclusive` prints `exhausted` in its `Debug`, which [the range fold](/quest/m3/ts-range-fold.md) makes observable. diff --git a/quest/m3/ts-fold-bool.md b/quest/m3/ts-fold-bool.md index e56184743..f465863de 100644 --- a/quest/m3/ts-fold-bool.md +++ b/quest/m3/ts-fold-bool.md @@ -3,7 +3,7 @@ ## Goal rust2-ts drops the dead arms of a match that a `bool` already decided, as -[#175](https://github.com/kixelated/rust2/pull/175) does for a match an `if` or guard sits +[#175](https://github.com/moq-dev/rust2/pull/175) does for a match an `if` or guard sits in front of: `if matches!(s, Shape::Dot) { match s { .. } }`, and `==` of a crate enum's derived `PartialEq`. Output only shrinks; the differential tests stay equal. diff --git a/quest/m3/ts-mut-ref.md b/quest/m3/ts-mut-ref.md index cf0f2fab0..3c7f7ebe0 100644 --- a/quest/m3/ts-mut-ref.md +++ b/quest/m3/ts-mut-ref.md @@ -10,7 +10,7 @@ through a `Take<&mut Self>`. ## Plan -Found by [#222](https://github.com/kixelated/rust2/pull/222) on 2026-10-29: a `&mut` to a +Found by [#222](https://github.com/moq-dev/rust2/pull/222) on 2026-10-29: a `&mut` to a type JS copies is an `rt.Place`, but a reference is never one, so `&mut &[u8]` is refused where it is made. moq-net's census refuses `<&mut &[u8] as Buf>::remaining` and `has_remaining` and `<&[u8] as Buf>::copy_to_bytes` in `transport/memory.rs`, which writes diff --git a/quest/m3/ts-ordering.md b/quest/m3/ts-ordering.md index a3e5c7901..52609a6ea 100644 --- a/quest/m3/ts-ordering.md +++ b/quest/m3/ts-ordering.md @@ -4,7 +4,7 @@ rust2-ts translates `cmp::max` and `cmp::min` (the free functions), the `is_sorted` family, and `BinaryHeap`, proven by differential tests against native Rust, and the cost -of [#173](https://github.com/kixelated/rust2/pull/173)'s comparison tests on integers is +of [#173](https://github.com/moq-dev/rust2/pull/173)'s comparison tests on integers is measured and, if it shows, removed. ## Plan diff --git a/quest/m3/ts-range-fold.md b/quest/m3/ts-range-fold.md index 1d552dd70..c388aecff 100644 --- a/quest/m3/ts-range-fold.md +++ b/quest/m3/ts-range-fold.md @@ -9,10 +9,10 @@ against native Rust. `for _ in r.by_ref()` over a `RangeInclusive`, then using ` ## Plan -[#179](https://github.com/kixelated/rust2/pull/179) gave `rt.Iter` a `folded()`, which each +[#179](https://github.com/moq-dev/rust2/pull/179) gave `rt.Iter` a `folded()`, which each consumer std folds reads through: the iterator itself, but a stepper of core's `try_fold` for a `RangeInclusive`, and its iterator's for a `&mut` borrow. A per-item method instead -cost up to 58% on `just ts bench`. [#172](https://github.com/kixelated/rust2/pull/172)'s +cost up to 58% on `just ts bench`. [#172](https://github.com/moq-dev/rust2/pull/172)'s per-kind `fold`, which consumers take where the iterator drops, forwards through each adaptor to the default `fold`, which reads through `folded()`. What remains is each adaptor where a consumer reads it by `next`: @@ -28,7 +28,7 @@ adaptor where a consumer reads it by `next`: `for _ in r.by_ref()` fails `tsc` today (`rt.iterBorrow(r)` is an `Iter`, not the `rt.RangeInclusive` it is assigned to), found by -[#147](https://github.com/kixelated/rust2/pull/147): `IntoIterator` for `&mut I` is typed as +[#147](https://github.com/moq-dev/rust2/pull/147): `IntoIterator` for `&mut I` is typed as a plain iterator. The fixtures drain with `while r.next().is_some()` around it. Public API: the translator's output. diff --git a/quest/m3/ts-tsrs.md b/quest/m3/ts-tsrs.md index 4576fb951..ace99aea8 100644 --- a/quest/m3/ts-tsrs.md +++ b/quest/m3/ts-tsrs.md @@ -11,7 +11,7 @@ Check: tsrs's releases, and whether it ships a crate (it is moving into Oxc). ## Plan Decided with the maintainer on 2026-10-27, on -[the bindings PR](https://github.com/kixelated/rust2/pull/127): translation runs the +[the bindings PR](https://github.com/moq-dev/rust2/pull/127): translation runs the flake's `tsc` 7 for now. tsrs was experimental then, and its reported speed over TypeScript 7 is the vendor's own. diff --git a/quest/m3/ts-unsafe.md b/quest/m3/ts-unsafe.md index 5ffab38ef..43fe628af 100644 --- a/quest/m3/ts-unsafe.md +++ b/quest/m3/ts-unsafe.md @@ -17,7 +17,7 @@ annotations or config; this quest is what retires them. Decided with the maintainer on 2026-10-28, typed pointers: a raw pointer is what its reference is, the object, an `rt.Place`, or `rt.NULL`, and a pointer into a slice or `Vec` is `{ array, index }`. Byte reinterpretation, pointer-to-integer casts, and raw allocation -are refused with a span. [#201](https://github.com/kixelated/rust2/pull/201) landed `Box` +are refused with a span. [#201](https://github.com/moq-dev/rust2/pull/201) landed `Box` to raw and back, `NonNull`, `MaybeUninit`, raw reads and writes, `get_unchecked`, and unions whose overlapping fields share a type, which took hashlink from 375 refusals to none of its own `unsafe`. @@ -40,7 +40,7 @@ none of its own `unsafe`. if a consumer's pointer is refused only by that. - A slice's pointer cast to an array's of its length, `*(s as *const [u8] as *const [u8; N])`, which `bytes`' `Buf::get_u16` and wider read a crate's own buffer through - ([#222](https://github.com/kixelated/rust2/pull/222)): the bytes keep their type, so + ([#222](https://github.com/moq-dev/rust2/pull/222)): the bytes keep their type, so this reinterprets nothing. Those getters also need `<[u8]>::get` and `get_mut` of a range, and each integer's `from_le_bytes` and `from_ne_bytes`, and `chunks_vectored` needs `std::io::IoSlice`: 184 of moq-net's 197 refusals in `bytes`, the rest being 12 diff --git a/quest/m4/README.md b/quest/m4/README.md index 6b474db51..c167ae0d6 100644 --- a/quest/m4/README.md +++ b/quest/m4/README.md @@ -14,8 +14,8 @@ Declined on 2026-10-25: a drop-in build-cache wrapper with an early cutoff. The cutoff is unsound on stock rustc (a stale SVH gives E0460, and DefIndex shifts), mbx and cargo already cover caching and GC, and a sound cutoff holds on only 7% of moq-net edits -([kixelated/rust2#62](https://github.com/kixelated/rust2/pull/62), -[kixelated/rust2#70](https://github.com/kixelated/rust2/pull/70)). +([moq-dev/rust2#62](https://github.com/moq-dev/rust2/pull/62), +[moq-dev/rust2#70](https://github.com/moq-dev/rust2/pull/70)). [The fork](/quest/m4/fork.md) collects the reasons to change rustc and cargo instead. ## Required diff --git a/quest/m4/fork.md b/quest/m4/fork.md index 0f7004f60..8ed2386e1 100644 --- a/quest/m4/fork.md +++ b/quest/m4/fork.md @@ -28,7 +28,7 @@ Each names what the fork changes, the measured gain on moq, and its source. under pipelining ([rust-lang/cargo#17439](https://github.com/rust-lang/cargo/issues/17439)). Gain: the replay estimates a cutoff holds on about 65 of 250 non-test moq-net edits in dev (26%), up from a sound 18 (7%), but on only 7 of 84 async edits - ([kixelated/rust2#62](https://github.com/kixelated/rust2/pull/62)). The + ([moq-dev/rust2#62](https://github.com/moq-dev/rust2/pull/62)). The estimate approximates the side table with `debug = 0` and `-Z location-detail=none`, which no differential test covers, so the fork's semantics need their own before this counts as sound. Each skip saves at most @@ -38,13 +38,13 @@ Each names what the fork changes, the measured gain on moq, and its source. ### Not reasons - **A drop-in `RUSTC_WRAPPER` cutoff**, declined on 2026-10-25 - ([kixelated/rust2#70](https://github.com/kixelated/rust2/pull/70)): + ([moq-dev/rust2#70](https://github.com/moq-dev/rust2/pull/70)): - it is unsound on stock rustc: a skipped dependent keeps its dependency's old SVH, so the next crate fails with E0460, and its rmeta encodes the dependency's DefIndex raw, which shifts; - caching, GC, and dedup are already in mbx, and cargo's cross-workspace cache goal is in progress; - its sound cutoff holds on 7% of moq-net edits - ([kixelated/rust2#62](https://github.com/kixelated/rust2/pull/62)). + ([moq-dev/rust2#62](https://github.com/moq-dev/rust2/pull/62)). Public API: none until the fork has a consumer. diff --git a/quest/m4/subset-compiler.md b/quest/m4/subset-compiler.md index 0f3868616..c62a23300 100644 --- a/quest/m4/subset-compiler.md +++ b/quest/m4/subset-compiler.md @@ -15,13 +15,13 @@ research, after moq's [poll-first](https://github.com/moq-dev/moq/blob/main/quest/m1/poll-first/README.md) and thin-generics work. -The [edit attribution](https://github.com/kixelated/rust2/pull/22) closed the +The [edit attribution](https://github.com/moq-dev/rust2/pull/22) closed the earlier version. What a revival has to answer: - **Most of the edit is rebuilding dependents:** 65% of the moq-net edit's critical path is crates rebuilt only because it changed. A public API hash could skip them ([relink](/quest/m3/relink.md)), but the - [semantic API hash replay](https://github.com/kixelated/rust2/pull/62) found + [semantic API hash replay](https://github.com/moq-dev/rust2/pull/62) found that a sound one holds on 18 of 250 non-test moq-net edits. - **What is left scales with the crate:** expansion, resolution, crate-wide analysis, and incremental I/O. A subset compiler would have to make these @@ -29,12 +29,12 @@ earlier version. What a revival has to answer: - **Linking:** it can't read or write rustc's unstable metadata, so it must own whole crates, with a C ABI or rustc-built shims at the boundary. - **Few proc macros buys little on edits:** the - [macro cost report](https://github.com/kixelated/rust2/pull/64) found that + [macro cost report](https://github.com/moq-dev/rust2/pull/64) found that running proc macros is about 5% of the moq-net edit, which `-Z cache-proc-macros` already removes, and compiling them is a clean-build cost. The largest share of macro output is tracing's `macro_rules!`, re-expanded in full on every rebuild. - **Evidence to collect first:** - - the [monomorphization budget](https://github.com/kixelated/rust2/pull/65) numbers. + - the [monomorphization budget](https://github.com/moq-dev/rust2/pull/65) numbers. Public API: none. diff --git a/ts/Cargo.toml b/ts/Cargo.toml index bd826a593..63f2d4def 100644 --- a/ts/Cargo.toml +++ b/ts/Cargo.toml @@ -21,7 +21,7 @@ resolver = "3" [workspace.package] edition = "2024" license = "MIT OR Apache-2.0" -repository = "https://github.com/kixelated/rust2" +repository = "https://github.com/moq-dev/rust2" [workspace.lints.rust] # What rust2-ts sets where it translates, for a safe twin of `unsafe`. diff --git a/uniffi/README.md b/uniffi/README.md index e5e8eb1a2..32291965c 100644 --- a/uniffi/README.md +++ b/uniffi/README.md @@ -10,7 +10,7 @@ Nothing is published to crates.io yet, so depend on a revision of this repositor ```toml [dependencies] -uniffi = { git = "https://github.com/kixelated/rust2", rev = "" } +uniffi = { git = "https://github.com/moq-dev/rust2", rev = "" } ``` Every crate keeps its upstream name (`uniffi`, `uniffi_core`, `uniffi_bindgen`, ...), so code @@ -28,7 +28,7 @@ The generators read a cdylib built against this runtime: The flake builds them all as `packages.uniffi`, and each one alone as `uniffi-bindgen`, `uniffi-bindgen-go`, `uniffi-bindgen-dart`, and `uniffi-bindgen-cpp`. Without Nix: -`cargo install --git https://github.com/kixelated/rust2 --rev uniffi-bindgen-go`. +`cargo install --git https://github.com/moq-dev/rust2 --rev uniffi-bindgen-go`. Upstream's [user guide](https://mozilla.github.io/uniffi-rs/0.32/) applies, minus Ruby. The generators document their options in [go/docs](go/docs/CONFIGURATION.md), diff --git a/uniffi/uniffi/Cargo.toml b/uniffi/uniffi/Cargo.toml index a87ccbb35..314f90388 100644 --- a/uniffi/uniffi/Cargo.toml +++ b/uniffi/uniffi/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "uniffi" description = "A hard fork of UniFFI: a multi-language bindings generator for rust" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" # Incrementing the minor version here means a breaking change to consumers. # A change to the FFI contract also updates `uniffi_meta::UNIFFI_CONTRACT_VERSION`. version = "0.1.0" diff --git a/uniffi/uniffi_bindgen/Cargo.toml b/uniffi/uniffi_bindgen/Cargo.toml index 04ad0a5dd..9e3529bad 100644 --- a/uniffi/uniffi_bindgen/Cargo.toml +++ b/uniffi/uniffi_bindgen/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_bindgen" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (codegen and cli tooling)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"] diff --git a/uniffi/uniffi_build/Cargo.toml b/uniffi/uniffi_build/Cargo.toml index 597ed829c..ff8a31262 100644 --- a/uniffi/uniffi_build/Cargo.toml +++ b/uniffi/uniffi_build/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_build" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (build script helpers)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"] diff --git a/uniffi/uniffi_core/Cargo.toml b/uniffi/uniffi_core/Cargo.toml index e3e7d0979..2b909b275 100644 --- a/uniffi/uniffi_core/Cargo.toml +++ b/uniffi/uniffi_core/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "uniffi_core" description = "A hard fork of UniFFI: a multi-language bindings generator for rust (runtime support code)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" version = "0.1.0" publish = false license = "MPL-2.0" diff --git a/uniffi/uniffi_internal_macros/Cargo.toml b/uniffi/uniffi_internal_macros/Cargo.toml index 4c7ea8654..ac6449416 100644 --- a/uniffi/uniffi_internal_macros/Cargo.toml +++ b/uniffi/uniffi_internal_macros/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_internal_macros" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (interal macro crate)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"] diff --git a/uniffi/uniffi_macros/Cargo.toml b/uniffi/uniffi_macros/Cargo.toml index 6ba69021c..3e5069d1e 100644 --- a/uniffi/uniffi_macros/Cargo.toml +++ b/uniffi/uniffi_macros/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_macros" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (convenience macros)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"] diff --git a/uniffi/uniffi_meta/Cargo.toml b/uniffi/uniffi_meta/Cargo.toml index ef2aff113..5df492cf8 100644 --- a/uniffi/uniffi_meta/Cargo.toml +++ b/uniffi/uniffi_meta/Cargo.toml @@ -4,8 +4,8 @@ version = "0.1.0" publish = false edition = "2021" description = "A hard fork of UniFFI: uniffi_meta" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" keywords = ["ffi", "bindgen"] readme = "../README.md" diff --git a/uniffi/uniffi_pipeline/Cargo.toml b/uniffi/uniffi_pipeline/Cargo.toml index 3bee67f69..7b674fec9 100644 --- a/uniffi/uniffi_pipeline/Cargo.toml +++ b/uniffi/uniffi_pipeline/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_pipeline" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (codegen and cli tooling)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"] diff --git a/uniffi/uniffi_testing/Cargo.toml b/uniffi/uniffi_testing/Cargo.toml index 4f6ff75b1..6c7ed4110 100644 --- a/uniffi/uniffi_testing/Cargo.toml +++ b/uniffi/uniffi_testing/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_testing" version = "0.1.0" publish = false description = "A hard fork of UniFFI: a multi-language bindings generator for rust (testing helpers)" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" edition = "2021" license = "MPL-2.0" readme = "../README.md" diff --git a/uniffi/uniffi_udl/Cargo.toml b/uniffi/uniffi_udl/Cargo.toml index 5ba8a4f68..58d4c0030 100644 --- a/uniffi/uniffi_udl/Cargo.toml +++ b/uniffi/uniffi_udl/Cargo.toml @@ -3,8 +3,8 @@ name = "uniffi_udl" version = "0.1.0" publish = false description = "A hard fork of UniFFI: udl parsing for the uniffi project" -homepage = "https://github.com/kixelated/rust2/tree/main/uniffi" -repository = "https://github.com/kixelated/rust2" +homepage = "https://github.com/moq-dev/rust2/tree/main/uniffi" +repository = "https://github.com/moq-dev/rust2" license = "MPL-2.0" edition = "2021" keywords = ["ffi", "bindgen"]