feat(ts): pick the browser's randomness, and translate moq-net at moq's main

driver/src/cargo.rs

@@ -92,6 +92,9 @@ pub struct Check<'a> {
 	pub manifest: &'a Path,
 	/// The cargo package whose library the driver handles.
 	pub package: &'a str,
+	/// The `Cargo.toml` of a package that depends on it, which cargo resolves it through
+	/// instead of its own workspace, if any, absolute.
+	pub root: Option<&'a Path>,
 	/// The target to check for, or `None` for the host.
 	pub target: Option<&'a str>,
 	/// Passed on to `cargo check`, such as `--features`.
@@ -113,7 +116,7 @@ impl Check<'_> {
 			cmd.current_dir(package_dir).envs(self.env.iter().copied());
 			cmd.arg(subcommand)
 				.arg("--manifest-path")
-				.arg(self.manifest)
+				.arg(self.root.unwrap_or(self.manifest))
 				.arg("--package")
 				.arg(self.package)
 				.arg("--target-dir")
@@ -196,7 +199,7 @@ fn resolution(args: &[String]) -> Vec<&str> {
 }
 
 /// The directory of the workspace `manifest`, or the current directory, belongs to.
-fn workspace_root(manifest: Option<&Path>) -> Result<PathBuf, String> {
+pub fn workspace_root(manifest: Option<&Path>) -> Result<PathBuf, String> {
 	let mut cmd = cargo();
 	cmd.args(["locate-project", "--workspace", "--message-format", "plain"]);
 	if let Some(manifest) = manifest {

ffi/justfile

@@ -8,6 +8,11 @@ set shell := ["bash", "-euo", "pipefail", "-c"]
 
 export PATH := if env("RUST2_TS_TOOLCHAIN", "") == "" { env("PATH") } else { env("RUST2_TS_TOOLCHAIN") / "bin:" + env("PATH") }
 
+# The moq revision these recipes export by default, behind `just ts moq`'s: moq's later API
+# needs moq/ffi.toml to follow it, and past moq-dev/moq#7032 moq-tokio's `Send` check
+# overflows the recursion limit `moq-export` denies.
+moq_rev := "30f25c04e6d0288d87893dc609ba582518be2cf6"
+
 default:
     @just --list
 
@@ -37,7 +42,7 @@ fix:
 run *args:
     cargo run --locked --quiet -- {{ args }}
 
-# Census each package moq/ffi.toml exports into target/census/<package>.md, from the moq revision `just ts moq` pins or a checkout.
+# Census each package moq/ffi.toml exports into target/census/<package>.md, from the pinned moq revision or a checkout.
 census checkout="": (standin checkout)
     cargo run --locked --quiet -- --config moq/ffi.toml --manifest-path target/moq-ffi/Cargo.toml --census target/census
 
@@ -64,7 +69,7 @@ bench checkout="": (moq checkout)
         kotlin -Djava.library.path="$out/target/release" -cp "target/bench-kt:$KOTLINX_COROUTINES" ExportKt
     done
 
-# Export moq's crates' C ABI, build it, and run moq/moq.c, moq/moq.cpp, and moq/moq.kt against it, from the moq revision `just ts moq` pins or a checkout.
+# Export moq's crates' C ABI, build it, and run moq/moq.c, moq/moq.cpp, and moq/moq.kt against it, from the pinned moq revision or a checkout.
 moq checkout="": (moq-cpp checkout)
     #!/usr/bin/env bash
     set -euo pipefail
@@ -107,14 +112,14 @@ moq-export checkout="": (standin checkout)
     RUSTFLAGS="-D recursion_depth_exceeding_limit --print=native-static-libs" cargo build --quiet --release --manifest-path "$out/Cargo.toml" --features kotlin 2>&1 | tee target/moq-build.log
     sed -n 's/^note: native-static-libs: //p' target/moq-build.log > target/moq-native
 
-# Write target/moq-ffi, an empty library on every crate moq/ffi.toml exports, from the moq revision `just ts moq` pins or a checkout: the check builds with all of them, as moq-ffi's remainder will.
+# Write target/moq-ffi, an empty library on every crate moq/ffi.toml exports, from the pinned moq revision or a checkout: the check builds with all of them, as moq-ffi's remainder will.
 [private]
 standin checkout="":
     #!/usr/bin/env bash
     set -euo pipefail
     src="{{ checkout }}"
     if [ -z "$src" ]; then
-        (cd ../ts && just moq-pin)
+        (cd ../ts && just moq-pin {{ moq_rev }})
         src=../ts/target/moq
     fi
     src=$(realpath "$src")

ffi/src/cli.rs

@@ -43,6 +43,7 @@ fn try_run(args: &[String]) -> Result<ExitCode, String> {
 		tool: "rust2-ffi",
 		manifest: &args.manifest,
 		package: &config.package,
+		root: None,
 		// The host's, whatever cargo's config names: a C ABI is the platform's, and the
 		// exports are found on it.
 		target: Some(rustc_session::config::host_tuple()),

flake.nix

@@ -304,13 +304,11 @@
             RUST2_TS_SYSROOT = rust2-ts-std;
             KOTLINX_COROUTINES = "${kotlinx-coroutines}";
           };
-          # `just ts bench` adds Chrome and Firefox as engines, and wasm-bindgen for moq-wasm's
-          # package, which must match the moq revision's or fails. Apart for their size.
+          # `just ts bench` adds Chrome and Firefox as engines. Apart for their size.
           devShells.bench = self.devShells.${system}.default.overrideAttrs (old: {
             nativeBuildInputs = old.nativeBuildInputs ++ [
               pkgs.chromium
               pkgs.firefox
-              pkgs.wasm-bindgen-cli
             ];
             # `just ffi bench` builds moq's rs/moq-c, whose VAAPI bindings run bindgen.
             LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";

quest/m1/ffi-export/recursion-limit.md

@@ -14,5 +14,6 @@ quest in moq.
 
 ## Plan
 
-Once it passes on moq's `main`, bump the exporter's `moq_rev` and update the config to what
+Once it passes on moq's `main`, drop the exporter's own `moq_rev` for `just ts moq`'s, so the
+translator and the exporter share one moq pin again, and update the config to what
 `just ffi census` then refuses.

quest/m2/README.md

@@ -26,7 +26,6 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export/README
 
 ## Required
 
-- [Translate moq-net without moq-wasm](/quest/m2/ts-moq-pin.md) - the translator's moq pin moves past moq's WASM removal, back onto the exporter's
-- [Translate moq-net's model to TypeScript](/quest/m2/ts-model/README.md) - the model translates with kio, moq-clock, and moq-pattern, for moq to compare against WASM
+- [Translate moq-net's model to TypeScript](/quest/m2/ts-model/README.md) - the model translates with kio and moq-pattern, as moq's browser route
 - [Waiting: Swift 6.4 in nixpkgs-unstable](/quest/m2/uniffi-swift-arm.md) - the nightly UniFFI fixtures move back to arm
 - [Waiting: ubrn reads UniFFI 0.32](/quest/m2/ubrn-release.md) - the binding benchmark's browser runner pins a ubrn release, not an open PR

quest/m2/ts-model/README.md

@@ -3,7 +3,7 @@
 ## Goal
 
 [rust2-ts](/ts/README.md) translates moq-net's model layer, with the workspace crates it
-calls (kio, moq-clock, moq-pattern), as it translates the codec today, so moq can ship
+calls (kio, with its clock, and moq-pattern), as it translates the codec today, so moq can ship
 `@moq/net` as JavaScript translated from its Rust, in place of the handwritten package.
 
 ## Plan
@@ -49,5 +49,6 @@ Public API: the translator's output for moq-net's model.
 
 ## Required
 
+- [The std calls moq's main added to the model](/quest/m2/ts-model/main-std.md) - `VecDeque::range`, and `str::rsplit_once` and `split_terminator` by a `char`, translate
 - [A crate's own hasher](/quest/m2/ts-model/own-hasher.md) - hashlink's default hasher, a crate's own `Hasher`, hashes keys as native's does
 - [A crate's own iterator traits](/quest/m2/ts-model/iter-traits.md) - hashlink's double-ended, exact-size, and fused iterators, and their `size_hint`

quest/m2/ts-model/main-std.md

@@ -0,0 +1,17 @@
+# [S] The std calls moq's main added to the model
+
+## Goal
+
+rust2-ts translates the std calls that moq-net's model reaches at moq's `main` and refused
+there first, proven by differential tests against native Rust: `VecDeque::range`, and
+`str::rsplit_once` and `str::split_terminator` by a `char`.
+
+## Plan
+
+Found moving the translator's moq pin past moq's WASM removal: each is one refusal in the
+census of `ts/moq/model.toml` (`model/group.rs`, `model/origin.rs`, `path/mod.rs`) that the
+previous pin's census did not have. Translate each as std's others of its kind are, with
+no config. The model's new `dyn DoubleEndedIterator` in `model/track.rs` is
+[trait objects](/quest/m3/ts-dyn.md)' work.
+
+Public API: the translator's output.

ts/Cargo.toml

@@ -40,7 +40,7 @@ toml = "1.1.8"
 [lints]
 workspace = true
 
-# moq's profile for moq-wasm, which ships size-optimized: the benchmark's WASM route.
+# The size-optimized profile moq's WASM shipped with: the benchmark's WASM route.
 [profile.wasm-release]
 inherits = "release"
 lto = "fat"

ts/README.md

@@ -9,7 +9,13 @@ rust2-ts --config ts.toml (--out dir | --census file.md) [--manifest-path Cargo.
 It runs `cargo check` on the package with itself as `RUSTC_WRAPPER`, for
 `wasm32-unknown-unknown`, against std checked from source with every function's MIR. The flake's
 package and dev shell check it once per toolchain and pass it as `RUST2_TS_SYSROOT`; without
-that, each target directory checks it with `-Zbuild-std`, which needs the toolchain's `rust-src`. Every crate compiles as rustc
+that, each target directory checks it with `-Zbuild-std`, which needs the toolchain's `rust-src`. Where the
+package builds with getrandom or uuid, which refuse wasm32 until a binary picks their source of randomness, cargo checks it
+as a dependency of a root package that picks `crypto.getRandomValues` by the feature each documents, as a browser's binary
+would, in a workspace that resolves as the package's own: its lockfile, patches, and dev profile, and its paths,
+relative to its root as rustc reads a member's. `--features` and `--no-default-features` pass to that dependency;
+`--all-features`, a feature of the package's dependency, and a `"*"` dev-profile override, which skips workspace members
+but would reach the package there, are refused. Every crate compiles as rustc
 would; the configured library is also translated, after type and borrow checking, starting from its roots and following
 what they reach. Every crate it depends on but std's translates with it as one program,
 as far as the roots reach: each compiles with every function's MIR, and its types and
@@ -968,8 +974,8 @@ comes up `Short` and retries, iterator chains over bytes, a `BTreeMap` of 16, 25
 4096 keys, and timestamps converted between timescales as moq-net's `Timestamp::convert`
 does, whose products pass 2^53, then added by its `checked_add` and ordered by its `Ord`,
 whose cross products do too, and integers sorted, searched for their greatest and least,
-and kept in a `BinaryHeap`. Each runs four ways: natively, as wasm32 at moq-wasm's
-size-optimized profile, hand-written (moq's `js/net` in `bench/moq.ts` and its `Timestamp`
+and kept in a `BinaryHeap`. Each runs four ways: natively, as wasm32 at the
+size-optimized profile moq's WASM shipped with, hand-written (moq's `js/net` in `bench/moq.ts` and its `Timestamp`
 in `bench/timestamp.ts`, ES iterator helpers in `bench/iter.ts`, a sorted array in
 `bench/sorted.ts`, `bigint` in `bench/rescale.ts`, as moq's `js/hang` converts
 timescales, and typed arrays and a heap of its own in `bench/order.ts`), and translated; every route's output must match
@@ -1007,4 +1013,4 @@ workloads still settle into one of two speeds per worker, up to 2x apart, so on
 their A/A stayed 6-35% wide while the median workload's was 1-3%. The report's
 A/A line also gives the noise of a family's geometric mean, the steadier gauge.
 
-The bench shell adds Chromium, Firefox, and the wasm-bindgen that builds moq-wasm's package.
+The bench shell adds Chromium and Firefox.

ts/bench/main.ts

@@ -2,7 +2,7 @@
 // Node, Bun, Chrome, and Firefox, and reports the numbers with each route's bundle size.
 //
 // usage: bun main.ts --translated <dir> --wasm <file> --native <bin> --moq <checkout>
-//                    --moq-wasm <dir> --task <dir> --task-wasm <file> --task-native <bin>
+//                    --task <dir> --task-wasm <file> --task-native <bin>
 //                    --out <dir> [--sample-ms 2] [--rounds 25] [--seed <u32>] [--route <name>=<dir>]
 //
 // The task fixture's async handoff runs beside the codec, against moq's way with promises.
@@ -30,7 +30,6 @@ const { values: args } = parseArgs({
 		wasm: { type: "string" },
 		native: { type: "string" },
 		moq: { type: "string" },
-		"moq-wasm": { type: "string" },
 		task: { type: "string" },
 		"task-wasm": { type: "string" },
 		"task-native": { type: "string" },
@@ -160,13 +159,11 @@ await Promise.all([
 	extra && Bun.write(join(out, "task-route.js"), extra.task),
 ]);
 
-const moqWasm = arg("moq-wasm");
 const sizes = [
 	{ route: "wasm", files: [wasmBytes] },
 	{ route: "hand-written", files: [handBundle] },
 	{ route: "translated", files: [translation] },
 	...(extra ? [{ route: extra.name, files: [extra.codec] }] : []),
-	{ route: "moq-wasm package", files: [await read(join(moqWasm, "moq_bg.wasm")), await read(join(moqWasm, "moq.js"))] },
 ].map(measureSize);
 
 // The task fixture: its channel, its async functions, and their runtime, as each route ships them.
@@ -366,7 +363,7 @@ function render(): string {
 		`of ${rounds} samples of at least ${sampleMs} ms, ± half their interquartile range. Each round runs`,
 		`the JS routes and workloads in a new random order, from seed ${seed}. \`native\` is a release`,
 		"build on the host, its workloads in a fixed order. `wasm` is the same",
-		"Rust at moq-wasm's size-optimized profile, run with its input already in memory;",
+		"Rust at the size-optimized profile moq's WASM shipped with, run with its input already in memory;",
 		"copying the input in and the output out are timed apart. `hand-written` is moq's",
 		"`js/net`, called as its own benchmarks call it, for `iter/` the same chain with ES",
 		"iterator helpers (`bench/iter.ts`), for `btree/` a sorted array (`bench/sorted.ts`), for `hash/` a `Map` (`bench/hashed.ts`), and",
@@ -380,8 +377,7 @@ function render(): string {
 		"",
 		"## Bundle size",
 		"",
-		"Bytes for the same workloads, as timed: minified by Bun where JS. `moq-wasm package` is what moq",
-		"ships as WASM today, its bindgen glue included: the whole consume path, not only the codec.",
+		"Bytes for the same workloads, as timed: minified by Bun where JS.",
 		"",
 		"| route | raw | gzip |",
 		"| --- | ---: | ---: |",

ts/justfile

@@ -9,7 +9,7 @@ set shell := ["bash", "-euo", "pipefail", "-c"]
 export PATH := if env("RUST2_TS_TOOLCHAIN", "") == "" { env("PATH") } else { env("RUST2_TS_TOOLCHAIN") / "bin:" + env("PATH") }
 
 # The moq revision `moq` translates by default.
-moq_rev := "30f25c04e6d0288d87893dc609ba582518be2cf6"
+moq_rev := "4b8e37bd44e407b3416a17992720870ea3f9221c"
 
 default:
     @just --list
@@ -51,8 +51,7 @@ moq checkout="":
         src=target/moq
     fi
     out=target/moq-ts
-    # moq-wasm comes along to select getrandom's wasm backend for moq-net.
-    cargo run --locked --quiet -- --config moq/ts.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --out "$out" -- --package moq-wasm
+    cargo run --locked --quiet -- --config moq/ts.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --out "$out"
     printf '{ "extends": "%s/runtime/tsconfig.json", "files": [], "include": ["**/*.ts"] }\n' "$PWD" > "$out/tsconfig.json"
     tsc -p "$out"
 
@@ -65,24 +64,24 @@ census checkout="":
         just moq-pin
         src=target/moq
     fi
-    cargo run --locked --quiet -- --config moq/net.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --census target/census/moq-net.md -- --package moq-wasm
-    cargo run --locked --quiet -- --config moq/model.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --census target/census/model.md -- --package moq-wasm
+    cargo run --locked --quiet -- --config moq/net.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --census target/census/moq-net.md
+    cargo run --locked --quiet -- --config moq/model.toml --manifest-path "$src/rs/moq-net/Cargo.toml" --census target/census/model.md
     cargo run --locked --quiet -- --config moq/kio.toml --manifest-path "$src/rs/kio/Cargo.toml" --census target/census/kio.md
 
-# Check out the pinned moq revision in target/moq.
+# Check out the pinned moq revision, or another, in target/moq.
 [private]
-moq-pin:
+moq-pin rev=moq_rev:
     [ -d target/moq/.git ] || git clone --quiet --filter=blob:none https://github.com/moq-dev/moq target/moq
     # Fetch only a missing pin; the partial clone would otherwise fetch it lazily to look it up.
-    GIT_NO_LAZY_FETCH=1 git -C target/moq cat-file -e {{ moq_rev }}^{commit} 2> /dev/null || git -C target/moq fetch --quiet --depth 1 origin {{ moq_rev }}
-    git -C target/moq checkout --quiet --detach {{ moq_rev }}
+    GIT_NO_LAZY_FETCH=1 git -C target/moq cat-file -e {{ rev }}^{commit} 2> /dev/null || git -C target/moq fetch --quiet --depth 1 origin {{ rev }}
+    git -C target/moq checkout --quiet --detach {{ rev }}
 
 # Time the codec natively, as moq's WASM, as moq's hand-written TS, and translated, in Node, Bun, Chrome, and Firefox; `--route name=dir` adds another run's translations.
 [arg("route", long)]
 bench checkout="" route="": (moq checkout)
     #!/usr/bin/env bash
     set -euo pipefail
-    for tool in bun chromium firefox wasm-bindgen; do
+    for tool in bun chromium firefox; do
         command -v "$tool" > /dev/null || { echo "$tool is missing: run this in the bench shell, nix develop .#bench" >&2; exit 1; }
     done
     src="{{ checkout }}"
@@ -98,10 +97,7 @@ bench checkout="" route="": (moq checkout)
     cargo build --locked --quiet --package task-fixture --example handoff --release
     # moq's hand-written TS imports its npm dependencies; its postinstall builds libav.
     (cd "$src" && bun install --frozen-lockfile --ignore-scripts --filter @moq/net)
-    # moq-wasm's package, as moq's `just js wasm` builds it.
-    (cd "$src" && cargo build --locked --quiet --package moq-wasm --target wasm32-unknown-unknown --profile wasm-release)
-    wasm-bindgen --target web --out-name moq --out-dir "$out/moq-wasm" "$src/target/wasm32-unknown-unknown/wasm-release/moq_wasm.wasm"
-    bun bench/main.ts --translated "$out/translated" --moq "$src" --moq-wasm "$out/moq-wasm" --out "$out" \
+    bun bench/main.ts --translated "$out/translated" --moq "$src" --out "$out" \
         --wasm target/wasm32-unknown-unknown/wasm-release/codec_fixture.wasm --native target/release/examples/bench \
         --task "$out/task" \
         --task-wasm target/wasm32-unknown-unknown/wasm-release/task_fixture.wasm --task-native target/release/examples/handoff \