diff --git a/Cargo.toml b/Cargo.toml index 069c08bd..831e1e32 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -111,6 +111,10 @@ harness = false name = "typescript_transform_latency" harness = false +[[test]] +name = "esm_module_load_phases" +harness = false + [[test]] name = "migrate_config_split" harness = false diff --git a/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs b/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs index 85e18a7b..33439bf1 100644 --- a/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs +++ b/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs @@ -2184,6 +2184,10 @@ fn collect_declared_cjs_globals_in_esm(source: &str) -> Vec { let mut i = 0usize; let mut declared = Vec::::new(); while i < bytes.len() { + if bytes[i].is_ascii_whitespace() { + i = skip_ascii_whitespace(source, i); + continue; + } if let Some(next) = skip_esm_cjs_global_scanner_span(source, i) { i = next; continue; @@ -2241,6 +2245,10 @@ fn find_bare_cjs_global_in_esm_among( scopes.pop(); } + if bytes[i].is_ascii_whitespace() { + i = skip_ascii_whitespace(source, i); + continue; + } if let Some(next) = skip_esm_cjs_global_scanner_span(source, i) { i = next; continue; @@ -7207,6 +7215,14 @@ fn skip_ws_comments(source: &str, pos: usize) -> usize { skip_ws_comments_impl::(source, pos).0 } +fn skip_ascii_whitespace(source: &str, mut pos: usize) -> usize { + let bytes = source.as_bytes(); + while pos < bytes.len() && bytes[pos].is_ascii_whitespace() { + pos += 1; + } + pos +} + fn skip_ws_comments_with_line_terminator(source: &str, pos: usize) -> (usize, bool) { skip_ws_comments_impl::(source, pos) } @@ -11848,6 +11864,9 @@ pub(crate) async fn initialize_module_loading(rt: &AsyncRuntime, ctx: &AsyncCont } fn rewrite_import_meta_main(source: &str, replacement: &str) -> String { + if !source.contains("import") { + return source.to_string(); + } let mut spans = Vec::new(); let _ = scan_code_positions(source, true, |i, _| { if let Some(end) = parse_import_meta_main_span(source, i) { @@ -12707,6 +12726,19 @@ import "./dep.js" withあ; ); } + #[test] + fn dense_whitespace_keeps_esm_scanner_results() { + let padding = " \n\t\r".repeat(16_384); + let source = format!("{padding}export default 42;"); + + assert_cjs_global(&source, None); + assert!(collect_declared_cjs_globals_in_esm(&source).is_empty()); + assert_eq!(rewrite_import_meta_main(&source, "false"), source); + + let with_require = format!("{padding}export default require;"); + assert_cjs_global(&with_require, Some("require")); + } + #[test] fn package_type_diagnostics_ignore_local_exports_binding() { assert!( diff --git a/examples/runtime/esm-module-load-phases/src/esm-module-load-phases.js b/examples/runtime/esm-module-load-phases/src/esm-module-load-phases.js new file mode 100644 index 00000000..da0d74ad --- /dev/null +++ b/examples/runtime/esm-module-load-phases/src/esm-module-load-phases.js @@ -0,0 +1,49 @@ +import fs from 'node:fs'; +import { stripTypeScriptTypes } from 'node:module'; +import { runJavaScript } from 'wasm-rquickjs:execution'; + +const ROOT = '/esm-module-load-phases'; + +function typedPrefix(sourceBytes) { + const lines = []; + let length = 0; + for (let index = 0; length < sourceBytes; index++) { + const line = `type Padding${index} = { value: number; next?: Padding${index} };\n`; + lines.push(line); + length += line.length; + } + return lines.join(''); +} + +export async function measureCase(sourceBytes, sample) { + fs.mkdirSync(ROOT, { recursive: true }); + const path = `${ROOT}/prepared-${sourceBytes}-${sample}.mjs`; + const typedSource = `${typedPrefix(Number(sourceBytes))} +globalThis.__esmPhaseMarks.evaluationStart = performance.now(); +export default function run(): number { return 42; } +globalThis.__esmPhaseMarks.evaluationEnd = performance.now();`; + const preparedSource = stripTypeScriptTypes(typedSource, { mode: 'strip' }); + fs.writeFileSync(path, preparedSource); + + const started = performance.now(); + const execution = await runJavaScript({ source: ` + globalThis.__esmPhaseMarks = {}; + globalThis.__esmPhaseMarks.importStart = performance.now(); + const loaded = await import(${JSON.stringify(path)}); + globalThis.__esmPhaseMarks.importResolved = performance.now(); + return { + value: loaded.default(), + marks: globalThis.__esmPhaseMarks, + }; + ` }); + return JSON.stringify({ + requestedSourceBytes: Number(sourceBytes), + actualSourceBytes: typedSource.length, + preparedSourceBytes: preparedSource.length, + elapsedMs: performance.now() - started, + value: execution.value.value, + marks: execution.value.marks, + overflowed: execution.overflowed, + profile: execution.profile, + }); +} diff --git a/examples/runtime/esm-module-load-phases/wit/esm-module-load-phases.wit b/examples/runtime/esm-module-load-phases/wit/esm-module-load-phases.wit new file mode 100644 index 00000000..69ea8371 --- /dev/null +++ b/examples/runtime/esm-module-load-phases/wit/esm-module-load-phases.wit @@ -0,0 +1,5 @@ +package quickjs:esm-module-load-phases; + +world esm-module-load-phases { + export measure-case: func(source-bytes: u64, sample: u64) -> string; +} diff --git a/tests/esm_module_load_phases.rs b/tests/esm_module_load_phases.rs new file mode 100644 index 00000000..d8beee60 --- /dev/null +++ b/tests/esm_module_load_phases.rs @@ -0,0 +1,413 @@ +//! Manual phase attribution for the slow strip-mode prepared-ESM path. +//! +//! The default path validates checked-in reports. Set +//! `ESM_MODULE_LOAD_PHASES_MEASURE=1` to execute five fresh-job samples. + +#![allow(dead_code)] + +#[path = "common/mod.rs"] +mod common; + +use camino::Utf8Path; +use common::{CompiledTest, FeatureCombination, TestInstance, test_target}; +use serde_json::{Map, Value, json}; +use std::fs; +use std::process::Command; +use std::time::{Duration, Instant}; +use wasmtime::component::Val; + +const EXAMPLE_DIR: &str = "examples/runtime/esm-module-load-phases"; +const RESULTS_DIR: &str = "tests/esm_module_load_phases/results"; +const SOURCE_BYTES: u64 = 65_536; +const ITERATIONS: usize = 5; +const INVOCATION_DEADLINE_SECONDS: u64 = 120; +const PHASES: &[&str] = &[ + "esm.importMetaLoader.total", + "esm.importMetaLoader.realpath", + "esm.importMetaLoader.sourceRead", + "esm.importMetaLoader.importAttrs", + "esm.importMetaLoader.cjsGlobalPreflight", + "esm.importMetaLoader.namedImportDiagnostics", + "esm.importMetaLoader.topLevelAwaitScan", + "esm.importMetaLoader.prologueInjection", + "esm.importMetaLoader.sourceMapRegistration", + "esm.importMetaLoader.quickjsDeclare", + "esm.importMetaLoader.importMetaInit", + "esm.nodeFileResolve", +]; +const EXCLUSIVE_LOADER_PHASES: &[&str] = &[ + "realpath", + "sourceRead", + "importAttrs", + "cjsGlobalPreflight", + "namedImportDiagnostics", + "topLevelAwaitScan", + "prologueInjection", + "sourceMapRegistration", + "quickjsDeclare", + "importMetaInit", +]; + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + if std::env::var_os("ESM_MODULE_LOAD_PHASES_MEASURE").is_none() { + return validate_checked_reports(); + } + + let build_started = Instant::now(); + let compiled = CompiledTest::new_with_features( + Utf8Path::new(EXAMPLE_DIR), + true, + FeatureCombination::TypeScriptCompilerProfiling, + ) + .await?; + let build_ms = millis(build_started.elapsed()); + let component_bytes = fs::metadata(compiled.wasm_path())?.len(); + let instantiate_started = Instant::now(); + let mut instance = TestInstance::new_with_memory_tracking(compiled.wasm_path()).await?; + let instantiate_ms = millis(instantiate_started.elapsed()); + + let mut samples = Vec::new(); + for sample in 0..ITERATIONS { + eprintln!("measuring prepared ESM phase sample {}", sample + 1); + samples.push( + invoke_json( + &mut instance, + "measure-case", + &[Val::U64(SOURCE_BYTES), Val::U64(sample as u64)], + ) + .await?, + ); + } + + let report = json!({ + "schemaVersion": 1, + "environment": environment()?, + "inputs": { + "instrumentationPatchBlake3": hash_file(Utf8Path::new(&required_env("ESM_MODULE_LOAD_PHASES_PATCH_FILE")?))?, + "patchedFilesHash": patched_files_hash()?, + }, + "target": format!("{:?}", test_target()).to_lowercase(), + "mode": "strip", + "path": "prepared-esm", + "iterations": ITERATIONS, + "sourceBytes": SOURCE_BYTES, + "component": { + "bytes": component_bytes, + "blake3": hash_file(compiled.wasm_path())?, + "buildMs": build_ms, + "instantiateMs": instantiate_ms, + }, + "summary": summarize(&samples), + "samples": samples, + "wasmLinearMemoryHighWaterBytes": instance.linear_memory_high_water_bytes(), + "notes": [ + "manual local attribution; timings are not CI thresholds", + "each sample uses a unique module path and a fresh execution-job QuickJS runtime", + "the component instance is reused within one target report; runtime state is not", + "preEvaluationResidual includes uninstrumented resolver dispatch, QuickJS linking, and promise scheduling", + ], + }); + validate_report(&report)?; + let encoded = serde_json::to_string_pretty(&report)?; + if let Ok(path) = std::env::var("ESM_MODULE_LOAD_PHASES_REPORT") { + fs::write(path, format!("{encoded}\n"))?; + } + println!("{encoded}"); + Ok(()) +} + +async fn invoke_json( + instance: &mut TestInstance, + function: &str, + args: &[Val], +) -> anyhow::Result { + instance.set_epoch_deadline(INVOCATION_DEADLINE_SECONDS); + let started = Instant::now(); + let value = instance.invoke(None, function, args).await?; + let Some(Val::String(encoded)) = value else { + anyhow::bail!("{function} did not return a JSON string") + }; + let result: Value = serde_json::from_str(&encoded)?; + Ok(json!({ + "outerWallMs": millis(started.elapsed()), + "linearMemoryHighWaterBytes": instance.linear_memory_high_water_bytes(), + "derived": derive(&result)?, + "result": result, + })) +} + +fn derive(result: &Value) -> anyhow::Result { + let counters = result["profile"]["counters"] + .as_object() + .ok_or_else(|| anyhow::anyhow!("sample is missing profile counters"))?; + let micros = |phase: &str| -> anyhow::Result { + Ok(counters + .get(&format!("{phase}.micros")) + .and_then(Value::as_u64) + .ok_or_else(|| anyhow::anyhow!("missing {phase}.micros"))? as f64 + / 1000.0) + }; + let loader_total_ms = micros("esm.importMetaLoader.total")?; + let node_file_resolve_ms = micros("esm.nodeFileResolve")?; + let mut exclusive = Map::new(); + let mut known_loader_ms = 0.0; + for phase in EXCLUSIVE_LOADER_PHASES { + let value = micros(&format!("esm.importMetaLoader.{phase}"))?; + known_loader_ms += value; + exclusive.insert(format!("{phase}Ms"), json!(value)); + } + let marks = result["marks"] + .as_object() + .ok_or_else(|| anyhow::anyhow!("sample is missing JS marks"))?; + let mark = |name: &str| -> anyhow::Result { + marks + .get(name) + .and_then(Value::as_f64) + .ok_or_else(|| anyhow::anyhow!("missing {name} mark")) + }; + let import_start = mark("importStart")?; + let evaluation_start = mark("evaluationStart")?; + let evaluation_end = mark("evaluationEnd")?; + let import_resolved = mark("importResolved")?; + let pre_evaluation_ms = evaluation_start - import_start; + Ok(json!({ + "nodeFileResolveMs": node_file_resolve_ms, + "loaderTotalMs": loader_total_ms, + "exclusiveLoaderPhases": exclusive, + "knownLoaderMs": known_loader_ms, + "loaderMiscMs": loader_total_ms - known_loader_ms, + "preEvaluationMs": pre_evaluation_ms, + "preEvaluationResidualMs": pre_evaluation_ms - node_file_resolve_ms - loader_total_ms, + "evaluationMs": evaluation_end - evaluation_start, + "settlementMs": import_resolved - evaluation_end, + "importPromiseMs": import_resolved - import_start, + })) +} + +fn summarize(samples: &[Value]) -> Value { + let mut elapsed = samples + .iter() + .filter_map(|sample| sample.pointer("/result/elapsedMs").and_then(Value::as_f64)) + .collect::>(); + elapsed.sort_by(f64::total_cmp); + let mut pre_evaluation = samples + .iter() + .filter_map(|sample| { + sample + .pointer("/derived/preEvaluationMs") + .and_then(Value::as_f64) + }) + .collect::>(); + pre_evaluation.sort_by(f64::total_cmp); + json!({ + "medianElapsedMs": elapsed[elapsed.len() / 2], + "maximumElapsedMs": elapsed[elapsed.len() - 1], + "medianPreEvaluationMs": pre_evaluation[pre_evaluation.len() / 2], + }) +} + +fn validate_checked_reports() -> anyhow::Result<()> { + let directory = Utf8Path::new(RESULTS_DIR); + anyhow::ensure!(directory.exists(), "checked report directory is missing"); + let mut targets = std::collections::BTreeSet::new(); + for entry in fs::read_dir(directory)? { + let path = entry?.path(); + if path.extension().and_then(|value| value.to_str()) != Some("json") { + continue; + } + let report: Value = serde_json::from_slice(&fs::read(&path)?)?; + validate_report(&report).map_err(|error| anyhow::anyhow!("{}: {error}", path.display()))?; + let target = report["target"].as_str().unwrap().to_string(); + anyhow::ensure!(targets.insert(target), "duplicate target report"); + } + anyhow::ensure!( + targets == ["p2".to_string(), "p3".to_string()].into_iter().collect(), + "checked reports must contain exactly one P2 and one P3 report" + ); + Ok(()) +} + +fn validate_report(report: &Value) -> anyhow::Result<()> { + anyhow::ensure!(report["schemaVersion"] == 1, "unexpected report schema"); + anyhow::ensure!( + matches!(report["target"].as_str(), Some("p2" | "p3")), + "invalid target" + ); + anyhow::ensure!( + report["mode"] == "strip" && report["path"] == "prepared-esm", + "invalid workload" + ); + anyhow::ensure!( + report["iterations"] == ITERATIONS && report["sourceBytes"] == SOURCE_BYTES, + "invalid sample shape" + ); + anyhow::ensure!( + report["environment"]["baseRevision"] + .as_str() + .is_some_and(is_git_sha) + && report["inputs"]["instrumentationPatchBlake3"] + .as_str() + .is_some_and(is_blake3) + && report["inputs"]["patchedFilesHash"] + .as_str() + .is_some_and(is_blake3) + && report["component"]["blake3"] + .as_str() + .is_some_and(is_blake3), + "report source or component identity is incomplete" + ); + let samples = report["samples"] + .as_array() + .ok_or_else(|| anyhow::anyhow!("missing samples"))?; + anyhow::ensure!(samples.len() == ITERATIONS, "wrong sample count"); + let mut elapsed = Vec::new(); + let mut pre_evaluation = Vec::new(); + for sample in samples { + let result = &sample["result"]; + anyhow::ensure!( + result["value"] == 42 && result["overflowed"] == false, + "prepared ESM returned an invalid result" + ); + anyhow::ensure!( + result["requestedSourceBytes"] == SOURCE_BYTES, + "source size differs from report" + ); + anyhow::ensure!( + result["profile"]["version"] == 1, + "missing execution profile" + ); + let counters = result["profile"]["counters"] + .as_object() + .ok_or_else(|| anyhow::anyhow!("missing counters"))?; + for phase in PHASES { + anyhow::ensure!( + counters + .get(&format!("{phase}.calls")) + .and_then(Value::as_u64) + == Some(1), + "{phase} did not run exactly once" + ); + anyhow::ensure!( + counters + .get(&format!("{phase}.micros")) + .and_then(Value::as_u64) + .is_some(), + "{phase} is missing duration" + ); + } + let marks = &result["marks"]; + let ordered = [ + "importStart", + "evaluationStart", + "evaluationEnd", + "importResolved", + ] + .into_iter() + .map(|name| { + marks[name] + .as_f64() + .ok_or_else(|| anyhow::anyhow!("missing {name}")) + }) + .collect::>>()?; + anyhow::ensure!( + ordered.windows(2).all(|pair| pair[0] <= pair[1]), + "JS timestamps are not monotonic" + ); + let loader_total = sample["derived"]["loaderTotalMs"].as_f64().unwrap(); + let known_loader = sample["derived"]["knownLoaderMs"].as_f64().unwrap(); + anyhow::ensure!( + loader_total + 0.050 >= known_loader, + "exclusive loader phases exceed loader total" + ); + let import_promise = sample["derived"]["importPromiseMs"].as_f64().unwrap(); + let user_await = result["profile"]["phasesMs"]["userAwait"] + .as_f64() + .ok_or_else(|| anyhow::anyhow!("missing userAwait"))?; + anyhow::ensure!( + user_await + 1.0 >= import_promise, + "userAwait does not cover the import promise" + ); + elapsed.push(result["elapsedMs"].as_f64().unwrap()); + pre_evaluation.push(sample["derived"]["preEvaluationMs"].as_f64().unwrap()); + } + elapsed.sort_by(f64::total_cmp); + pre_evaluation.sort_by(f64::total_cmp); + anyhow::ensure!( + approximately_equal( + report["summary"]["medianElapsedMs"].as_f64(), + Some(elapsed[2]) + ) && approximately_equal( + report["summary"]["maximumElapsedMs"].as_f64(), + elapsed.last().copied() + ) && approximately_equal( + report["summary"]["medianPreEvaluationMs"].as_f64(), + Some(pre_evaluation[2]) + ), + "summary does not match raw samples" + ); + Ok(()) +} + +fn environment() -> anyhow::Result { + Ok(json!({ + "baseRevision": required_env("ESM_MODULE_LOAD_PHASES_BASE_REVISION")?, + "dirty": !command_text(Command::new("git").args(["status", "--porcelain"]))?.is_empty(), + "os": std::env::consts::OS, + "arch": std::env::consts::ARCH, + "rustc": command_text(Command::new("rustc").arg("--version"))?, + "cargo": command_text(Command::new("cargo").arg("--version"))?, + "artifactCache": std::env::var("WASM_RQUICKJS_TEST_ARTIFACT_CACHE").ok(), + "wasmtimeCache": std::env::var("WASM_RQUICKJS_TEST_WASMTIME_CACHE").ok(), + })) +} + +fn patched_files_hash() -> anyhow::Result { + let mut hasher = blake3::Hasher::new(); + for path in [ + "crates/wasm-rquickjs/skeleton/Cargo.toml_", + "crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs", + ] { + let bytes = fs::read(path)?; + hasher.update(&(path.len() as u64).to_le_bytes()); + hasher.update(path.as_bytes()); + hasher.update(&(bytes.len() as u64).to_le_bytes()); + hasher.update(&bytes); + } + Ok(hasher.finalize().to_hex().to_string()) +} + +fn hash_file(path: &Utf8Path) -> anyhow::Result { + Ok(blake3::hash(&fs::read(path)?).to_hex().to_string()) +} + +fn required_env(name: &str) -> anyhow::Result { + std::env::var(name).map_err(|_| anyhow::anyhow!("{name} is required while measuring")) +} + +fn command_text(command: &mut Command) -> anyhow::Result { + let output = command.output()?; + anyhow::ensure!( + output.status.success(), + "command failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + Ok(String::from_utf8(output.stdout)?.trim().to_string()) +} + +fn millis(duration: Duration) -> f64 { + duration.as_secs_f64() * 1000.0 +} + +fn approximately_equal(left: Option, right: Option) -> bool { + left.zip(right) + .is_some_and(|(left, right)| (left - right).abs() <= f64::EPSILON * 8.0) +} + +fn is_blake3(value: &str) -> bool { + value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) +} + +fn is_git_sha(value: &str) -> bool { + value.len() == 40 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) +} diff --git a/tests/esm_module_load_phases/2026-09-21-instrumentation.patch b/tests/esm_module_load_phases/2026-09-21-instrumentation.patch new file mode 100644 index 00000000..04e3f848 --- /dev/null +++ b/tests/esm_module_load_phases/2026-09-21-instrumentation.patch @@ -0,0 +1,212 @@ +diff --git a/crates/wasm-rquickjs/skeleton/Cargo.toml_ b/crates/wasm-rquickjs/skeleton/Cargo.toml_ +index a163394d..be9ff9b2 100644 +--- a/crates/wasm-rquickjs/skeleton/Cargo.toml_ ++++ b/crates/wasm-rquickjs/skeleton/Cargo.toml_ +@@ -93,7 +93,7 @@ typescript-transform-runtime = ["typescript-runtime"] + # Private test instrumentation. Individual test combinations opt into the + # capabilities they observe; this umbrella is excluded from every runtime tier. + test-observability = [] +-typescript-compiler-profiling = ["typescript-transform-runtime", "test-observability"] ++typescript-compiler-profiling = ["typescript-runtime", "test-observability"] + + # WebSocket support via the target-specific `golem:websocket@1.5.0` bindings. + websocket = ["dep:golem-websocket"] +diff --git a/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs b/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs +index 85e18a7b..988f3c2b 100644 +--- a/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs ++++ b/crates/wasm-rquickjs/skeleton/src/internal/module_loading.rs +@@ -22,8 +22,52 @@ use std::hash::BuildHasher; + use std::ops::ControlFlow; + use std::rc::Rc; + use std::sync::atomic::{AtomicUsize, Ordering}; ++#[cfg(feature = "typescript-compiler-profiling")] ++use std::time::Instant; + use std::time::{SystemTime, UNIX_EPOCH}; + ++#[cfg(feature = "typescript-compiler-profiling")] ++struct EsmPhaseTimer { ++ profile: Option>, ++ phase: &'static str, ++ started: Instant, ++} ++ ++#[cfg(feature = "typescript-compiler-profiling")] ++impl EsmPhaseTimer { ++ fn new(ctx: &Ctx<'_>, phase: &'static str) -> Self { ++ let profile = ctx ++ .userdata::() ++ .expect("runtime services not initialized") ++ .execution_profile(); ++ Self { ++ profile, ++ phase, ++ started: Instant::now(), ++ } ++ } ++} ++ ++#[cfg(feature = "typescript-compiler-profiling")] ++impl Drop for EsmPhaseTimer { ++ fn drop(&mut self) { ++ if let Some(profile) = &self.profile { ++ profile.increment(&format!("{}.calls", self.phase)); ++ profile.add( ++ &format!("{}.micros", self.phase), ++ self.started.elapsed().as_micros().min(u128::from(u64::MAX)) as u64, ++ ); ++ } ++ } ++} ++ ++macro_rules! esm_phase_timer { ++ ($ctx:expr, $phase:literal) => { ++ #[cfg(feature = "typescript-compiler-profiling")] ++ let _esm_phase_timer = EsmPhaseTimer::new($ctx, $phase); ++ }; ++} ++ + pub(crate) const IMPORT_META_RESOLVE_JS: &str = r#"const __wasm_rquickjs_import_meta_resolve_global = globalThis; + function __wasm_rquickjs_import_meta_resolve_impl(baseUrl, specifier) { + baseUrl = String(baseUrl); +@@ -3856,6 +3900,7 @@ impl NodeFileResolver { + + impl Resolver for NodeFileResolver { + fn resolve<'js>(&mut self, ctx: &Ctx<'js>, base: &str, name: &str) -> rquickjs::Result { ++ esm_phase_timer!(ctx, "esm.nodeFileResolve"); + if name.contains("://") || name.starts_with("node:") { + return Err(Error::new_resolving(base, name)); + } +@@ -10178,6 +10223,7 @@ fn read_module_source_or_throw<'js>( + module_id: &str, + source_path: &str, + ) -> rquickjs::Result { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.sourceRead"); + #[cfg(feature = "typescript-compiler-profiling")] + let profile = ctx + .userdata::() +@@ -11934,47 +11980,74 @@ fn declare_esm_file_module_from_source<'js>( + ) -> rquickjs::Result> { + let fs_abs_path = ensure_absolute_path(fs_path); + let module_abs_path = ensure_absolute_path(module_id); +- let processed = process_static_import_attrs(&raw_source, module_id); ++ let processed = { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.importAttrs"); ++ process_static_import_attrs(&raw_source, module_id) ++ }; + let source = &processed.source; + let init = file_import_meta_init(url, fs_abs_path.clone()); +- let raw_cjs_global_messages = require_esm_in_progress(ctx, &fs_abs_path, &init.url); +- + let globals = ctx.globals(); +- if let Ok(cache) = globals.get::<_, Object>("__esm_error_cache") +- && let Ok(cached_error) = cache.get::<_, Value>(module_id) +- && !cached_error.is_undefined() + { +- return Err(ctx.throw(cached_error)); ++ esm_phase_timer!(ctx, "esm.importMetaLoader.cjsGlobalPreflight"); ++ let raw_cjs_global_messages = require_esm_in_progress(ctx, &fs_abs_path, &init.url); ++ if let Ok(cache) = globals.get::<_, Object>("__esm_error_cache") ++ && let Ok(cached_error) = cache.get::<_, Value>(module_id) ++ && !cached_error.is_undefined() ++ { ++ return Err(ctx.throw(cached_error)); ++ } ++ if let Some(error_source) = ++ esm_file_preflight_error_module_source(source, preflight_mode, raw_cjs_global_messages) ++ { ++ return Module::declare(ctx.clone(), module_id, error_source.as_bytes().to_vec()); ++ } + } +- +- if let Some(error_source) = +- esm_file_preflight_error_module_source(source, preflight_mode, raw_cjs_global_messages) + { +- return Module::declare(ctx.clone(), module_id, error_source.as_bytes().to_vec()); +- } +- if let Some(error_source) = cjs_named_import_error_module_source(ctx, &fs_abs_path, source) { +- return Module::declare(ctx.clone(), module_id, error_source.as_bytes().to_vec()); ++ esm_phase_timer!(ctx, "esm.importMetaLoader.namedImportDiagnostics"); ++ if let Some(error_source) = cjs_named_import_error_module_source(ctx, &fs_abs_path, source) { ++ return Module::declare(ctx.clone(), module_id, error_source.as_bytes().to_vec()); ++ } + } + +- let has_top_level_await = source_has_top_level_await(source, true); +- let injected = inject_module_source_prologue( +- init.filename.as_deref(), +- source, +- processed.dynamic_import_binding_names.as_ref(), +- ); +- if let Ok(register_source_map) = +- globals.get::<_, Function>("__wasm_rquickjs_register_transformed_source_map") ++ let has_top_level_await = { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.topLevelAwaitScan"); ++ source_has_top_level_await(source, true) ++ }; ++ let injected = { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.prologueInjection"); ++ inject_module_source_prologue( ++ init.filename.as_deref(), ++ source, ++ processed.dynamic_import_binding_names.as_ref(), ++ ) ++ }; + { +- register_source_map.call::<_, ()>(( +- fs_abs_path.as_str(), +- injected.as_str(), +- module_id, +- 1, +- 0, +- true, +- ))?; ++ esm_phase_timer!(ctx, "esm.importMetaLoader.sourceMapRegistration"); ++ if let Ok(register_source_map) = ++ globals.get::<_, Function>("__wasm_rquickjs_register_transformed_source_map") ++ { ++ register_source_map.call::<_, ()>(( ++ fs_abs_path.as_str(), ++ injected.as_str(), ++ module_id, ++ 1, ++ 0, ++ true, ++ ))?; ++ } + } +- match declare_module_with_import_meta(ctx, module_id, &injected, &init) { ++ let declared = { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.quickjsDeclare"); ++ Module::declare(ctx.clone(), module_id, injected.as_bytes().to_vec()) ++ }; ++ let declared = declared.and_then(|module| { ++ { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.importMetaInit"); ++ initialize_module_import_meta(ctx, &module, &init)?; ++ } ++ Ok(module) ++ }); ++ match declared { + Ok(module) => { + if has_top_level_await { + mark_async_esm_module(ctx, &globals, &module_abs_path, &init.url)?; +@@ -12013,6 +12086,7 @@ impl Loader for ImportMetaLoader { + ctx: &Ctx<'js>, + path: &str, + ) -> rquickjs::Result> { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.total"); + let fs_path = module_filesystem_path(path); + let is_extensionless = std::path::Path::new(fs_path).extension().is_none(); + if !fs_path.ends_with(".mjs") && !is_extensionless { +@@ -12032,7 +12106,10 @@ impl Loader for ImportMetaLoader { + return throw_import_attr_type_incompatible(ctx); + } + +- let source_path = module_source_filesystem_path(ctx, path); ++ let source_path = { ++ esm_phase_timer!(ctx, "esm.importMetaLoader.realpath"); ++ module_source_filesystem_path(ctx, path) ++ }; + declare_esm_file_module( + ctx, + path, diff --git a/tests/esm_module_load_phases/README.md b/tests/esm_module_load_phases/README.md new file mode 100644 index 00000000..6ccd04f5 --- /dev/null +++ b/tests/esm_module_load_phases/README.md @@ -0,0 +1,40 @@ +# ESM module-load phase attribution + +This manual experiment attributes the roughly 11-second strip-mode prepared-ESM +latency reproduced by `tests/typescript_transform_latency`. It runs five serial +64-KiB samples for P2 and P3. Every sample creates a fresh execution-job QuickJS +runtime and a unique `.mjs` path; only the compiled component instance is reused +within a target report. + +The checked-in instrumentation patch is deliberately not applied to production +source. It records exclusive loader subphases and the surrounding resolver time in +the existing private execution profile. Same-runtime JavaScript timestamps locate +evaluation within the import promise. The remaining pre-evaluation interval is +reported as a residual containing unresolved resolver-chain dispatch, QuickJS +linking, and promise scheduling; it is not called an exact link timer. + +Run one target at a time from the repository root: + +```sh +tests/esm_module_load_phases/run.sh p2 +tests/esm_module_load_phases/run.sh p3 +``` + +The runner creates a detached temporary worktree at the current committed source, +verifies and applies the retained patch there, records one report, and removes the +worktree. This keeps the validated transform-latency reports current. Optional +artifact and Wasmtime caches remain disabled. Validate retained reports without +executing workloads with: + +```sh +tests/esm_module_load_phases/run.sh --check +``` + +The 2026-09-21 baseline capture attributed virtually all of the delay to the +CJS-global preflight scan and module-prologue injection. Each consumed about +5.2–5.4 seconds for the whitespace-preserving 64-KiB source, while QuickJS +declaration, filesystem resolution, evaluation, and the unresolved residual were +sub-millisecond. A narrowed production change now bulk-skips contiguous ASCII +whitespace in those scanners. The retained exact-revision candidate reports reduce +the P2/P3 end-to-end medians from 10.66/11.06 seconds to 192/197 milliseconds. See +the results README for the exact medians and interpretation. diff --git a/tests/esm_module_load_phases/results/2026-09-21-p2-macos-aarch64.json b/tests/esm_module_load_phases/results/2026-09-21-p2-macos-aarch64.json new file mode 100644 index 00000000..7d8efa5c --- /dev/null +++ b/tests/esm_module_load_phases/results/2026-09-21-p2-macos-aarch64.json @@ -0,0 +1,552 @@ +{ + "component": { + "blake3": "6afcddfb1cf9a53e60bfaac6ad45d69fa22e7aacd3365ae336eda4d9e2feab45", + "buildMs": 60423.962125000005, + "bytes": 174730364, + "instantiateMs": 14663.023958 + }, + "environment": { + "arch": "aarch64", + "artifactCache": null, + "baseRevision": "7bed8b048cbafc43bc2a300c8d7b48733bf05386", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "dirty": true, + "os": "macos", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", + "wasmtimeCache": null + }, + "inputs": { + "instrumentationPatchBlake3": "9ce449f5620139641768110fbb31f45e8fcf88ba6d8f3c2a891cb74264b8c242", + "patchedFilesHash": "0584982a4064bb630dcd53c1959066421dbeefec8fb906f993ed9d1752d90d68" + }, + "iterations": 5, + "mode": "strip", + "notes": [ + "manual local attribution; timings are not CI thresholds", + "each sample uses a unique module path and a fresh execution-job QuickJS runtime", + "the component instance is reused within one target report; runtime state is not", + "preEvaluationResidual includes uninstrumented resolver dispatch, QuickJS linking, and promise scheduling" + ], + "path": "prepared-esm", + "samples": [ + { + "derived": { + "evaluationMs": 0.003500000000002501, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.43, + "importAttrsMs": 4.239, + "importMetaInitMs": 0.017, + "namedImportDiagnosticsMs": 7.634, + "prologueInjectionMs": 0.499, + "quickjsDeclareMs": 0.156, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.169, + "sourceReadMs": 0.894, + "topLevelAwaitScanMs": 0.178 + }, + "importPromiseMs": 15.232499999999959, + "knownLoaderMs": 14.227000000000002, + "loaderMiscMs": 0.17599999999999838, + "loaderTotalMs": 14.403, + "nodeFileResolveMs": 0.568, + "preEvaluationMs": 15.20791699999998, + "preEvaluationResidualMs": 0.2369169999999805, + "settlementMs": 0.021082999999975982 + }, + "linearMemoryHighWaterBytes": 20119552, + "outerWallMs": 347.07687500000003, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 195.80408299999908, + "marks": { + "evaluationEnd": 185.113625, + "evaluationStart": 185.110125, + "importResolved": 185.134708, + "importStart": 169.90220800000003 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 430, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4239, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 17, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7634, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 499, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 156, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 169, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 894, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 178, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14403, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 568, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 168.011583, + "initialEvaluation": 0.090666, + "loaderInitialization": 1.457125, + "processConfiguration": 0.173792, + "queueDelay": 1.070833, + "resultFormatting": 0.012, + "runtimeCreation": 0.471083, + "teardown": 7.953666999999999, + "transportWiring": 0.132542, + "userAwait": 15.413125, + "wrapperPreparation": 0.014125 + }, + "totalMs": 194.83175, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.0031669999999621723, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.424, + "importAttrsMs": 4.273, + "importMetaInitMs": 0.014, + "namedImportDiagnosticsMs": 7.545, + "prologueInjectionMs": 0.587, + "quickjsDeclareMs": 0.14, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.159, + "sourceReadMs": 0.607, + "topLevelAwaitScanMs": 0.178 + }, + "importPromiseMs": 14.852208000000047, + "knownLoaderMs": 13.938, + "loaderMiscMs": 0.17300000000000004, + "loaderTotalMs": 14.111, + "nodeFileResolveMs": 0.55, + "preEvaluationMs": 14.836333000000081, + "preEvaluationResidualMs": 0.17533300000008012, + "settlementMs": 0.012708000000003494 + }, + "linearMemoryHighWaterBytes": 20119552, + "outerWallMs": 335.131916, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 194.15816600000107, + "marks": { + "evaluationEnd": 184.551083, + "evaluationStart": 184.54791600000004, + "importResolved": 184.563791, + "importStart": 169.71158299999996 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 424, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4273, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 14, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7545, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 587, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 140, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 159, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 607, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 178, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14111, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 550, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 168.719, + "initialEvaluation": 0.083916, + "loaderInitialization": 0.694209, + "processConfiguration": 0.087958, + "queueDelay": 0.363667, + "resultFormatting": 0.006917, + "runtimeCreation": 0.417666, + "teardown": 7.834458000000001, + "transportWiring": 0.098958, + "userAwait": 15.001, + "wrapperPreparation": 0.017334 + }, + "totalMs": 193.343458, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.004165999999969472, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.428, + "importAttrsMs": 4.238, + "importMetaInitMs": 0.015, + "namedImportDiagnosticsMs": 7.557, + "prologueInjectionMs": 0.574, + "quickjsDeclareMs": 0.138, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.181, + "sourceReadMs": 0.583, + "topLevelAwaitScanMs": 0.184 + }, + "importPromiseMs": 14.744749999999954, + "knownLoaderMs": 13.908999999999999, + "loaderMiscMs": 0.16900000000000048, + "loaderTotalMs": 14.078, + "nodeFileResolveMs": 0.472, + "preEvaluationMs": 14.72529199999994, + "preEvaluationResidualMs": 0.17529199999994027, + "settlementMs": 0.015292000000044936 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 333.54033300000003, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 192.27720899999983, + "marks": { + "evaluationEnd": 182.46833299999992, + "evaluationStart": 182.46416699999995, + "importResolved": 182.48362499999996, + "importStart": 167.738875 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 428, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4238, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 15, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7557, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 574, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 138, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 181, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 583, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 184, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14078, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 472, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 166.773625, + "initialEvaluation": 0.085958, + "loaderInitialization": 0.664208, + "processConfiguration": 0.097083, + "queueDelay": 0.363625, + "resultFormatting": 0.006791, + "runtimeCreation": 0.420042, + "teardown": 7.95475, + "transportWiring": 0.100334, + "userAwait": 14.887584, + "wrapperPreparation": 0.011708 + }, + "totalMs": 191.385625, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.003375000000005457, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.441, + "importAttrsMs": 4.266, + "importMetaInitMs": 0.017, + "namedImportDiagnosticsMs": 7.551, + "prologueInjectionMs": 0.572, + "quickjsDeclareMs": 0.179, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.169, + "sourceReadMs": 0.6, + "topLevelAwaitScanMs": 0.184 + }, + "importPromiseMs": 15.082332999999863, + "knownLoaderMs": 13.989999999999998, + "loaderMiscMs": 0.45700000000000074, + "loaderTotalMs": 14.447, + "nodeFileResolveMs": 0.454, + "preEvaluationMs": 15.06533300000001, + "preEvaluationResidualMs": 0.16433300000000983, + "settlementMs": 0.013624999999848342 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 332.66704200000004, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 192.1499580000018, + "marks": { + "evaluationEnd": 182.471542, + "evaluationStart": 182.468167, + "importResolved": 182.48516699999985, + "importStart": 167.40283399999998 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 441, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4266, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 17, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7551, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 572, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 179, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 169, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 600, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 184, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14447, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 454, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 166.439208, + "initialEvaluation": 0.091083, + "loaderInitialization": 0.6611250000000001, + "processConfiguration": 0.091625, + "queueDelay": 0.32345799999999997, + "resultFormatting": 0.00675, + "runtimeCreation": 0.409917, + "teardown": 7.9635, + "transportWiring": 0.099208, + "userAwait": 15.233833, + "wrapperPreparation": 0.011834 + }, + "totalMs": 191.3495, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.002958000000063521, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.428, + "importAttrsMs": 4.248, + "importMetaInitMs": 0.014, + "namedImportDiagnosticsMs": 7.519, + "prologueInjectionMs": 0.577, + "quickjsDeclareMs": 0.183, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.161, + "sourceReadMs": 0.596, + "topLevelAwaitScanMs": 0.179 + }, + "importPromiseMs": 14.743375000000015, + "knownLoaderMs": 13.915999999999999, + "loaderMiscMs": 0.1720000000000006, + "loaderTotalMs": 14.088, + "nodeFileResolveMs": 0.476, + "preEvaluationMs": 14.728499999999912, + "preEvaluationResidualMs": 0.16449999999991327, + "settlementMs": 0.01191700000003948 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 332.311625, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 191.26529200000004, + "marks": { + "evaluationEnd": 181.79545800000005, + "evaluationStart": 181.7925, + "importResolved": 181.8073750000001, + "importStart": 167.06400000000008 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 428, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4248, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 14, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7519, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 577, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 183, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 161, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 596, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 179, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14088, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 476, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 166.134, + "initialEvaluation": 0.08337499999999999, + "loaderInitialization": 0.6545420000000001, + "processConfiguration": 0.07404100000000001, + "queueDelay": 0.299958, + "resultFormatting": 0.006125, + "runtimeCreation": 0.424083, + "teardown": 7.786375, + "transportWiring": 0.099667, + "userAwait": 14.893584, + "wrapperPreparation": 0.010583 + }, + "totalMs": 190.483833, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + } + ], + "schemaVersion": 1, + "sourceBytes": 65536, + "summary": { + "maximumElapsedMs": 195.80408299999908, + "medianElapsedMs": 192.27720899999983, + "medianPreEvaluationMs": 14.836333000000081 + }, + "target": "p2", + "wasmLinearMemoryHighWaterBytes": 20185088 +} diff --git a/tests/esm_module_load_phases/results/2026-09-21-p3-macos-aarch64.json b/tests/esm_module_load_phases/results/2026-09-21-p3-macos-aarch64.json new file mode 100644 index 00000000..557e5c2b --- /dev/null +++ b/tests/esm_module_load_phases/results/2026-09-21-p3-macos-aarch64.json @@ -0,0 +1,552 @@ +{ + "component": { + "blake3": "f4556b66cbc73a3a2e7a8f602c393fdcc3c77e5988d8331e4bcb65187c4a21ef", + "buildMs": 57574.76904100001, + "bytes": 173362008, + "instantiateMs": 14410.372458 + }, + "environment": { + "arch": "aarch64", + "artifactCache": null, + "baseRevision": "7bed8b048cbafc43bc2a300c8d7b48733bf05386", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "dirty": true, + "os": "macos", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", + "wasmtimeCache": null + }, + "inputs": { + "instrumentationPatchBlake3": "9ce449f5620139641768110fbb31f45e8fcf88ba6d8f3c2a891cb74264b8c242", + "patchedFilesHash": "0584982a4064bb630dcd53c1959066421dbeefec8fb906f993ed9d1752d90d68" + }, + "iterations": 5, + "mode": "strip", + "notes": [ + "manual local attribution; timings are not CI thresholds", + "each sample uses a unique module path and a fresh execution-job QuickJS runtime", + "the component instance is reused within one target report; runtime state is not", + "preEvaluationResidual includes uninstrumented resolver dispatch, QuickJS linking, and promise scheduling" + ], + "path": "prepared-esm", + "samples": [ + { + "derived": { + "evaluationMs": 0.00304199999999355, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.446, + "importAttrsMs": 4.527, + "importMetaInitMs": 0.045, + "namedImportDiagnosticsMs": 7.799, + "prologueInjectionMs": 0.612, + "quickjsDeclareMs": 0.276, + "realpathMs": 0.013, + "sourceMapRegistrationMs": 0.23, + "sourceReadMs": 0.76, + "topLevelAwaitScanMs": 0.199 + }, + "importPromiseMs": 16.22604099999998, + "knownLoaderMs": 14.907, + "loaderMiscMs": 0.5079999999999991, + "loaderTotalMs": 15.415, + "nodeFileResolveMs": 0.525, + "preEvaluationMs": 16.199333000000024, + "preEvaluationResidualMs": 0.2593330000000247, + "settlementMs": 0.023665999999963105 + }, + "linearMemoryHighWaterBytes": 20119552, + "outerWallMs": 357.622958, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 205.42295900000315, + "marks": { + "evaluationEnd": 193.67216700000003, + "evaluationStart": 193.66912500000004, + "importResolved": 193.695833, + "importStart": 177.469792 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 446, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4527, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 45, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7799, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 612, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 276, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 13, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 230, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 760, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 199, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 15415, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 525, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 175.40900000000002, + "initialEvaluation": 0.103667, + "loaderInitialization": 1.450541, + "processConfiguration": 0.164375, + "queueDelay": 0.877875, + "resultFormatting": 0.017291, + "runtimeCreation": 0.487167, + "teardown": 9.023917, + "transportWiring": 0.295875, + "userAwait": 16.45725, + "wrapperPreparation": 0.017542 + }, + "totalMs": 204.339042, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.0027919999999994616, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.442, + "importAttrsMs": 4.355, + "importMetaInitMs": 0.027, + "namedImportDiagnosticsMs": 7.886, + "prologueInjectionMs": 0.508, + "quickjsDeclareMs": 0.219, + "realpathMs": 0.01, + "sourceMapRegistrationMs": 0.224, + "sourceReadMs": 0.626, + "topLevelAwaitScanMs": 0.184 + }, + "importPromiseMs": 15.72020800000007, + "knownLoaderMs": 14.480999999999998, + "loaderMiscMs": 0.4720000000000013, + "loaderTotalMs": 14.953, + "nodeFileResolveMs": 0.549, + "preEvaluationMs": 15.700958000000043, + "preEvaluationResidualMs": 0.1989580000000437, + "settlementMs": 0.016458000000028505 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 347.706833, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 200.9238330000007, + "marks": { + "evaluationEnd": 189.697167, + "evaluationStart": 189.694375, + "importResolved": 189.71362500000004, + "importStart": 173.99341699999997 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 442, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4355, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 27, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7886, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 508, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 219, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 10, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 224, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 626, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 184, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14953, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 549, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 172.942916, + "initialEvaluation": 0.08875, + "loaderInitialization": 0.692583, + "processConfiguration": 0.123459, + "queueDelay": 0.352208, + "resultFormatting": 0.015625, + "runtimeCreation": 0.447167, + "teardown": 9.28775, + "transportWiring": 0.123584, + "userAwait": 15.903292, + "wrapperPreparation": 0.012041 + }, + "totalMs": 200.019416, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.002583000000015545, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.436, + "importAttrsMs": 4.295, + "importMetaInitMs": 0.016, + "namedImportDiagnosticsMs": 7.657, + "prologueInjectionMs": 0.484, + "quickjsDeclareMs": 0.149, + "realpathMs": 0.011, + "sourceMapRegistrationMs": 0.165, + "sourceReadMs": 0.613, + "topLevelAwaitScanMs": 0.189 + }, + "importPromiseMs": 15.191667000000052, + "knownLoaderMs": 14.014999999999999, + "loaderMiscMs": 0.45800000000000196, + "loaderTotalMs": 14.473, + "nodeFileResolveMs": 0.534, + "preEvaluationMs": 15.1764170000001, + "preEvaluationResidualMs": 0.16941700000009874, + "settlementMs": 0.012666999999936479 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 343.66454200000004, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 197.3629170000022, + "marks": { + "evaluationEnd": 187.598125, + "evaluationStart": 187.595542, + "importResolved": 187.61079199999995, + "importStart": 172.4191249999999 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 436, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4295, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 16, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7657, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 484, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 149, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 11, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 165, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 613, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 189, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14473, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 534, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 171.429041, + "initialEvaluation": 0.08708300000000001, + "loaderInitialization": 0.664083, + "processConfiguration": 0.119084, + "queueDelay": 0.341792, + "resultFormatting": 0.007125, + "runtimeCreation": 0.4255, + "teardown": 7.956167, + "transportWiring": 0.099792, + "userAwait": 15.348042, + "wrapperPreparation": 0.011 + }, + "totalMs": 196.507167, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.0024160000000392756, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.423, + "importAttrsMs": 4.3, + "importMetaInitMs": 0.014, + "namedImportDiagnosticsMs": 7.559, + "prologueInjectionMs": 0.57, + "quickjsDeclareMs": 0.181, + "realpathMs": 0.01, + "sourceMapRegistrationMs": 0.163, + "sourceReadMs": 0.619, + "topLevelAwaitScanMs": 0.178 + }, + "importPromiseMs": 15.344833000000108, + "knownLoaderMs": 14.017000000000001, + "loaderMiscMs": 0.44599999999999795, + "loaderTotalMs": 14.463, + "nodeFileResolveMs": 0.681, + "preEvaluationMs": 15.330917, + "preEvaluationResidualMs": 0.18691699999999933, + "settlementMs": 0.011500000000069122 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 333.21508300000005, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 191.5809999999983, + "marks": { + "evaluationEnd": 182.00016600000004, + "evaluationStart": 181.99775, + "importResolved": 182.0116660000001, + "importStart": 166.666833 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 423, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4300, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 14, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7559, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 570, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 181, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 10, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 163, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 619, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 178, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14463, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 681, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 165.631458, + "initialEvaluation": 0.083125, + "loaderInitialization": 0.681875, + "processConfiguration": 0.15275, + "queueDelay": 0.320791, + "resultFormatting": 0.005375, + "runtimeCreation": 0.413875, + "teardown": 7.878125, + "transportWiring": 0.096917, + "userAwait": 15.493083, + "wrapperPreparation": 0.010125 + }, + "totalMs": 190.783791, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + }, + { + "derived": { + "evaluationMs": 0.002457999999904814, + "exclusiveLoaderPhases": { + "cjsGlobalPreflightMs": 0.432, + "importAttrsMs": 4.347, + "importMetaInitMs": 0.015, + "namedImportDiagnosticsMs": 7.609, + "prologueInjectionMs": 0.585, + "quickjsDeclareMs": 0.188, + "realpathMs": 0.01, + "sourceMapRegistrationMs": 0.161, + "sourceReadMs": 0.705, + "topLevelAwaitScanMs": 0.179 + }, + "importPromiseMs": 15.298791999999821, + "knownLoaderMs": 14.231000000000002, + "loaderMiscMs": 0.4529999999999976, + "loaderTotalMs": 14.684, + "nodeFileResolveMs": 0.437, + "preEvaluationMs": 15.283500000000004, + "preEvaluationResidualMs": 0.16250000000000497, + "settlementMs": 0.012833999999912749 + }, + "linearMemoryHighWaterBytes": 20185088, + "outerWallMs": 332.01550000000003, + "result": { + "actualSourceBytes": 65761, + "elapsedMs": 191.0237500000003, + "marks": { + "evaluationEnd": 181.483375, + "evaluationStart": 181.4809170000001, + "importResolved": 181.4962089999999, + "importStart": 166.1974170000001 + }, + "overflowed": false, + "preparedSourceBytes": 65761, + "profile": { + "counters": { + "esm.importMetaLoader.cjsGlobalPreflight.calls": 1, + "esm.importMetaLoader.cjsGlobalPreflight.micros": 432, + "esm.importMetaLoader.importAttrs.calls": 1, + "esm.importMetaLoader.importAttrs.micros": 4347, + "esm.importMetaLoader.importMetaInit.calls": 1, + "esm.importMetaLoader.importMetaInit.micros": 15, + "esm.importMetaLoader.namedImportDiagnostics.calls": 1, + "esm.importMetaLoader.namedImportDiagnostics.micros": 7609, + "esm.importMetaLoader.prologueInjection.calls": 1, + "esm.importMetaLoader.prologueInjection.micros": 585, + "esm.importMetaLoader.quickjsDeclare.calls": 1, + "esm.importMetaLoader.quickjsDeclare.micros": 188, + "esm.importMetaLoader.realpath.calls": 1, + "esm.importMetaLoader.realpath.micros": 10, + "esm.importMetaLoader.sourceMapRegistration.calls": 1, + "esm.importMetaLoader.sourceMapRegistration.micros": 161, + "esm.importMetaLoader.sourceRead.calls": 1, + "esm.importMetaLoader.sourceRead.micros": 705, + "esm.importMetaLoader.topLevelAwaitScan.calls": 1, + "esm.importMetaLoader.topLevelAwaitScan.micros": 179, + "esm.importMetaLoader.total.calls": 1, + "esm.importMetaLoader.total.micros": 14684, + "esm.nodeFileResolve.calls": 1, + "esm.nodeFileResolve.micros": 437, + "filesystem.realpath.calls": 1, + "filesystem.realpath.success": 1, + "modules.directoryProbe.calls": 1, + "modules.directoryProbe.missing": 1, + "modules.directoryProbe.systemCalls": 1, + "modules.fileProbe.calls": 1, + "modules.fileProbe.found": 1, + "modules.fileProbe.systemCalls": 1, + "modules.pathProbe.systemCalls": 2, + "modules.realpath.cacheHits": 1, + "modules.realpath.calls": 2, + "modules.realpath.systemCalls": 1, + "modules.resolve.calls": 1, + "modules.resolve.missing": 1, + "modules.resolve.specifier.absolute": 1, + "modules.sourceRead.bytes": 65761, + "modules.sourceRead.calls": 1, + "modules.sourceRead.success": 1 + }, + "phasesMs": { + "builtinInitialization": 165.234583, + "initialEvaluation": 0.084417, + "loaderInitialization": 0.667541, + "processConfiguration": 0.087667, + "queueDelay": 0.305, + "resultFormatting": 0.006333, + "runtimeCreation": 0.401417, + "teardown": 7.88225, + "transportWiring": 0.10425, + "userAwait": 15.450417, + "wrapperPreparation": 0.011875 + }, + "totalMs": 190.252833, + "version": 1 + }, + "requestedSourceBytes": 65536, + "value": 42 + } + } + ], + "schemaVersion": 1, + "sourceBytes": 65536, + "summary": { + "maximumElapsedMs": 205.42295900000315, + "medianElapsedMs": 197.3629170000022, + "medianPreEvaluationMs": 15.330917 + }, + "target": "p3", + "wasmLinearMemoryHighWaterBytes": 20185088 +} diff --git a/tests/esm_module_load_phases/results/README.md b/tests/esm_module_load_phases/results/README.md new file mode 100644 index 00000000..361d7c64 --- /dev/null +++ b/tests/esm_module_load_phases/results/README.md @@ -0,0 +1,34 @@ +# Results + +The retained P2/P3 reports contain the final candidate's five raw samples, exact +base revision and instrumentation identities, component identity, execution +profile counters, and derived reconciliation. These are descriptive local +measurements, not CI thresholds. The baseline raw reports are summarized below +rather than retained sample by sample. + +The baseline capture attributed essentially the entire pre-evaluation interval to +two repository-owned Rust source scans: + +| Target | End-to-end median | Pre-evaluation median | CJS-global preflight median | Prologue injection median | QuickJS declaration median | Residual median | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | +| P2 | 10,657.94 ms | 10,478.13 ms | 5,235.03 ms | 5,225.32 ms | 0.22 ms | 0.25 ms | +| P3 | 11,058.54 ms | 10,867.23 ms | 5,433.22 ms | 5,436.13 ms | 0.27 ms | 0.47 ms | + +Those instrumented end-to-end medians remained close to the immediately preceding +uninstrumented prepared-ESM medians (11,088.28 ms for P2 and 10,859.98 ms for P3). +The evidence rejected QuickJS parsing, linking, evaluation, filesystem resolution, +and source reads as material owners of this workload. + +The final candidate bulk-skips contiguous ASCII whitespace in the two affected +source scanners. Its retained reports were captured from exact revision +`7bed8b048cbafc43bc2a300c8d7b48733bf05386`: + +| Target | End-to-end median | Pre-evaluation median | CJS-global preflight median | Prologue injection median | End-to-end reduction | +| --- | ---: | ---: | ---: | ---: | ---: | +| P2 | 192.28 ms | 14.84 ms | 0.43 ms | 0.57 ms | 98.20% | +| P3 | 197.36 ms | 15.33 ms | 0.44 ms | 0.57 ms | 98.22% | + +The candidate removes the whitespace-size pathology while keeping every sample's +result at 42 and preserving the report's counter and timing reconciliation +invariants. The broader TypeScript latency matrix and focused module-loader tests +provide the end-to-end and semantic checks. diff --git a/tests/esm_module_load_phases/run.sh b/tests/esm_module_load_phases/run.sh new file mode 100755 index 00000000..8ecb29b0 --- /dev/null +++ b/tests/esm_module_load_phases/run.sh @@ -0,0 +1,59 @@ +#!/bin/sh +set -eu + +repo_root=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd) +results_dir="$repo_root/tests/esm_module_load_phases/results" +patch_rel="tests/esm_module_load_phases/2026-09-21-instrumentation.patch" + +if [ "${1:-}" = "--check" ]; then + cd "$repo_root" + tools/dev-test.sh p2 standard esm_module_load_phases "" + exit 0 +fi + +target=${1:-} +case "$target" in + p2|p3) ;; + *) echo "usage: $0 " >&2; exit 2 ;; +esac + +cd "$repo_root" +git diff --quiet --exit-code +git diff --cached --quiet --exit-code +base_revision=$(git rev-parse HEAD) +worktree_parent=$(mktemp -d "${TMPDIR:-/tmp}/esm-module-load-phases.XXXXXX") +worktree="$worktree_parent/source" + +cleanup() { + git -C "$repo_root" worktree remove --force "$worktree" >/dev/null 2>&1 || true + rmdir "$worktree_parent" >/dev/null 2>&1 || true +} +trap cleanup EXIT HUP INT TERM + +git worktree add --detach "$worktree" "$base_revision" +patch_file="$worktree/$patch_rel" +git -C "$worktree" apply --check "$patch_file" +git -C "$worktree" apply "$patch_file" + +platform=$(node -p 'process.platform') +arch=$(node -p 'process.arch') +case "$platform" in + darwin) platform=macos ;; + win32) platform=windows ;; +esac +case "$arch" in + arm64) arch=aarch64 ;; + x64) arch=x86_64 ;; +esac + +mkdir -p "$results_dir" +default_report="$results_dir/$(date +%Y-%m-%d)-$target-$platform-$arch.json" +report=${ESM_MODULE_LOAD_PHASES_REPORT:-$default_report} +( + cd "$worktree" + ESM_MODULE_LOAD_PHASES_MEASURE=1 \ + ESM_MODULE_LOAD_PHASES_BASE_REVISION="$base_revision" \ + ESM_MODULE_LOAD_PHASES_PATCH_FILE="$patch_file" \ + ESM_MODULE_LOAD_PHASES_REPORT="$report" \ + tools/dev-test.sh "$target" standard esm_module_load_phases "" +) diff --git a/tests/goldenfiles/generated_types_esm-module-load-phases_exports.d.ts b/tests/goldenfiles/generated_types_esm-module-load-phases_exports.d.ts new file mode 100644 index 00000000..c75eea80 --- /dev/null +++ b/tests/goldenfiles/generated_types_esm-module-load-phases_exports.d.ts @@ -0,0 +1,3 @@ +declare module 'esm-module-load-phases' { + export function measureCase(sourceBytes: bigint, sample: bigint): Promise; +} diff --git a/tests/typescript_transform_latency/README.md b/tests/typescript_transform_latency/README.md index 13e4e992..c35b4e9f 100644 --- a/tests/typescript_transform_latency/README.md +++ b/tests/typescript_transform_latency/README.md @@ -39,17 +39,12 @@ sample uses a fresh execution job and, where filesystem-backed, a unique module path; direct API samples run in the report's outer runtime. No QuickJS runtime, Wasmtime store, or component instance is reused across reports. -The documented native-transform bound is deliberately narrow: the direct public -API samples cover dense requested-size profiles through 64 KiB on the recorded -three-sample macOS arm64 host and target combinations. The calibration observed the -requested 64-KiB direct-API maxima at or below 21 ms in all four P2/P3 -strip/transform profiles; a conservative 25 ms maximum is the accepted local bound -for those exact profiles. This is evidence, not a CI threshold or a general upper -bound. On those same profiles, the strip-mode prepared-ESM case reproduces nearly -all of the roughly 11-second ESM module latency after transformation, while inputs -from the same requested 64-KiB profile with dense stripped padding complete inline -in about 203 ms and through CommonJS in about 370 ms. This localizes the separate -bottleneck to the ESM module-loading path rather than generic compilation of -whitespace-preserving output. GOL-347 owns phase-level profiling and any measured -optimization for that path; end-to-end strip-mode ESM latency is not considered -acceptable here. +The direct public API samples cover dense requested-size profiles through 64 KiB on +the recorded three-sample macOS arm64 host and target combinations. The current +requested 64-KiB direct-API maxima range from 17.65 to 19.19 ms. This is descriptive +evidence, not a CI threshold or a general upper bound. Earlier strip-mode captures +showed roughly 11-second ESM module latency after transformation. GOL-347 localized +that delay to two repository-owned source scanners and changed them to bulk-skip +contiguous ASCII whitespace. The refreshed matrix now completes the requested +64-KiB strip-mode prepared-ESM case in 189–191 ms and ordinary ESM in 325–329 ms on +P2/P3, removing the whitespace-size pathology without changing the transform API. diff --git a/tests/typescript_transform_latency/results/2026-09-01-p2-strip-macos-aarch64.json b/tests/typescript_transform_latency/results/2026-09-21-p2-strip-macos-aarch64.json similarity index 66% rename from tests/typescript_transform_latency/results/2026-09-01-p2-strip-macos-aarch64.json rename to tests/typescript_transform_latency/results/2026-09-21-p2-strip-macos-aarch64.json index 407d4105..484212b6 100644 --- a/tests/typescript_transform_latency/results/2026-09-01-p2-strip-macos-aarch64.json +++ b/tests/typescript_transform_latency/results/2026-09-21-p2-strip-macos-aarch64.json @@ -5,15 +5,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 2.8770839999997406, - "medianMs": 1.3828749999993306, + "maximumMs": 2.7161250000026484, + "medianMs": 1.2831669999977748, "samples": [ { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 8.154791, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 6.736666, "result": { "actualSourceBytes": 4190, - "elapsedMs": 2.8770839999997406, + "elapsedMs": 2.7161250000026484, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -21,11 +21,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 2.213417, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.808875, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.3828749999993306, + "elapsedMs": 1.2831669999977748, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -33,11 +33,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 1.8682919999999998, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.700292, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.3636659999974654, + "elapsedMs": 1.255666999997629, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -52,15 +52,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 194.06300000000192, - "medianMs": 192.77816600000008, + "maximumMs": 182.10212500000125, + "medianMs": 176.81483300000036, "samples": [ { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 193.096458, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 182.760709, "result": { "actualSourceBytes": 4158, - "elapsedMs": 192.4394580000007, + "elapsedMs": 182.10212500000125, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -68,11 +68,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 193.626458, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 177.57475, "result": { "actualSourceBytes": 4158, - "elapsedMs": 192.77816600000008, + "elapsedMs": 176.81483300000036, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -80,11 +80,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 194.94245800000002, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 176.485708, "result": { "actualSourceBytes": 4158, - "elapsedMs": 194.06300000000192, + "elapsedMs": 175.78520800000115, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -99,15 +99,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 253.28641700000296, - "medianMs": 245.84083400000236, + "maximumMs": 187.94545799999833, + "medianMs": 187.8135829999992, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 254.263083, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 188.545208, "result": { "actualSourceBytes": 4190, - "elapsedMs": 253.28641700000296, + "elapsedMs": 187.8135829999992, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -115,11 +115,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 246.843875, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 188.61291599999998, "result": { "actualSourceBytes": 4190, - "elapsedMs": 245.84083400000236, + "elapsedMs": 187.94545799999833, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -127,11 +127,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 240.106042, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 186.791833, "result": { "actualSourceBytes": 4190, - "elapsedMs": 238.86912500000108, + "elapsedMs": 186.1688340000001, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -146,15 +146,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 245.45366600000125, - "medianMs": 241.39141599999857, + "maximumMs": 186.37550000000192, + "medianMs": 186.1263340000005, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 242.37225, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 187.034208, "result": { "actualSourceBytes": 4190, - "elapsedMs": 241.39141599999857, + "elapsedMs": 186.37550000000192, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -162,11 +162,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 239.502667, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 186.769667, "result": { "actualSourceBytes": 4190, - "elapsedMs": 238.65441699999792, + "elapsedMs": 186.1263340000005, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -174,11 +174,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 246.2065, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 186.193458, "result": { "actualSourceBytes": 4190, - "elapsedMs": 245.45366600000125, + "elapsedMs": 185.55595800000083, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -193,15 +193,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 234.70866699999897, - "medianMs": 232.65387499999997, + "maximumMs": 182.97166600000128, + "medianMs": 180.33200000000215, "samples": [ { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 243.39112500000002, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 186.488, "result": { "actualSourceBytes": 4190, - "elapsedMs": 232.65387499999997, + "elapsedMs": 176.41791699999885, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -209,11 +209,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 240.644208, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 192.952125, "result": { "actualSourceBytes": 4190, - "elapsedMs": 230.24625000000017, + "elapsedMs": 182.97166600000128, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -221,11 +221,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 245.64575, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 190.226708, "result": { "actualSourceBytes": 4190, - "elapsedMs": 234.70866699999897, + "elapsedMs": 180.33200000000215, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -240,15 +240,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 198.59424999999828, - "medianMs": 193.80566700000057, + "maximumMs": 191.26029199999903, + "medianMs": 190.5872079999972, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 199.41412499999998, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 191.97166700000002, "result": { "actualSourceBytes": 4190, - "elapsedMs": 198.59424999999828, + "elapsedMs": 191.26029199999903, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -256,11 +256,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 194.713166, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 191.295, "result": { "actualSourceBytes": 4190, - "elapsedMs": 193.80566700000057, + "elapsedMs": 190.5872079999972, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -268,11 +268,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 191.956709, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 190.425458, "result": { "actualSourceBytes": 4190, - "elapsedMs": 190.83379200000127, + "elapsedMs": 189.74937499999945, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -287,15 +287,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 5.550125000001572, - "medianMs": 5.103583999996772, + "maximumMs": 5.240916000000652, + "medianMs": 4.87749999999869, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 6.145875, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 6.53125, "result": { "actualSourceBytes": 16464, - "elapsedMs": 4.948041999999987, + "elapsedMs": 5.240916000000652, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -303,11 +303,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 6.574958, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 5.694542, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.550125000001572, + "elapsedMs": 4.87749999999869, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -315,11 +315,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 6.2955, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 5.60175, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.103583999996772, + "elapsedMs": 4.841834000000745, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -334,15 +334,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 185.0116249999992, - "medianMs": 183.74716700000135, + "maximumMs": 184.52249999999913, + "medianMs": 184.19916600000033, "samples": [ { - "linearMemoryHighWaterBytes": 20250624, - "outerWallMs": 184.83787500000003, + "linearMemoryHighWaterBytes": 20381696, + "outerWallMs": 181.272667, "result": { "actualSourceBytes": 16432, - "elapsedMs": 183.74716700000135, + "elapsedMs": 180.3247080000001, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -350,11 +350,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 181.9545, + "linearMemoryHighWaterBytes": 20381696, + "outerWallMs": 185.555, "result": { "actualSourceBytes": 16432, - "elapsedMs": 180.8371670000015, + "elapsedMs": 184.52249999999913, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -362,11 +362,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 186.215125, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 185.274459, "result": { "actualSourceBytes": 16432, - "elapsedMs": 185.0116249999992, + "elapsedMs": 184.19916600000033, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -381,15 +381,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 904.0727079999996, - "medianMs": 903.2578329999996, + "maximumMs": 215.20095799999945, + "medianMs": 215.03737499999988, "samples": [ { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 904.04975, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 216.45245799999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 902.6623330000002, + "elapsedMs": 215.20095799999945, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -397,11 +397,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 904.3656249999999, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 216.042625, "result": { "actualSourceBytes": 16464, - "elapsedMs": 903.2578329999996, + "elapsedMs": 215.03737499999988, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -409,11 +409,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 905.286834, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 216.055916, "result": { "actualSourceBytes": 16464, - "elapsedMs": 904.0727079999996, + "elapsedMs": 215.03337499999907, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -428,15 +428,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 901.8379999999996, - "medianMs": 900.909125, + "maximumMs": 214.60150000000067, + "medianMs": 214.5589170000003, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 902.977458, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 215.60000000000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 901.8379999999996, + "elapsedMs": 214.5589170000003, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -444,11 +444,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 902.081834, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 215.56375, "result": { "actualSourceBytes": 16464, - "elapsedMs": 900.909125, + "elapsedMs": 214.55879099999947, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -456,11 +456,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 899.258375, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 215.7665, "result": { "actualSourceBytes": 16464, - "elapsedMs": 898.0517080000009, + "elapsedMs": 214.60150000000067, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -475,15 +475,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 873.9858750000003, - "medianMs": 867.5398330000007, + "maximumMs": 180.02854200000002, + "medianMs": 179.7952499999992, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 904.250542, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 216.322208, "result": { "actualSourceBytes": 16464, - "elapsedMs": 866.2756250000002, + "elapsedMs": 180.02854200000002, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -491,11 +491,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 904.9795, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 216.02558299999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 867.5398330000007, + "elapsedMs": 179.7952499999992, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -503,11 +503,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 910.8125419999999, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 215.14075, "result": { "actualSourceBytes": 16464, - "elapsedMs": 873.9858750000003, + "elapsedMs": 179.1251250000023, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -522,15 +522,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 232.2219580000001, - "medianMs": 230.6682499999988, + "maximumMs": 219.04391699999903, + "medianMs": 217.5386669999989, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 231.842125, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 215.882916, "result": { "actualSourceBytes": 16464, - "elapsedMs": 230.6682499999988, + "elapsedMs": 214.8938330000019, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -538,11 +538,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 228.680083, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 218.62395800000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 227.61162499999955, + "elapsedMs": 217.5386669999989, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -550,11 +550,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 233.565458, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 220.150291, "result": { "actualSourceBytes": 16464, - "elapsedMs": 232.2219580000001, + "elapsedMs": 219.04391699999903, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -569,15 +569,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 20.5020829999994, - "medianMs": 19.45629200000076, + "maximumMs": 18.95104100000026, + "medianMs": 18.881250000000364, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 23.202375, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 21.220708000000002, "result": { "actualSourceBytes": 65634, - "elapsedMs": 20.5020829999994, + "elapsedMs": 18.95104100000026, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -585,11 +585,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 21.745125, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 21.043334, "result": { "actualSourceBytes": 65634, - "elapsedMs": 19.236041999998633, + "elapsedMs": 18.881250000000364, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -597,11 +597,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 21.904417, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 20.986458, "result": { "actualSourceBytes": 65634, - "elapsedMs": 19.45629200000076, + "elapsedMs": 18.86854100000164, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -616,15 +616,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 203.19824999999943, - "medianMs": 202.9507080000003, + "maximumMs": 195.06083300000137, + "medianMs": 193.5243330000012, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 205.596542, + "linearMemoryHighWaterBytes": 22216704, + "outerWallMs": 195.591458, "result": { "actualSourceBytes": 65602, - "elapsedMs": 202.9507080000003, + "elapsedMs": 193.28900000000067, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -632,11 +632,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 205.92779099999998, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 197.48612500000002, "result": { "actualSourceBytes": 65602, - "elapsedMs": 203.19824999999943, + "elapsedMs": 195.06083300000137, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -644,11 +644,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 205.387334, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 195.956, "result": { "actualSourceBytes": 65602, - "elapsedMs": 202.466124999999, + "elapsedMs": 193.5243330000012, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -663,15 +663,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 11136.495791, - "medianMs": 11040.891541999998, + "maximumMs": 326.51791700000103, + "medianMs": 325.43154199999844, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11043.846833, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 327.705083, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11040.891541999998, + "elapsedMs": 325.1125000000011, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -679,11 +679,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11139.602417, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 327.98233300000004, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11136.495791, + "elapsedMs": 325.43154199999844, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -691,11 +691,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11009.125083, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 328.87899999999996, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11006.025999999998, + "elapsedMs": 326.51791700000103, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -710,15 +710,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 11248.11499999999, - "medianMs": 11094.260749999989, + "maximumMs": 338.10100000000057, + "medianMs": 329.12633300000016, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 10995.456415999999, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 340.569833, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10992.569957999996, + "elapsedMs": 338.10100000000057, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -726,11 +726,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11251.577583, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 329.371375, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11248.11499999999, + "elapsedMs": 326.7248749999999, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -738,11 +738,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11097.703333, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 331.517625, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11094.260749999989, + "elapsedMs": 329.12633300000016, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -757,15 +757,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 10978.504750000007, - "medianMs": 10944.886209000004, + "maximumMs": 194.10108299999956, + "medianMs": 190.6754170000004, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11088.633333, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 334.79724999999996, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10944.886209000004, + "elapsedMs": 194.10108299999956, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -773,11 +773,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11045.548208, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 331.266875, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10901.547749999998, + "elapsedMs": 190.6754170000004, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -785,11 +785,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11126.390417, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 330.914208, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10978.504750000007, + "elapsedMs": 190.5682909999996, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -804,15 +804,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 378.5278340000077, - "medianMs": 372.50912499999686, + "maximumMs": 331.898541999999, + "medianMs": 331.21450000000004, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 375.700875, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 333.62016700000004, "result": { "actualSourceBytes": 65634, - "elapsedMs": 372.50912499999686, + "elapsedMs": 331.21450000000004, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -820,11 +820,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 381.13741699999997, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 332.496625, "result": { "actualSourceBytes": 65634, - "elapsedMs": 378.5278340000077, + "elapsedMs": 330.135542, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -832,11 +832,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 373.97925, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 334.38849999999996, "result": { "actualSourceBytes": 65634, - "elapsedMs": 371.2287500000093, + "elapsedMs": 331.898541999999, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -848,37 +848,37 @@ } ], "component": { - "blake3": "ccd30094b61e69913d54118a37495463d7ba24e9aa43fdc7085ec024ccdbf162", - "buildMs": 30495.357584, - "bytes": 154624624, - "instantiateMs": 16082.761792 + "blake3": "b05ffc3d9402c570641732c046b02ffcfdf3841a2483fa3af8673f4cf8b39661", + "buildMs": 29736.530833, + "bytes": 174182374, + "instantiateMs": 15200.170458 }, "concurrencyAtLargestSize": { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 28.767834, + "linearMemoryHighWaterBytes": 22478848, + "outerWallMs": 26.375084, "result": { - "baselineTimerMs": 2.6537919999973383, - "elapsedMs": 23.72329200000968, - "incrementalSiblingDelayMs": 21.039750000010827, + "baselineTimerMs": 2.7142910000002303, + "elapsedMs": 21.660375000001295, + "incrementalSiblingDelayMs": 18.93466799999987, "outputBytes": 65634, "requestedMs": 1, - "siblingIssuedMs": 23.693542000008165, - "transformMs": 20.779667000009795 + "siblingIssuedMs": 21.648959000000104, + "transformMs": 18.94304099999863 } }, "controlsAtLargestSize": { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 418.829791, + "linearMemoryHighWaterBytes": 22478848, + "outerWallMs": 388.525083, "result": { "cancellation": { "cancelled": true, - "completedMs": 207.7271250000049, - "issuedMs": 198.6288329999952, + "completedMs": 193.9515420000007, + "issuedMs": 185.90062500000025, "message": "execution job cancelled", "requestedMs": 1 }, "timeout": { - "completedMs": 208.5919160000049, + "completedMs": 192.4424169999984, "message": "execution job timed out", "timedOut": true } @@ -887,17 +887,17 @@ "environment": { "arch": "aarch64", "artifactCache": null, - "cargo": "cargo 1.95.0 (f2d3ce0bd 2026-03-21)", - "commitHint": "058b904201154bd2f89e1d07dd56629cbbcfbe67", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "commitHint": "012a07cc553ec91ab308e071ab8622358f5cfec1", "dirty": false, "os": "macos", - "rustc": "rustc 1.95.0 (59807616e 2026-04-14)", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", "unoptimized": null, "wasmtimeCache": null }, "inputs": { - "benchmarkHash": "9c271ca9f5517af7f4b5cc7638d3398b2a844e94e85c9e6775382aa0b1bc0a8f", - "runtimeHash": "791eeb5d424bbd485542532b553a58c7ecd7fc63d50c25921724032f95f17ccb" + "benchmarkHash": "bccc8d574c50193654300d836469eb52a13a895f08860614ec07f523e2f3630c", + "runtimeHash": "242cc8726fad9a244984ee6a65ef40e05a648ffdb3d191fba426affff17a0e65" }, "iterations": 3, "mode": "strip", @@ -914,5 +914,5 @@ 65536 ], "target": "p2", - "wasmLinearMemoryHighWaterBytes": 22413312 + "wasmLinearMemoryHighWaterBytes": 22478848 } diff --git a/tests/typescript_transform_latency/results/2026-09-01-p2-transform-macos-aarch64.json b/tests/typescript_transform_latency/results/2026-09-21-p2-transform-macos-aarch64.json similarity index 67% rename from tests/typescript_transform_latency/results/2026-09-01-p2-transform-macos-aarch64.json rename to tests/typescript_transform_latency/results/2026-09-21-p2-transform-macos-aarch64.json index e0047508..45fb1dcc 100644 --- a/tests/typescript_transform_latency/results/2026-09-01-p2-transform-macos-aarch64.json +++ b/tests/typescript_transform_latency/results/2026-09-21-p2-transform-macos-aarch64.json @@ -5,15 +5,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 4.1852079999989655, - "medianMs": 1.6069160000006375, + "maximumMs": 4.0132919999996375, + "medianMs": 1.4411670000008598, "samples": [ { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 7.698333, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 7.080542, "result": { "actualSourceBytes": 4190, - "elapsedMs": 4.1852079999989655, + "elapsedMs": 4.0132919999996375, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -21,11 +21,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 1.9805000000000001, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.944291, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.31329199999891, + "elapsedMs": 1.4411670000008598, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -33,11 +33,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 2.337792, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.8124580000000001, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.6069160000006375, + "elapsedMs": 1.337999999999738, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -52,15 +52,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 203.51545799999803, - "medianMs": 191.10612499999843, + "maximumMs": 191.29862499999945, + "medianMs": 187.75491599999805, "samples": [ { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 204.272291, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 191.87912500000002, "result": { "actualSourceBytes": 4158, - "elapsedMs": 203.51545799999803, + "elapsedMs": 191.29862499999945, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -68,11 +68,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 191.364708, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 188.56924999999998, "result": { "actualSourceBytes": 4158, - "elapsedMs": 190.3869579999991, + "elapsedMs": 187.75491599999805, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -80,11 +80,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 191.950583, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 187.839708, "result": { "actualSourceBytes": 4158, - "elapsedMs": 191.10612499999843, + "elapsedMs": 186.7964589999974, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -99,15 +99,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 202.3740829999988, - "medianMs": 199.81837499999892, + "maximumMs": 198.21870899999703, + "medianMs": 197.890707999999, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 203.596041, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 198.584667, "result": { "actualSourceBytes": 4190, - "elapsedMs": 202.3740829999988, + "elapsedMs": 197.890707999999, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -115,11 +115,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 200.71529099999998, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 197.48012500000002, "result": { "actualSourceBytes": 4190, - "elapsedMs": 199.81837499999892, + "elapsedMs": 196.8244169999998, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -127,11 +127,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 199.675667, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 198.889125, "result": { "actualSourceBytes": 4190, - "elapsedMs": 198.67820899999788, + "elapsedMs": 198.21870899999703, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -146,15 +146,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 199.1080839999995, - "medianMs": 196.4955829999999, + "maximumMs": 200.2625420000004, + "medianMs": 200.03429200000028, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 194.449792, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 200.853584, "result": { "actualSourceBytes": 4190, - "elapsedMs": 193.77391699999865, + "elapsedMs": 200.03429200000028, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -162,11 +162,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 199.864833, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 196.633166, "result": { "actualSourceBytes": 4190, - "elapsedMs": 199.1080839999995, + "elapsedMs": 195.95999999999913, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -174,11 +174,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 197.574666, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 200.993041, "result": { "actualSourceBytes": 4190, - "elapsedMs": 196.4955829999999, + "elapsedMs": 200.2625420000004, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -193,15 +193,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 192.5927499999998, - "medianMs": 186.1592500000006, + "maximumMs": 186.9182080000028, + "medianMs": 185.9215000000004, "samples": [ { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 189.1675, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 188.93183299999998, "result": { "actualSourceBytes": 4190, - "elapsedMs": 186.1592500000006, + "elapsedMs": 185.88083299999928, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -209,11 +209,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 195.872792, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 188.850167, "result": { "actualSourceBytes": 4190, - "elapsedMs": 192.5927499999998, + "elapsedMs": 185.9215000000004, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -221,11 +221,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 186.966667, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 190.352458, "result": { "actualSourceBytes": 4190, - "elapsedMs": 184.03466599999956, + "elapsedMs": 186.9182080000028, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -240,15 +240,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 195.84325000000172, - "medianMs": 195.7699590000011, + "maximumMs": 198.67137500000172, + "medianMs": 197.27400000000125, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 196.5605, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 198.03037500000002, "result": { "actualSourceBytes": 4190, - "elapsedMs": 195.7699590000011, + "elapsedMs": 197.27400000000125, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -256,11 +256,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 195.550916, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 199.578709, "result": { "actualSourceBytes": 4190, - "elapsedMs": 194.7901249999995, + "elapsedMs": 198.67137500000172, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -268,11 +268,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 196.568084, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 188.970208, "result": { "actualSourceBytes": 4190, - "elapsedMs": 195.84325000000172, + "elapsedMs": 188.31383300000016, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -287,15 +287,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 185.82458300000144, - "medianMs": 183.89858399999864, + "maximumMs": 188.12329200000025, + "medianMs": 181.31904199999917, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 184.80966600000002, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 189.015625, "result": { "actualSourceBytes": 4193, - "elapsedMs": 183.89858399999864, + "elapsedMs": 188.12329200000025, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -303,11 +303,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 181.712959, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 181.63191600000002, "result": { "actualSourceBytes": 4193, - "elapsedMs": 180.84258399999817, + "elapsedMs": 180.4454999999998, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -315,11 +315,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 186.63708400000002, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 182.150708, "result": { "actualSourceBytes": 4193, - "elapsedMs": 185.82458300000144, + "elapsedMs": 181.31904199999917, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -334,15 +334,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 4.916124999999738, - "medianMs": 4.893166999998357, + "maximumMs": 4.761749999999665, + "medianMs": 4.634374999999636, "samples": [ { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 6.031625, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 5.800291, "result": { "actualSourceBytes": 16464, - "elapsedMs": 4.916124999999738, + "elapsedMs": 4.761749999999665, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -350,11 +350,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 5.785958, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 5.456542, "result": { "actualSourceBytes": 16464, - "elapsedMs": 4.893166999998357, + "elapsedMs": 4.634374999999636, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -362,11 +362,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 5.725458, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 5.295459, "result": { "actualSourceBytes": 16464, - "elapsedMs": 4.816291999999521, + "elapsedMs": 4.533417000000554, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -381,15 +381,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 197.08241700000144, - "medianMs": 192.2531250000029, + "maximumMs": 183.86074999999985, + "medianMs": 183.2894580000011, "samples": [ { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 191.59475, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 184.741458, "result": { "actualSourceBytes": 16432, - "elapsedMs": 190.4947919999977, + "elapsedMs": 183.86074999999985, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -397,11 +397,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 193.41445900000002, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 182.95979200000002, "result": { "actualSourceBytes": 16432, - "elapsedMs": 192.2531250000029, + "elapsedMs": 181.69233299999905, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -409,11 +409,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 198.30175, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 184.361416, "result": { "actualSourceBytes": 16432, - "elapsedMs": 197.08241700000144, + "elapsedMs": 183.2894580000011, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -428,15 +428,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 299.0376670000005, - "medianMs": 283.86162500000137, + "maximumMs": 215.90687499999876, + "medianMs": 212.4577500000014, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 285.292541, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 216.93075000000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 283.86162500000137, + "elapsedMs": 215.90687499999876, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -444,11 +444,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 300.725959, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 212.874792, "result": { "actualSourceBytes": 16464, - "elapsedMs": 299.0376670000005, + "elapsedMs": 211.79570799999783, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -456,11 +456,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 264.205292, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 213.47133300000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 262.80204200000117, + "elapsedMs": 212.4577500000014, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -475,15 +475,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 302.8170000000009, - "medianMs": 250.72099999999955, + "maximumMs": 214.80545899999925, + "medianMs": 213.77566699999988, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 252.31058299999998, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 214.852167, "result": { "actualSourceBytes": 16464, - "elapsedMs": 250.72099999999955, + "elapsedMs": 213.77566699999988, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -491,11 +491,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 304.090167, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 214.5445, "result": { "actualSourceBytes": 16464, - "elapsedMs": 302.8170000000009, + "elapsedMs": 213.46133299999929, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -503,11 +503,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 239.793833, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 215.883625, "result": { "actualSourceBytes": 16464, - "elapsedMs": 238.4511249999996, + "elapsedMs": 214.80545899999925, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -522,15 +522,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 202.5224160000016, - "medianMs": 193.8763340000005, + "maximumMs": 177.12441699999908, + "medianMs": 175.49166699999842, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 210.150584, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 181.686375, "result": { "actualSourceBytes": 16464, - "elapsedMs": 202.5224160000016, + "elapsedMs": 175.24058400000104, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -538,11 +538,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 200.706167, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 183.327416, "result": { "actualSourceBytes": 16464, - "elapsedMs": 193.8763340000005, + "elapsedMs": 177.12441699999908, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -550,11 +550,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 196.37754199999998, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 181.80599999999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 188.17225000000144, + "elapsedMs": 175.49166699999842, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -569,15 +569,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 236.5767080000005, - "medianMs": 234.20395800000188, + "maximumMs": 215.6640420000003, + "medianMs": 212.3291250000002, "samples": [ { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 236.208084, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 213.508916, "result": { "actualSourceBytes": 16464, - "elapsedMs": 234.20395800000188, + "elapsedMs": 212.3291250000002, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -585,11 +585,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 234.74962499999998, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 213.34366699999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 233.2535829999997, + "elapsedMs": 212.124834000002, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -597,11 +597,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 237.769, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 216.683666, "result": { "actualSourceBytes": 16464, - "elapsedMs": 236.5767080000005, + "elapsedMs": 215.6640420000003, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -616,15 +616,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 200.28300000000127, - "medianMs": 198.62562500000055, + "maximumMs": 184.63979199999991, + "medianMs": 184.4547079999993, "samples": [ { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 201.653458, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 185.835834, "result": { "actualSourceBytes": 16467, - "elapsedMs": 200.28300000000127, + "elapsedMs": 184.63979199999991, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -632,11 +632,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 199.982375, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 185.742333, "result": { "actualSourceBytes": 16467, - "elapsedMs": 198.62562500000055, + "elapsedMs": 184.4547079999993, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -644,11 +644,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 197.55249999999998, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 183.233833, "result": { "actualSourceBytes": 16467, - "elapsedMs": 196.27620900000147, + "elapsedMs": 182.20704199999815, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -663,15 +663,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 19.03204200000073, - "medianMs": 18.98729099999946, + "maximumMs": 17.64587500000016, + "medianMs": 17.63154200000099, "samples": [ { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 20.914458, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 19.949833, "result": { "actualSourceBytes": 65634, - "elapsedMs": 18.31462499999907, + "elapsedMs": 17.64587500000016, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -679,11 +679,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 21.393834000000002, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 19.651334, "result": { "actualSourceBytes": 65634, - "elapsedMs": 19.03204200000073, + "elapsedMs": 17.514040999998542, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -691,11 +691,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 21.513541, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 19.767, "result": { "actualSourceBytes": 65634, - "elapsedMs": 18.98729099999946, + "elapsedMs": 17.63154200000099, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -710,15 +710,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 209.92562499999983, - "medianMs": 200.90462500000103, + "maximumMs": 196.25133300000016, + "medianMs": 196.2233750000014, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 212.909, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 198.354583, "result": { "actualSourceBytes": 65602, - "elapsedMs": 209.92562499999983, + "elapsedMs": 196.02441700000057, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -726,11 +726,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 203.43275, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 198.635791, "result": { "actualSourceBytes": 65602, - "elapsedMs": 200.90462500000103, + "elapsedMs": 196.25133300000016, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -738,11 +738,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 200.232833, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 198.601042, "result": { "actualSourceBytes": 65602, - "elapsedMs": 197.71662500000093, + "elapsedMs": 196.2233750000014, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -757,15 +757,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 323.21979199999987, - "medianMs": 322.43195800000103, + "maximumMs": 316.4423330000009, + "medianMs": 315.6650410000002, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 325.039875, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 317.5595, "result": { "actualSourceBytes": 65634, - "elapsedMs": 322.43195800000103, + "elapsedMs": 315.1889169999995, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -773,11 +773,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 325.76375, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 318.816292, "result": { "actualSourceBytes": 65634, - "elapsedMs": 323.21979199999987, + "elapsedMs": 316.4423330000009, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -785,11 +785,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 324.50183300000003, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 318.009084, "result": { "actualSourceBytes": 65634, - "elapsedMs": 322.0746659999986, + "elapsedMs": 315.6650410000002, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -804,15 +804,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 331.0949579999997, - "medianMs": 323.79745899999944, + "maximumMs": 317.89258399999926, + "medianMs": 315.024875000001, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 333.487209, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 317.450167, "result": { "actualSourceBytes": 65634, - "elapsedMs": 331.0949579999997, + "elapsedMs": 315.024875000001, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -820,11 +820,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 326.21245799999997, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 317.01162500000004, "result": { "actualSourceBytes": 65634, - "elapsedMs": 323.79745899999944, + "elapsedMs": 314.3341249999994, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -832,11 +832,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 324.130625, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 320.472583, "result": { "actualSourceBytes": 65634, - "elapsedMs": 321.55624999999964, + "elapsedMs": 317.89258399999926, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -851,15 +851,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 224.52995799999917, - "medianMs": 198.7046250000003, + "maximumMs": 176.59295799999927, + "medianMs": 176.34858300000087, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 220.52508300000002, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 197.873167, "result": { "actualSourceBytes": 65634, - "elapsedMs": 198.7046250000003, + "elapsedMs": 176.34858300000087, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -867,11 +867,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 253.093083, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 197.51208300000002, "result": { "actualSourceBytes": 65634, - "elapsedMs": 224.52995799999917, + "elapsedMs": 176.59295799999927, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -879,11 +879,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 211.7245, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 196.773583, "result": { "actualSourceBytes": 65634, - "elapsedMs": 189.0867500000004, + "elapsedMs": 175.917958, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -898,15 +898,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 346.4256659999992, - "medianMs": 343.44066700000076, + "maximumMs": 317.23545899999954, + "medianMs": 313.66829099999995, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 342.675208, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 315.459459, "result": { "actualSourceBytes": 65634, - "elapsedMs": 340.1129579999997, + "elapsedMs": 313.1439169999994, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -914,11 +914,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 348.89300000000003, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 316.037375, "result": { "actualSourceBytes": 65634, - "elapsedMs": 346.4256659999992, + "elapsedMs": 313.66829099999995, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -926,11 +926,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 346.138, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 319.59754200000003, "result": { "actualSourceBytes": 65634, - "elapsedMs": 343.44066700000076, + "elapsedMs": 317.23545899999954, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -945,15 +945,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 204.24629099999947, - "medianMs": 203.6168340000004, + "maximumMs": 197.6933750000007, + "medianMs": 197.56762499999968, "samples": [ { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 206.18525, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 199.547459, "result": { "actualSourceBytes": 65637, - "elapsedMs": 203.6168340000004, + "elapsedMs": 197.09187500000007, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -961,11 +961,11 @@ } }, { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 203.041125, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 200.30825, "result": { "actualSourceBytes": 65637, - "elapsedMs": 200.10629199999855, + "elapsedMs": 197.56762499999968, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -973,11 +973,11 @@ } }, { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 206.909375, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 200.11066699999998, "result": { "actualSourceBytes": 65637, - "elapsedMs": 204.24629099999947, + "elapsedMs": 197.6933750000007, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -989,37 +989,37 @@ } ], "component": { - "blake3": "f7864a6858df32e93357f04ed97bc6479f897db74c806e1661abdfbf7a63a493", - "buildMs": 30107.629041, - "bytes": 154665477, - "instantiateMs": 15407.022916 + "blake3": "dff386197ed6d8480d634ae031ebf7005e878d52dc6cfef06bb14e6ab796bc44", + "buildMs": 29196.833167, + "bytes": 174087724, + "instantiateMs": 14413.66825 }, "concurrencyAtLargestSize": { - "linearMemoryHighWaterBytes": 22544384, - "outerWallMs": 26.568624999999997, + "linearMemoryHighWaterBytes": 22609920, + "outerWallMs": 23.9365, "result": { - "baselineTimerMs": 2.631500000001324, - "elapsedMs": 21.58454199999869, - "incrementalSiblingDelayMs": 18.926666999997902, + "baselineTimerMs": 2.7172500000015134, + "elapsedMs": 19.24250000000029, + "incrementalSiblingDelayMs": 16.514624999997977, "outputBytes": 49, "requestedMs": 1, - "siblingIssuedMs": 21.55816699999923, - "transformMs": 18.74179200000071 + "siblingIssuedMs": 19.23187499999949, + "transformMs": 17.720541999999114 } }, "controlsAtLargestSize": { - "linearMemoryHighWaterBytes": 22544384, - "outerWallMs": 414.14504200000005, + "linearMemoryHighWaterBytes": 22609920, + "outerWallMs": 394.290708, "result": { "cancellation": { "cancelled": true, - "completedMs": 205.5602080000008, - "issuedMs": 195.56233299999985, + "completedMs": 197.88545800000065, + "issuedMs": 189.82574999999997, "message": "execution job cancelled", "requestedMs": 1 }, "timeout": { - "completedMs": 205.9060840000002, + "completedMs": 194.3070829999997, "message": "execution job timed out", "timedOut": true } @@ -1028,17 +1028,17 @@ "environment": { "arch": "aarch64", "artifactCache": null, - "cargo": "cargo 1.95.0 (f2d3ce0bd 2026-03-21)", - "commitHint": "058b904201154bd2f89e1d07dd56629cbbcfbe67", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "commitHint": "012a07cc553ec91ab308e071ab8622358f5cfec1", "dirty": false, "os": "macos", - "rustc": "rustc 1.95.0 (59807616e 2026-04-14)", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", "unoptimized": null, "wasmtimeCache": null }, "inputs": { - "benchmarkHash": "9c271ca9f5517af7f4b5cc7638d3398b2a844e94e85c9e6775382aa0b1bc0a8f", - "runtimeHash": "791eeb5d424bbd485542532b553a58c7ecd7fc63d50c25921724032f95f17ccb" + "benchmarkHash": "bccc8d574c50193654300d836469eb52a13a895f08860614ec07f523e2f3630c", + "runtimeHash": "242cc8726fad9a244984ee6a65ef40e05a648ffdb3d191fba426affff17a0e65" }, "iterations": 3, "mode": "transform", @@ -1055,5 +1055,5 @@ 65536 ], "target": "p2", - "wasmLinearMemoryHighWaterBytes": 22544384 + "wasmLinearMemoryHighWaterBytes": 22609920 } diff --git a/tests/typescript_transform_latency/results/2026-09-01-p3-strip-macos-aarch64.json b/tests/typescript_transform_latency/results/2026-09-21-p3-strip-macos-aarch64.json similarity index 65% rename from tests/typescript_transform_latency/results/2026-09-01-p3-strip-macos-aarch64.json rename to tests/typescript_transform_latency/results/2026-09-21-p3-strip-macos-aarch64.json index 672be6db..8d0e3ec3 100644 --- a/tests/typescript_transform_latency/results/2026-09-01-p3-strip-macos-aarch64.json +++ b/tests/typescript_transform_latency/results/2026-09-21-p3-strip-macos-aarch64.json @@ -5,15 +5,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 3.4715829999986454, - "medianMs": 1.3589590000010503, + "maximumMs": 2.858874999998079, + "medianMs": 1.363666999997804, "samples": [ { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 8.856375, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 6.832625, "result": { "actualSourceBytes": 4190, - "elapsedMs": 3.4715829999986454, + "elapsedMs": 2.858874999998079, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -21,11 +21,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 1.9580829999999998, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.804209, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.3589590000010503, + "elapsedMs": 1.363666999997804, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -33,11 +33,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 1.7829169999999999, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.690666, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.320292000000336, + "elapsedMs": 1.3262499999982538, "kind": "api", "outputBytes": 4190, "overflowed": false, @@ -52,15 +52,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 177.4370839999974, - "medianMs": 176.4188749999994, + "maximumMs": 186.213541000001, + "medianMs": 185.17562499999983, "samples": [ { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 177.989416, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 186.773709, "result": { "actualSourceBytes": 4158, - "elapsedMs": 177.4370839999974, + "elapsedMs": 186.213541000001, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -68,11 +68,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 177.073958, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 185.827875, "result": { "actualSourceBytes": 4158, - "elapsedMs": 176.4188749999994, + "elapsedMs": 185.17562499999983, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -80,11 +80,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 175.799458, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 185.498583, "result": { "actualSourceBytes": 4158, - "elapsedMs": 175.15533399999913, + "elapsedMs": 184.8742080000011, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -99,15 +99,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 231.9571250000008, - "medianMs": 230.77879100000064, + "maximumMs": 201.1929999999993, + "medianMs": 195.9875839999986, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 232.687708, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 196.028916, "result": { "actualSourceBytes": 4190, - "elapsedMs": 231.9571250000008, + "elapsedMs": 195.3485830000027, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -115,11 +115,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 231.412792, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 196.60091599999998, "result": { "actualSourceBytes": 4190, - "elapsedMs": 230.77879100000064, + "elapsedMs": 195.9875839999986, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -127,11 +127,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 231.452125, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 202.064875, "result": { "actualSourceBytes": 4190, - "elapsedMs": 230.74108299999716, + "elapsedMs": 201.1929999999993, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -146,15 +146,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 255.97087499999907, - "medianMs": 233.8927919999987, + "maximumMs": 197.1912500000035, + "medianMs": 196.89695899999788, "samples": [ { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 234.30954100000002, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 198.204458, "result": { "actualSourceBytes": 4190, - "elapsedMs": 233.4382079999996, + "elapsedMs": 197.1912500000035, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -162,11 +162,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 234.560792, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 197.61525, "result": { "actualSourceBytes": 4190, - "elapsedMs": 233.8927919999987, + "elapsedMs": 196.89695899999788, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -174,11 +174,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 256.68649999999997, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 196.92570800000001, "result": { "actualSourceBytes": 4190, - "elapsedMs": 255.97087499999907, + "elapsedMs": 196.16649999999936, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -193,15 +193,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 245.9720419999976, - "medianMs": 243.6025840000002, + "maximumMs": 186.82470900000044, + "medianMs": 186.5649999999987, "samples": [ { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 263.94266700000003, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 197.422166, "result": { "actualSourceBytes": 4190, - "elapsedMs": 245.9720419999976, + "elapsedMs": 186.82470900000044, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -209,11 +209,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 253.34637500000002, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 197.552875, "result": { "actualSourceBytes": 4190, - "elapsedMs": 240.82445899999948, + "elapsedMs": 186.5649999999987, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -221,11 +221,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 255.2665, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 196.12937499999998, "result": { "actualSourceBytes": 4190, - "elapsedMs": 243.6025840000002, + "elapsedMs": 185.66233400000056, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -240,15 +240,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 209.9944170000017, - "medianMs": 209.5323749999989, + "maximumMs": 200.5219589999997, + "medianMs": 196.3740829999988, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 210.787125, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 197.1715, "result": { "actualSourceBytes": 4190, - "elapsedMs": 209.5323749999989, + "elapsedMs": 196.3740829999988, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -256,11 +256,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 211.13750000000002, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 196.74712499999998, "result": { "actualSourceBytes": 4190, - "elapsedMs": 209.9944170000017, + "elapsedMs": 195.99879200000032, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -268,11 +268,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 205.245167, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 201.514958, "result": { "actualSourceBytes": 4190, - "elapsedMs": 204.31866699999773, + "elapsedMs": 200.5219589999997, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -287,15 +287,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 5.438958000000639, - "medianMs": 5.377207999999882, + "maximumMs": 5.212916999998924, + "medianMs": 5.17174999999952, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 7.213584, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 6.464292, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.438958000000639, + "elapsedMs": 5.17174999999952, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -303,11 +303,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 6.514542, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 6.270084000000001, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.218834000001152, + "elapsedMs": 5.212916999998924, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -315,11 +315,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 6.632542, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 6.345375000000001, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.377207999999882, + "elapsedMs": 5.128875000000335, "kind": "api", "outputBytes": 16464, "overflowed": false, @@ -334,15 +334,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 196.6645830000016, - "medianMs": 196.53862499999923, + "maximumMs": 183.96645799999897, + "medianMs": 180.6208749999987, "samples": [ { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 197.602667, + "linearMemoryHighWaterBytes": 20381696, + "outerWallMs": 185.076417, "result": { "actualSourceBytes": 16432, - "elapsedMs": 196.53862499999923, + "elapsedMs": 183.96645799999897, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -350,11 +350,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 197.806667, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 181.654708, "result": { "actualSourceBytes": 16432, - "elapsedMs": 196.6645830000016, + "elapsedMs": 180.6208749999987, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -362,11 +362,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 192.875666, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 180.852125, "result": { "actualSourceBytes": 16432, - "elapsedMs": 191.5420410000006, + "elapsedMs": 179.86099999999897, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -381,15 +381,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 916.054250000001, - "medianMs": 915.741, + "maximumMs": 213.65304200000173, + "medianMs": 213.5292499999996, "samples": [ { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 916.927333, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 214.213083, "result": { "actualSourceBytes": 16464, - "elapsedMs": 915.741, + "elapsedMs": 213.1588329999995, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -397,11 +397,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 917.2905000000001, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 214.44116599999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 916.054250000001, + "elapsedMs": 213.5292499999996, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -409,11 +409,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 908.597125, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 214.623292, "result": { "actualSourceBytes": 16464, - "elapsedMs": 907.4824589999988, + "elapsedMs": 213.65304200000173, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -428,15 +428,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 909.4808329999996, - "medianMs": 908.7662500000006, + "maximumMs": 215.6702499999992, + "medianMs": 214.360541, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 910.032875, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 214.45558400000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 908.7662500000006, + "elapsedMs": 213.49608300000185, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -444,11 +444,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 910.682291, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 216.70837500000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 909.4808329999996, + "elapsedMs": 215.6702499999992, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -456,11 +456,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 906.067541, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 215.506708, "result": { "actualSourceBytes": 16464, - "elapsedMs": 904.9943749999984, + "elapsedMs": 214.360541, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -475,15 +475,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 877.1025419999987, - "medianMs": 873.3861660000002, + "maximumMs": 180.1694580000003, + "medianMs": 180.11474999999882, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 905.736083, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 217.99420899999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 868.3579999999984, + "elapsedMs": 180.1694580000003, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -491,11 +491,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 911.434083, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 216.46320899999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 873.3861660000002, + "elapsedMs": 180.11474999999882, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -503,11 +503,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 915.203875, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 216.1195, "result": { "actualSourceBytes": 16464, - "elapsedMs": 877.1025419999987, + "elapsedMs": 180.05662499999926, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -522,15 +522,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 239.75629200000003, - "medianMs": 237.40016599999944, + "maximumMs": 219.82745799999975, + "medianMs": 216.8705000000009, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 238.712709, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 216.780833, "result": { "actualSourceBytes": 16464, - "elapsedMs": 237.40016599999944, + "elapsedMs": 215.71737500000015, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -538,11 +538,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 240.863458, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 220.79475000000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 239.75629200000003, + "elapsedMs": 219.82745799999975, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -550,11 +550,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 233.033958, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 217.842625, "result": { "actualSourceBytes": 16464, - "elapsedMs": 231.9375830000008, + "elapsedMs": 216.8705000000009, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -569,15 +569,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 20.77395799999977, - "medianMs": 19.615875000001324, + "maximumMs": 19.18933300000208, + "medianMs": 19.111957999999504, "samples": [ { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 21.614541000000003, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 21.431792, "result": { "actualSourceBytes": 65634, - "elapsedMs": 19.26679200000035, + "elapsedMs": 19.18933300000208, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -585,11 +585,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 23.082166, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 21.001792, "result": { "actualSourceBytes": 65634, - "elapsedMs": 20.77395799999977, + "elapsedMs": 18.864665999999488, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -597,11 +597,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 22.470875, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 21.210666, "result": { "actualSourceBytes": 65634, - "elapsedMs": 19.615875000001324, + "elapsedMs": 19.111957999999504, "kind": "api", "outputBytes": 65634, "overflowed": false, @@ -616,15 +616,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 212.32816599999933, - "medianMs": 207.63245800000004, + "maximumMs": 193.58237500000175, + "medianMs": 192.8331249999992, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 214.81074999999998, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 195.815792, "result": { "actualSourceBytes": 65602, - "elapsedMs": 212.32816599999933, + "elapsedMs": 193.58237500000175, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -632,11 +632,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 210.43212499999998, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 195.342542, "result": { "actualSourceBytes": 65602, - "elapsedMs": 207.63245800000004, + "elapsedMs": 192.8331249999992, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -644,11 +644,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 203.678791, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 195.226208, "result": { "actualSourceBytes": 65602, - "elapsedMs": 201.06620900000053, + "elapsedMs": 192.68662500000028, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -663,15 +663,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 11052.629749999996, - "medianMs": 11036.760375000003, + "maximumMs": 329.61004200000025, + "medianMs": 325.9599999999991, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11024.233208, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 328.297791, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11021.145042000002, + "elapsedMs": 325.9599999999991, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -679,11 +679,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11055.771917, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 327.084958, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11052.629749999996, + "elapsedMs": 324.82383299999856, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -691,11 +691,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11039.583416, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 331.909375, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11036.760375000003, + "elapsedMs": 329.61004200000025, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -710,15 +710,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 11351.273542000004, - "medianMs": 11169.502832999991, + "maximumMs": 328.9059589999997, + "medianMs": 325.08408299999974, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11042.731625, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 326.91225000000003, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11040.134917000005, + "elapsedMs": 324.44887500000186, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -726,11 +726,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11353.985166999999, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 331.535333, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11351.273542000004, + "elapsedMs": 328.9059589999997, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -738,11 +738,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11172.074375, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 327.50600000000003, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11169.502832999991, + "elapsedMs": 325.08408299999974, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -757,15 +757,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 11024.513082999998, - "medianMs": 10934.687334000002, + "maximumMs": 189.1610000000001, + "medianMs": 188.89304099999936, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11170.195749999999, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 328.701458, "result": { "actualSourceBytes": 65634, - "elapsedMs": 11024.513082999998, + "elapsedMs": 188.88533300000017, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -773,11 +773,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11058.882209, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 329.77991699999995, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10913.332916, + "elapsedMs": 189.1610000000001, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -785,11 +785,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 11083.307584, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 329.266292, "result": { "actualSourceBytes": 65634, - "elapsedMs": 10934.687334000002, + "elapsedMs": 188.89304099999936, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -804,15 +804,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 370.36125000000175, - "medianMs": 366.0301670000045, + "maximumMs": 331.2283329999991, + "medianMs": 330.9397919999992, "samples": [ { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 365.47533300000003, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 333.57966700000003, "result": { "actualSourceBytes": 65634, - "elapsedMs": 362.4177079999936, + "elapsedMs": 331.2283329999991, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -820,11 +820,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 373.14825, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 333.245625, "result": { "actualSourceBytes": 65634, - "elapsedMs": 370.36125000000175, + "elapsedMs": 330.9397919999992, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -832,11 +832,11 @@ } }, { - "linearMemoryHighWaterBytes": 22151168, - "outerWallMs": 368.5005, + "linearMemoryHighWaterBytes": 22282240, + "outerWallMs": 331.83750000000003, "result": { "actualSourceBytes": 65634, - "elapsedMs": 366.0301670000045, + "elapsedMs": 329.5143339999995, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -848,37 +848,37 @@ } ], "component": { - "blake3": "a18b24b2270bbde1ff5f16e2ba31b637ec476043f6b0d05ae6f8cebdb71edaf7", - "buildMs": 29196.525708, - "bytes": 152426759, - "instantiateMs": 14863.789999999999 + "blake3": "9e7ff11ea1f2c832fb57eeb06aeb9a0e1e18fa13f22b9f63035ab5f97e121740", + "buildMs": 29495.421625, + "bytes": 172175994, + "instantiateMs": 14294.210416 }, "concurrencyAtLargestSize": { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 29.148833999999997, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 26.96975, "result": { - "baselineTimerMs": 2.43241599999601, - "elapsedMs": 24.54570899999817, - "incrementalSiblingDelayMs": 22.0964590000076, + "baselineTimerMs": 2.691665999998804, + "elapsedMs": 22.169207999999344, + "incrementalSiblingDelayMs": 19.465167000000292, "outputBytes": 65634, "requestedMs": 1, - "siblingIssuedMs": 24.52887500000361, - "transformMs": 21.92041700000118 + "siblingIssuedMs": 22.156832999999097, + "transformMs": 19.48108299999876 } }, "controlsAtLargestSize": { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 411.56100000000004, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 390.371125, "result": { "cancellation": { "cancelled": true, - "completedMs": 203.83533299999544, - "issuedMs": 194.94354100000055, + "completedMs": 195.88845899999976, + "issuedMs": 187.035167, "message": "execution job cancelled", "requestedMs": 1 }, "timeout": { - "completedMs": 205.5270840000012, + "completedMs": 192.2898750000004, "message": "execution job timed out", "timedOut": true } @@ -887,17 +887,17 @@ "environment": { "arch": "aarch64", "artifactCache": null, - "cargo": "cargo 1.95.0 (f2d3ce0bd 2026-03-21)", - "commitHint": "058b904201154bd2f89e1d07dd56629cbbcfbe67", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "commitHint": "012a07cc553ec91ab308e071ab8622358f5cfec1", "dirty": false, "os": "macos", - "rustc": "rustc 1.95.0 (59807616e 2026-04-14)", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", "unoptimized": null, "wasmtimeCache": null }, "inputs": { - "benchmarkHash": "9c271ca9f5517af7f4b5cc7638d3398b2a844e94e85c9e6775382aa0b1bc0a8f", - "runtimeHash": "791eeb5d424bbd485542532b553a58c7ecd7fc63d50c25921724032f95f17ccb" + "benchmarkHash": "bccc8d574c50193654300d836469eb52a13a895f08860614ec07f523e2f3630c", + "runtimeHash": "242cc8726fad9a244984ee6a65ef40e05a648ffdb3d191fba426affff17a0e65" }, "iterations": 3, "mode": "strip", @@ -914,5 +914,5 @@ 65536 ], "target": "p3", - "wasmLinearMemoryHighWaterBytes": 22413312 + "wasmLinearMemoryHighWaterBytes": 22544384 } diff --git a/tests/typescript_transform_latency/results/2026-09-01-p3-transform-macos-aarch64.json b/tests/typescript_transform_latency/results/2026-09-21-p3-transform-macos-aarch64.json similarity index 66% rename from tests/typescript_transform_latency/results/2026-09-01-p3-transform-macos-aarch64.json rename to tests/typescript_transform_latency/results/2026-09-21-p3-transform-macos-aarch64.json index a7d61a5f..e7e46168 100644 --- a/tests/typescript_transform_latency/results/2026-09-01-p3-transform-macos-aarch64.json +++ b/tests/typescript_transform_latency/results/2026-09-21-p3-transform-macos-aarch64.json @@ -5,15 +5,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 4.92329200000313, - "medianMs": 1.7232499999990978, + "maximumMs": 3.355125000001862, + "medianMs": 1.3375000000014552, "samples": [ { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 9.066416, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 6.297750000000001, "result": { "actualSourceBytes": 4190, - "elapsedMs": 4.92329200000313, + "elapsedMs": 3.355125000001862, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -21,11 +21,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 2.255667, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.858792, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.5434999999997672, + "elapsedMs": 1.3375000000014552, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -33,11 +33,11 @@ } }, { - "linearMemoryHighWaterBytes": 12648448, - "outerWallMs": 2.445792, + "linearMemoryHighWaterBytes": 12713984, + "outerWallMs": 1.690167, "result": { "actualSourceBytes": 4190, - "elapsedMs": 1.7232499999990978, + "elapsedMs": 1.2469170000003942, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -52,15 +52,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 196.0192090000019, - "medianMs": 193.28579199999876, + "maximumMs": 182.63562500000265, + "medianMs": 179.19895799999722, "samples": [ { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 196.69229199999998, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 183.211125, "result": { "actualSourceBytes": 4158, - "elapsedMs": 196.0192090000019, + "elapsedMs": 182.63562500000265, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -68,11 +68,11 @@ } }, { - "linearMemoryHighWaterBytes": 19660800, - "outerWallMs": 192.868208, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 179.884, "result": { "actualSourceBytes": 4158, - "elapsedMs": 191.63033399999767, + "elapsedMs": 179.19895799999722, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -80,11 +80,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 194.077084, + "linearMemoryHighWaterBytes": 19791872, + "outerWallMs": 179.5455, "result": { "actualSourceBytes": 4158, - "elapsedMs": 193.28579199999876, + "elapsedMs": 178.88724999999977, "kind": "inline", "overflowed": false, "requestedSourceBytes": 4096, @@ -99,15 +99,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 203.46879199999967, - "medianMs": 203.02408400000056, + "maximumMs": 189.4549169999991, + "medianMs": 188.75408400000015, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 203.376542, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 190.262833, "result": { "actualSourceBytes": 4190, - "elapsedMs": 202.2744160000002, + "elapsedMs": 189.4549169999991, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -115,11 +115,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 203.80083299999998, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 189.571, "result": { "actualSourceBytes": 4190, - "elapsedMs": 203.02408400000056, + "elapsedMs": 188.75408400000015, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -127,11 +127,11 @@ } }, { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 204.26587500000002, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 188.431084, "result": { "actualSourceBytes": 4190, - "elapsedMs": 203.46879199999967, + "elapsedMs": 187.80637500000012, "kind": "entry", "overflowed": false, "requestedSourceBytes": 4096, @@ -146,15 +146,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 202.54300000000148, - "medianMs": 201.89691700000185, + "maximumMs": 190.9185409999991, + "medianMs": 188.3441669999993, "samples": [ { - "linearMemoryHighWaterBytes": 19726336, - "outerWallMs": 203.558708, + "linearMemoryHighWaterBytes": 19857408, + "outerWallMs": 191.574208, "result": { "actualSourceBytes": 4190, - "elapsedMs": 202.54300000000148, + "elapsedMs": 190.9185409999991, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -162,11 +162,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 202.74975, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 188.935708, "result": { "actualSourceBytes": 4190, - "elapsedMs": 201.89691700000185, + "elapsedMs": 188.3441669999993, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -174,11 +174,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 202.349625, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 188.245542, "result": { "actualSourceBytes": 4190, - "elapsedMs": 201.5948339999995, + "elapsedMs": 187.5882500000007, "kind": "esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -193,15 +193,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 190.83241700000144, - "medianMs": 190.47520799999984, + "maximumMs": 178.9862920000014, + "medianMs": 176.3634579999998, "samples": [ { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 194.08149999999998, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 178.830541, "result": { "actualSourceBytes": 4190, - "elapsedMs": 190.83241700000144, + "elapsedMs": 176.3634579999998, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -209,11 +209,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 193.3505, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 178.548667, "result": { "actualSourceBytes": 4190, - "elapsedMs": 190.47520799999984, + "elapsedMs": 175.95008299999972, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -221,11 +221,11 @@ } }, { - "linearMemoryHighWaterBytes": 19791872, - "outerWallMs": 193.434375, + "linearMemoryHighWaterBytes": 19922944, + "outerWallMs": 181.569875, "result": { "actualSourceBytes": 4190, - "elapsedMs": 190.3537499999984, + "elapsedMs": 178.9862920000014, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 4096, @@ -240,15 +240,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 202.91345800000272, - "medianMs": 202.61854200000016, + "maximumMs": 189.0903330000001, + "medianMs": 188.17375000000175, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 203.983834, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 188.393375, "result": { "actualSourceBytes": 4190, - "elapsedMs": 202.91345800000272, + "elapsedMs": 187.7307499999988, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -256,11 +256,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 201.590125, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 188.784875, "result": { "actualSourceBytes": 4190, - "elapsedMs": 200.40329199999903, + "elapsedMs": 188.17375000000175, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -268,11 +268,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 203.408708, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 189.896916, "result": { "actualSourceBytes": 4190, - "elapsedMs": 202.61854200000016, + "elapsedMs": 189.0903330000001, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 4096, @@ -287,15 +287,15 @@ "sourceBytes": 4096, "summary": { "iterations": 3, - "maximumMs": 201.20429199999853, - "medianMs": 199.2011249999996, + "maximumMs": 179.54566599999998, + "medianMs": 178.54929099999936, "samples": [ { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 196.18075, + "linearMemoryHighWaterBytes": 19988480, + "outerWallMs": 180.244417, "result": { "actualSourceBytes": 4193, - "elapsedMs": 195.18920900000012, + "elapsedMs": 179.54566599999998, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -303,11 +303,11 @@ } }, { - "linearMemoryHighWaterBytes": 19857408, - "outerWallMs": 200.205041, + "linearMemoryHighWaterBytes": 20054016, + "outerWallMs": 179.183875, "result": { "actualSourceBytes": 4193, - "elapsedMs": 199.2011249999996, + "elapsedMs": 178.54929099999936, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -315,11 +315,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 202.59925, + "linearMemoryHighWaterBytes": 20054016, + "outerWallMs": 179.155709, "result": { "actualSourceBytes": 4193, - "elapsedMs": 201.20429199999853, + "elapsedMs": 178.48466700000063, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 4096, @@ -334,15 +334,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 5.607958000000508, - "medianMs": 5.453207999998995, + "maximumMs": 4.771542000000409, + "medianMs": 4.554208000001381, "samples": [ { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 6.664459, + "linearMemoryHighWaterBytes": 20054016, + "outerWallMs": 5.686916999999999, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.453207999998995, + "elapsedMs": 4.771542000000409, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -350,11 +350,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 6.846459, + "linearMemoryHighWaterBytes": 20054016, + "outerWallMs": 5.334333, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.607958000000508, + "elapsedMs": 4.554208000001381, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -362,11 +362,11 @@ } }, { - "linearMemoryHighWaterBytes": 19922944, - "outerWallMs": 6.4479999999999995, + "linearMemoryHighWaterBytes": 20054016, + "outerWallMs": 5.2387500000000005, "result": { "actualSourceBytes": 16464, - "elapsedMs": 5.161916999997629, + "elapsedMs": 4.477875000000495, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -381,15 +381,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 202.21366599999965, - "medianMs": 200.90179200000057, + "maximumMs": 182.55354200000147, + "medianMs": 182.3759170000012, "samples": [ { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 202.11337500000002, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 182.897667, "result": { "actualSourceBytes": 16432, - "elapsedMs": 200.90179200000057, + "elapsedMs": 181.97287499999948, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -397,11 +397,11 @@ } }, { - "linearMemoryHighWaterBytes": 20316160, - "outerWallMs": 203.498375, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 183.528042, "result": { "actualSourceBytes": 16432, - "elapsedMs": 202.21366599999965, + "elapsedMs": 182.55354200000147, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -409,11 +409,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 198.9045, + "linearMemoryHighWaterBytes": 20447232, + "outerWallMs": 183.38483399999998, "result": { "actualSourceBytes": 16432, - "elapsedMs": 197.7479170000006, + "elapsedMs": 182.3759170000012, "kind": "inline", "overflowed": false, "requestedSourceBytes": 16384, @@ -428,15 +428,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 231.24175000000105, - "medianMs": 229.840833000002, + "maximumMs": 225.97362499999872, + "medianMs": 222.46249999999964, "samples": [ { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 232.443459, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 221.023583, "result": { "actualSourceBytes": 16464, - "elapsedMs": 231.24175000000105, + "elapsedMs": 219.8508750000001, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -444,11 +444,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 229.22525, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 223.896125, "result": { "actualSourceBytes": 16464, - "elapsedMs": 228.17908399999945, + "elapsedMs": 222.46249999999964, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -456,11 +456,11 @@ } }, { - "linearMemoryHighWaterBytes": 20381696, - "outerWallMs": 230.959208, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 227.090791, "result": { "actualSourceBytes": 16464, - "elapsedMs": 229.840833000002, + "elapsedMs": 225.97362499999872, "kind": "entry", "overflowed": false, "requestedSourceBytes": 16384, @@ -475,15 +475,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 238.63079199999993, - "medianMs": 232.05412500000057, + "maximumMs": 227.45087499999863, + "medianMs": 226.72879100000137, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 233.403083, + "linearMemoryHighWaterBytes": 20512768, + "outerWallMs": 226.253291, "result": { "actualSourceBytes": 16464, - "elapsedMs": 232.05412500000057, + "elapsedMs": 225.18745800000033, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -491,11 +491,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 233.108958, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 227.94174999999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 231.8668749999997, + "elapsedMs": 226.72879100000137, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -503,11 +503,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 239.961791, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 228.732125, "result": { "actualSourceBytes": 16464, - "elapsedMs": 238.63079199999993, + "elapsedMs": 227.45087499999863, "kind": "esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -522,15 +522,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 189.19083299999875, - "medianMs": 187.62770900000032, + "maximumMs": 192.91412499999933, + "medianMs": 187.20250000000124, "samples": [ { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 193.056208, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 193.42279200000002, "result": { "actualSourceBytes": 16464, - "elapsedMs": 185.9352910000016, + "elapsedMs": 186.8053749999999, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -538,11 +538,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 197.659667, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 200.49724999999998, "result": { "actualSourceBytes": 16464, - "elapsedMs": 189.19083299999875, + "elapsedMs": 192.91412499999933, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -550,11 +550,11 @@ } }, { - "linearMemoryHighWaterBytes": 20447232, - "outerWallMs": 194.73237500000002, + "linearMemoryHighWaterBytes": 20578304, + "outerWallMs": 194.251375, "result": { "actualSourceBytes": 16464, - "elapsedMs": 187.62770900000032, + "elapsedMs": 187.20250000000124, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 16384, @@ -569,15 +569,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 270.4706669999996, - "medianMs": 244.5450409999994, + "maximumMs": 225.5429999999997, + "medianMs": 224.1025410000002, "samples": [ { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 244.533625, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 226.653667, "result": { "actualSourceBytes": 16464, - "elapsedMs": 243.10345900000175, + "elapsedMs": 225.5429999999997, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -585,11 +585,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 246.090375, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 223.770375, "result": { "actualSourceBytes": 16464, - "elapsedMs": 244.5450409999994, + "elapsedMs": 222.41654200000085, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -597,11 +597,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 273.56629100000004, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 225.333125, "result": { "actualSourceBytes": 16464, - "elapsedMs": 270.4706669999996, + "elapsedMs": 224.1025410000002, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 16384, @@ -616,15 +616,15 @@ "sourceBytes": 16384, "summary": { "iterations": 3, - "maximumMs": 202.29983400000128, - "medianMs": 198.75395799999933, + "maximumMs": 193.62745799999905, + "medianMs": 193.10166599999863, "samples": [ { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 200.13879200000002, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 195.108084, "result": { "actualSourceBytes": 16467, - "elapsedMs": 198.75395799999933, + "elapsedMs": 193.62745799999905, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -632,11 +632,11 @@ } }, { - "linearMemoryHighWaterBytes": 20512768, - "outerWallMs": 203.715709, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 194.166625, "result": { "actualSourceBytes": 16467, - "elapsedMs": 202.29983400000128, + "elapsedMs": 193.10166599999863, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -644,11 +644,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 196.558208, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 189.596791, "result": { "actualSourceBytes": 16467, - "elapsedMs": 195.0536250000005, + "elapsedMs": 188.4573330000003, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 16384, @@ -663,15 +663,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 18.78083399999923, - "medianMs": 18.279375000000073, + "maximumMs": 17.850374999998166, + "medianMs": 17.650541000000885, "samples": [ { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 21.547916999999998, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 20.254708, "result": { "actualSourceBytes": 65634, - "elapsedMs": 18.78083399999923, + "elapsedMs": 17.850374999998166, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -679,11 +679,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 20.910999999999998, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 19.820625, "result": { "actualSourceBytes": 65634, - "elapsedMs": 18.279375000000073, + "elapsedMs": 17.650541000000885, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -691,11 +691,11 @@ } }, { - "linearMemoryHighWaterBytes": 20578304, - "outerWallMs": 20.532584, + "linearMemoryHighWaterBytes": 20643840, + "outerWallMs": 19.842624999999998, "result": { "actualSourceBytes": 65634, - "elapsedMs": 18.072040999999444, + "elapsedMs": 17.643874999999753, "kind": "api", "outputBytes": 49, "overflowed": false, @@ -710,15 +710,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 210.63966700000128, - "medianMs": 210.56608400000005, + "maximumMs": 196.84170900000024, + "medianMs": 196.12575000000103, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 212.900917, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 199.15333299999998, "result": { "actualSourceBytes": 65602, - "elapsedMs": 210.56608400000005, + "elapsedMs": 196.84170900000024, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -726,11 +726,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 213.15004100000002, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 198.46983300000002, "result": { "actualSourceBytes": 65602, - "elapsedMs": 210.63966700000128, + "elapsedMs": 196.0890410000011, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -738,11 +738,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 213.08829200000002, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 198.510917, "result": { "actualSourceBytes": 65602, - "elapsedMs": 210.5042089999988, + "elapsedMs": 196.12575000000103, "kind": "inline", "overflowed": false, "requestedSourceBytes": 65536, @@ -757,15 +757,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 385.0064160000002, - "medianMs": 356.6277919999993, + "maximumMs": 316.73041699999885, + "medianMs": 316.0995409999996, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 341.85725, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 319.102125, "result": { "actualSourceBytes": 65634, - "elapsedMs": 338.8820830000004, + "elapsedMs": 316.73041699999885, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -773,11 +773,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 388.886208, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 318.399625, "result": { "actualSourceBytes": 65634, - "elapsedMs": 385.0064160000002, + "elapsedMs": 316.07274999999936, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -785,11 +785,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 360.003833, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 318.42058299999997, "result": { "actualSourceBytes": 65634, - "elapsedMs": 356.6277919999993, + "elapsedMs": 316.0995409999996, "kind": "entry", "overflowed": false, "requestedSourceBytes": 65536, @@ -804,15 +804,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 342.3850419999999, - "medianMs": 341.15016599999944, + "maximumMs": 314.81354199999987, + "medianMs": 314.38533299999835, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 344.210167, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 316.762834, "result": { "actualSourceBytes": 65634, - "elapsedMs": 341.15016599999944, + "elapsedMs": 314.38533299999835, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -820,11 +820,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 338.565416, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 316.524917, "result": { "actualSourceBytes": 65634, - "elapsedMs": 335.91749999999956, + "elapsedMs": 314.1324999999997, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -832,11 +832,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 345.238417, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 317.138416, "result": { "actualSourceBytes": 65634, - "elapsedMs": 342.3850419999999, + "elapsedMs": 314.81354199999987, "kind": "esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -851,15 +851,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 198.4002079999991, - "medianMs": 191.90791700000045, + "maximumMs": 177.8785829999997, + "medianMs": 175.94166700000096, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 221.176459, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 194.53799999999998, "result": { "actualSourceBytes": 65634, - "elapsedMs": 198.4002079999991, + "elapsedMs": 174.09987499999988, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -867,11 +867,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 212.95837500000002, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 196.44400000000002, "result": { "actualSourceBytes": 65634, - "elapsedMs": 190.12862499999935, + "elapsedMs": 175.94166700000096, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -879,11 +879,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 214.98775, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 198.589125, "result": { "actualSourceBytes": 65634, - "elapsedMs": 191.90791700000045, + "elapsedMs": 177.8785829999997, "kind": "prepared-esm", "overflowed": false, "requestedSourceBytes": 65536, @@ -898,15 +898,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 362.0872500000005, - "medianMs": 355.45387499999924, + "maximumMs": 314.9001250000001, + "medianMs": 313.01941700000134, "samples": [ { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 364.90450000000004, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 315.589834, "result": { "actualSourceBytes": 65634, - "elapsedMs": 362.0872500000005, + "elapsedMs": 313.01941700000134, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -914,11 +914,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 357.782292, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 317.20225, "result": { "actualSourceBytes": 65634, - "elapsedMs": 354.8786249999994, + "elapsedMs": 314.9001250000001, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -926,11 +926,11 @@ } }, { - "linearMemoryHighWaterBytes": 22216704, - "outerWallMs": 358.012375, + "linearMemoryHighWaterBytes": 22347776, + "outerWallMs": 315.427042, "result": { "actualSourceBytes": 65634, - "elapsedMs": 355.45387499999924, + "elapsedMs": 313.0187500000011, "kind": "cjs", "overflowed": false, "requestedSourceBytes": 65536, @@ -945,15 +945,15 @@ "sourceBytes": 65536, "summary": { "iterations": 3, - "maximumMs": 215.04500000000007, - "medianMs": 212.55233399999997, + "maximumMs": 197.9337090000008, + "medianMs": 197.1626670000005, "samples": [ { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 217.54758299999997, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 199.638625, "result": { "actualSourceBytes": 65637, - "elapsedMs": 215.04500000000007, + "elapsedMs": 197.1626670000005, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -961,11 +961,11 @@ } }, { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 215.097875, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 199.125916, "result": { "actualSourceBytes": 65637, - "elapsedMs": 212.55233399999997, + "elapsedMs": 196.73670799999857, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -973,11 +973,11 @@ } }, { - "linearMemoryHighWaterBytes": 22413312, - "outerWallMs": 214.226167, + "linearMemoryHighWaterBytes": 22544384, + "outerWallMs": 200.287959, "result": { "actualSourceBytes": 65637, - "elapsedMs": 211.3668749999997, + "elapsedMs": 197.9337090000008, "kind": "transform-only", "overflowed": false, "requestedSourceBytes": 65536, @@ -989,37 +989,37 @@ } ], "component": { - "blake3": "08f8e8e6b6a771a133177dbbe29cca0e8cc85fd9c345b4c6228741df9a5cb450", - "buildMs": 30544.315458, - "bytes": 152440084, - "instantiateMs": 18173.024709 + "blake3": "fb925514a84741670490da6a63420b1eb6ad66967d0b8e18e86e560e670e39b7", + "buildMs": 29128.630333, + "bytes": 172146164, + "instantiateMs": 14446.916583 }, "concurrencyAtLargestSize": { - "linearMemoryHighWaterBytes": 22544384, - "outerWallMs": 27.138833, + "linearMemoryHighWaterBytes": 22609920, + "outerWallMs": 25.007708, "result": { - "baselineTimerMs": 2.9557500000009895, - "elapsedMs": 21.873999999999796, - "incrementalSiblingDelayMs": 18.900666999998062, + "baselineTimerMs": 2.647624999999607, + "elapsedMs": 20.379665999998902, + "incrementalSiblingDelayMs": 17.723165999999765, "outputBytes": 49, "requestedMs": 1, - "siblingIssuedMs": 21.856416999999055, - "transformMs": 19.132125000000087 + "siblingIssuedMs": 20.37079099999937, + "transformMs": 17.735000000000582 } }, "controlsAtLargestSize": { - "linearMemoryHighWaterBytes": 22544384, - "outerWallMs": 424.425, + "linearMemoryHighWaterBytes": 22609920, + "outerWallMs": 394.746583, "result": { "cancellation": { "cancelled": true, - "completedMs": 214.18362500000148, - "issuedMs": 204.99483300000065, + "completedMs": 198.23020799999904, + "issuedMs": 190.02629200000047, "message": "execution job cancelled", "requestedMs": 1 }, "timeout": { - "completedMs": 207.7208329999994, + "completedMs": 194.3871250000011, "message": "execution job timed out", "timedOut": true } @@ -1028,17 +1028,17 @@ "environment": { "arch": "aarch64", "artifactCache": null, - "cargo": "cargo 1.95.0 (f2d3ce0bd 2026-03-21)", - "commitHint": "058b904201154bd2f89e1d07dd56629cbbcfbe67", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "commitHint": "012a07cc553ec91ab308e071ab8622358f5cfec1", "dirty": false, "os": "macos", - "rustc": "rustc 1.95.0 (59807616e 2026-04-14)", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", "unoptimized": null, "wasmtimeCache": null }, "inputs": { - "benchmarkHash": "9c271ca9f5517af7f4b5cc7638d3398b2a844e94e85c9e6775382aa0b1bc0a8f", - "runtimeHash": "791eeb5d424bbd485542532b553a58c7ecd7fc63d50c25921724032f95f17ccb" + "benchmarkHash": "bccc8d574c50193654300d836469eb52a13a895f08860614ec07f523e2f3630c", + "runtimeHash": "242cc8726fad9a244984ee6a65ef40e05a648ffdb3d191fba426affff17a0e65" }, "iterations": 3, "mode": "transform", @@ -1055,5 +1055,5 @@ 65536 ], "target": "p3", - "wasmLinearMemoryHighWaterBytes": 22544384 + "wasmLinearMemoryHighWaterBytes": 22609920 } diff --git a/tests/typescript_transform_latency/results/README.md b/tests/typescript_transform_latency/results/README.md index fd195b04..115a219c 100644 --- a/tests/typescript_transform_latency/results/README.md +++ b/tests/typescript_transform_latency/results/README.md @@ -10,11 +10,9 @@ Each configured size is a requested source-byte target. Generated declarations a case-specific suffixes can make the actual source slightly larger; samples in the requested 64-KiB profile contain 65,602–65,637 source bytes. -The reports' `environment.commitHint` records the checkout used for the workload -capture (`058b9042`), while the input hashes are the currentness keys. The -`benchmarkHash` was refreshed after capture only because `run.sh` gained -validation-only source-root wiring; the recorded timings and component artifacts -still come from the `058b9042` capture. +The reports' `environment.commitHint` records the exact ESM whitespace-scan +candidate used for the workload capture (`012a07cc`), while the runtime and +benchmark input hashes are the currentness keys. `run.sh --check` validates the checked-in report schema and complete P2/P3 by strip/transform matrix without claiming that historical timings describe the @@ -22,29 +20,29 @@ current runtime. `run.sh --check-current` additionally compares the stored input hashes with the checkout. A failure there requires a deliberate new measurement capture, not validation-only replacement of the runtime hash. -## 2026-09-01 macOS arm64 baseline +## 2026-09-21 macOS arm64 candidate All values below are milliseconds for the requested 64-KiB profile unless noted otherwise. | Target/mode | Direct API median / max | Inline median | Entry median | ESM median | Prepared ESM median | CJS median | |---|---:|---:|---:|---:|---:|---:| -| P2 strip | 19.46 / 20.50 | 202.95 | 11,040.89 | 11,094.26 | 10,944.89 | 372.51 | -| P2 transform | 18.99 / 19.03 | 200.90 | 322.43 | 323.80 | 198.70 | 343.44 | -| P3 strip | 19.62 / 20.77 | 207.63 | 11,036.76 | 11,169.50 | 10,934.69 | 366.03 | -| P3 transform | 18.28 / 18.78 | 210.57 | 356.63 | 341.15 | 191.91 | 355.45 | - -The same-runtime 1 ms timer was delayed by 18.90–22.10 ms while the synchronous -public transform API ran. A 1 ms execution timeout completed in 205.53–208.59 ms; -the cancellation callback was issued in 194.94–204.99 ms and completed in -203.84–214.18 ms. Those execution-control values include fresh runtime startup and +| P2 strip | 18.88 / 18.95 | 193.52 | 325.43 | 329.13 | 190.68 | 331.21 | +| P2 transform | 17.63 / 17.65 | 196.22 | 315.67 | 315.02 | 176.35 | 313.67 | +| P3 strip | 19.11 / 19.19 | 192.83 | 325.96 | 325.08 | 188.89 | 330.94 | +| P3 transform | 17.65 / 17.85 | 196.13 | 316.10 | 314.39 | 175.94 | 313.02 | + +The same-runtime 1 ms timer was delayed by 16.51–19.47 ms while the synchronous +public transform API ran. A 1 ms execution timeout completed in 192.29–194.39 ms; +the cancellation callback was issued in 185.90–190.03 ms and completed in +193.95–198.23 ms. Those execution-control values include fresh runtime startup and must not be described as native-transform time or preemption. -The highest observed guest linear-memory reservation was 22,544,384 bytes. This is -an instance-wide monotone high-water mark, not retained memory. Strip-mode prepared -ESM reproduces nearly all of the end-to-end ESM delay after transformation has -already finished, while similarly sized inputs with the same dense stripped padding -complete inline in about 203 ms and through CommonJS in about 370 ms. The separate -bottleneck is therefore in the ESM module-loading path, not generic compilation of -whitespace-preserving output; GOL-347 owns its phase-level profiling and measured -mitigation. +The highest observed guest linear-memory reservation was 22,609,920 bytes. This is +an instance-wide monotone high-water mark, not retained memory. The preceding +baseline's requested 64-KiB strip-mode prepared-ESM medians were 11,088.28 ms for P2 +and 10,859.98 ms for P3. After the whitespace-scan change they are 190.68 ms and +188.89 ms, reductions of 98.28% and 98.26%. Entry and ordinary ESM paths now track +the approximately 313–331 ms CommonJS range instead of taking roughly 11 seconds. +The phase experiment retains the raw P2/P3 attribution samples and documents the +two source scanners responsible for the baseline delay.