[jschaf]

trace_references recreated a fresh seen set for every CallExpression, so touch re-walked the same transitive assignment graph once per call. For N calls reaching an N-deep binding chain, this was $O(N^2)$.

Share one seen set per trace_references invocation. Use separate sets for the write-directed CallExpression touches and the read-directed ReturnStatement touches. The shared set ensures each assignment-value expression is walked at most once, making the traversal linear. touch only ever adds to a fixed target set, so skipping an already-seen expression never drops a binding: compiler output is byte-identical.

calculate_blockers performance

Apple M4 Max; Node 24.18.0; pnpm 10.4.0; Hyperfine 1.20.0. Each command used 3 warmups and 15 measured runs. Hyperfine timed batched compiler processes; the matching compiler-import/source-generation baseline was subtracted, then the mean was divided by the batch size.

Assignments / calls	Before (ms)	After (ms)	Speedup
50	1.73	1.17	1.5×
100	4.43	2.28	1.9×
200	11.42	4.38	2.6×
400	37.26	8.53	4.4×
800	183.95	20.72	8.9×

Benchmark code and Hyperfine commands

Save as $BASE/blocker-hyperfine.mjs:

Before: 602a873b6b82bba4e6edc91b039e2f6defbe3fc4
After: ca8cb55e23cd15d626a4ca01aa5ed073a689b519

import { readFile } from 'node:fs/promises';
import process from 'node:process';
import { pathToFileURL } from 'node:url';

const iterations_by_size = new Map([
	[50, 150],
	[100, 80],
	[200, 50],
	[400, 25],
	[800, 15]
]);

function component(size) {
	const assignments = Array.from(
		{ length: size },
		(_, i) => `let value_${i + 1} = value_${i};`
	).join('\n\t');
	const calls = Array.from({ length: size }, () => `sink(value_${size});`).join('\n\t\t');

	return `<script>
	let value_0 = await Promise.resolve(0);
	${assignments}

	function sink(value) {
		return value;
	}

	function run() {
		${calls}
		return value_${size};
	}
</script>

<p>{run()}</p>
`;
}

async function bench(mode, root, size_arg) {
	const size = Number(size_arg);
	const iterations = iterations_by_size.get(size);
	if (iterations === undefined) throw new Error(`Unsupported size: ${size_arg}`);

	const compiler_url = pathToFileURL(`${root}/packages/svelte/src/compiler/index.js`).href;
	const { compile } = await import(compiler_url);
	const source = component(size);

	if (mode === 'baseline') return;
	if (mode !== 'compile') throw new Error(`Unsupported mode: ${mode}`);

	for (let i = 0; i < iterations; i += 1) {
		compile(source, {
			filename: 'Blocker.svelte',
			generate: 'client',
			dev: false,
			experimental: { async: true }
		});
	}
}

async function table(results_dir) {
	console.log('| Assignments / calls | Before (ms) | After (ms) | Speedup |');
	console.log('| ---: | ---: | ---: | ---: |');

	for (const [size, iterations] of iterations_by_size) {
		const result = JSON.parse(await readFile(`${results_dir}/${size}.json`, 'utf8'));
		const means = new Map(result.results.map(({ command, mean }) => [command, mean]));
		const before = ((means.get('before') - means.get('before baseline')) * 1000) / iterations;
		const after = ((means.get('after') - means.get('after baseline')) * 1000) / iterations;

		console.log(
			`| ${size} | ${before.toFixed(2)} | ${after.toFixed(2)} | ${(before / after).toFixed(1)}× |`
		);
	}
}

const [mode, ...args] = process.argv.slice(2);

if ((mode === 'compile' || mode === 'baseline') && args.length === 2) {
	await bench(mode, args[0], args[1]);
} else if (mode === 'table' && args.length === 1) {
	await table(args[0]);
} else {
	throw new Error(
		'Usage: blocker-hyperfine.mjs <compile|baseline> <worktree> <size> | table <results-dir>'
	);
}

REPO=/opt/p/svelte
BASE=$(mktemp -d /tmp/svelte-blocker-hf.XXXXXX)
BEFORE="$BASE/before"
AFTER="$BASE/after"
SCRIPT="$BASE/blocker-hyperfine.mjs"
RESULTS="$BASE/results"

git -C "$REPO" worktree add --detach \
  "$BEFORE" \
  602a873b6b82bba4e6edc91b039e2f6defbe3fc4

git -C "$REPO" worktree add --detach \
  "$AFTER" \
  ca8cb55e23cd15d626a4ca01aa5ed073a689b519

# The compared commits do not change dependencies, so both isolated
# worktrees use the existing pnpm installation.
ln -s "$REPO/node_modules" "$BEFORE/node_modules"
ln -s "$REPO/node_modules" "$AFTER/node_modules"
ln -s "$REPO/packages/svelte/node_modules" "$BEFORE/packages/svelte/node_modules"
ln -s "$REPO/packages/svelte/node_modules" "$AFTER/packages/svelte/node_modules"

mkdir -p "$RESULTS"

mise exec node@24 -- sh -c \
  'node --version && pnpm --version && hyperfine --version'

for SIZE in 50 100 200 400 800; do
  mise exec node@24 -- hyperfine \
    --warmup 3 \
    --runs 15 \
    --style basic \
    --export-json "$RESULTS/$SIZE.json" \
    --command-name before \
      "node $SCRIPT compile $BEFORE $SIZE" \
    --command-name 'before baseline' \
      "node $SCRIPT baseline $BEFORE $SIZE" \
    --command-name after \
      "node $SCRIPT compile $AFTER $SIZE" \
    --command-name 'after baseline' \
      "node $SCRIPT baseline $AFTER $SIZE"
done

mise exec node@24 -- node "$SCRIPT" table "$RESULTS"

git -C "$REPO" worktree remove --force "$BEFORE"
git -C "$REPO" worktree remove --force "$AFTER"
rm -rf "$BASE"
git -C "$REPO" worktree prune

Complements #18548.

[pkg-svelte-dev]

Install the latest version of svelte from 79ef7d7:

pnpm add https://pkg.svelte.dev/svelte/c/79ef7d744bea869d4ef45cac5f2c0337e28f6a4e

Open in pkg.svelte.dev: https://pkg.svelte.dev/repos/svelte/pr/18549

Note

This PR is from a fork. A maintainer must approve approve each commit before it can be built and installed.

[changeset-bot]

🦋 Changeset detected

Latest commit: 79ef7d7

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 1 package

Name	Type
svelte	Patch

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

[dummdidumm]

Thank you - though I think we can omit the new tests.

[jschaf]

Thank you - though I think we can omit the new tests.

Sure thing, done.

[dummdidumm]

thank you!

there was another PR merged in the meantime which meant I had to add a new Set() but the cases where it's used are rare so should not affect perf.