Results

Sizes per entry point

Production output of each package, measured by its own yarn size. The budget column shows the value the script fails on, where one exists; rows without a budget are recorded for comparison (the esbuild figures keep helpers behind folded development gates and are not the quoted number). Method and environment: Methodology.

@svelte-lean/primitives

Method: ESM, target es2022, gzip level 9, brotli quality 11 (node:zlib). Tier 1 and Tier 2 entries are dist/<name>/register.js with @svelte-lean/core from the workspace. "vite" builds the public specifier with Vite in production mode; the brotli budget applies to it and it must list no diagnostics and keep the registration. "esbuild" bundles the same file with esbuild under the production condition; it keeps development helpers core references from folded DEV gates and is recorded for comparison. "core-only" is a registration with an empty handler. "native-only" imports the root entry and a Tier 0 subpath and must contain no runtime. Command: yarn workspace @svelte-lean/primitives size. Date: not recorded in the file; sizes are deterministic for the toolchain versions listed in docs/compatibility.md.

@svelte-lean/core

Method: ESM, target es2022, gzip level 9, brotli quality 11 (node:zlib). "production" and "default" are dist/index.js with every export, esbuild bundle + minify, under the production export condition and the runtime-detected env module respectively. "consumer" is one Tier 1 behavior using parts and emit, built with Vite in production mode; it must list no diagnostics. Command: yarn workspace @svelte-lean/core size. Date: not recorded in the file; sizes are deterministic for the toolchain versions listed in docs/compatibility.md.

@svelte-lean/table

Method: Each entry bundled independently with esbuild (bundle + minify, ESM); shared code is counted per entry here and de-duplicated by consumer bundlers. Svelte peer runtime excluded. gzip level 9 / brotli quality 11 (node:zlib). Budgets are gzip. Command: yarn workspace @svelte-lean/table size. Date: not recorded in the file; sizes are deterministic for the toolchain versions listed in docs/compatibility.md.

@svelte-lean/styles

Method: bytes = shipped source; minified = comments and redundant whitespace removed by scripts/check.mjs minify (a bundler minifier may be slightly smaller); gzip level 9 and brotli quality 11 of the minified text. standalone = the file with the files it @imports inlined. "index.css (resolved)" inlines every @import once, depth first, and carries the budget. Command: yarn workspace @svelte-lean/styles size. Date: not recorded in the file; sizes are deterministic for the toolchain versions listed in docs/compatibility.md.

What a consumer ships

Five small applications consume the packages the way an installed consumer would and are built in production mode. A plugin isolates every @svelte-lean/* module into one chunk and Svelte's runtime into another, so the Svelte Lean bytes of a page can be read without Svelte's in them. Assertions are the expect.json checks of each fixture (module graph, forbidden strings, manifest).

Method: Production `vite build` per fixture with Vite defaults (esbuild minify, modulepreload polyfill). Sizes are the emitted JavaScript and CSS files: raw bytes, gzip level 9, brotli quality 11 (node:zlib). "svelteLean" is the svelte-lean chunk that the fixture plugin isolates for every @svelte-lean/* module and "svelteRuntime" the svelte-runtime chunk for Svelte's runtime (both include chunk import/export bindings); 0 B means no such chunk was emitted. "modules.svelteLean" lists rendered @svelte-lean/* modules with their pre-minification rendered length. Environment: node v22.23.3,vite 7.3.6,svelte 5.57.1,@sveltejs/vite-plugin-svelte 6.2.4. Date: not recorded in the file. Command: yarn test:fixtures.

Listeners

The listener claim has no number in a file: it is an exact assertion in the browser suite, that the per-type listener counts for a thousand tabs roots equal those for one root, on two independent accounts. What this page can show is the same two accounts taken live. The specimen below is a real tabs root driven by the shared behavior; the panel under it reads the runtime's own account and the independent count of every addEventListener call on this page. Mount a hundred roots, then compare the readings.

Runtime

Read from the page after it loads; requires JavaScript.

The proof page mounts one, a hundred or a thousand roots on demand and records a reading for each count. The gate itself is listeners.spec.ts; command: yarn workspace @svelte-lean/playground test:e2e --project=chromium tests/primitives/listeners.spec.ts. Two related counts are recorded in files:

Timings

Startup and interaction entries, each the median of five fresh page loads with every sample recorded. Minimum and maximum are shown so the spread is visible: five samples on one machine give a median, not a distribution, and a run on another machine gives another number. Startup and interaction are never combined into one score.

Environment: chromium 153.0.8010.53, darwin 27.0.0 arm64, Apple M2, 8 cores, 16 GiB, Node v22.23.3, production build, headless. Date: 2026-09-27T20:46:17.407Z. Command: yarn bench:publish.

Memory after stress cycles

A thousand tabs roots mounted and unmounted five times, a menu opened and closed two hundred times, and one combobox root opened with ArrowDown and closed with Escape two hundred times (a Tier 2 session per cycle; the number of scoped document pointerdown listeners installed is recorded next to the JSEventListeners count): heap after forced garbage collection, DOM nodes and listeners, against a baseline taken after a warm-up cycle. The tolerance for growth is stated in each entry's method. This project runs in the nightly workflow, not on every pull request.

Environment: chromium 153.0.8010.53, darwin 27.0.0 arm64, Apple M2, 8 cores, 16 GiB, Node v22.23.3, production build, headless. Date: 2026-09-27T20:46:35.800Z. Command: yarn bench:publish.

Table with 1000 rows

The specimen the timings above are taken from, rendered on demand with every row in the document: no pagination and no virtualization, deliberately. The two readings under the table are taken in your browser when the specimen mounts and when you re-render it; they are readings, not published numbers, and change with the machine.

<script lang="ts">
	import { DataTable, type Column } from '@svelte-lean/table';
	import '@svelte-lean/table/style.css';
	import { rows, type Row } from './rows'; // one thousand generated rows

	const columns: Column<Row>[] = [
		{ id: 'name', header: 'Name' },
		{ id: 'email', header: 'Email' },
		{ id: 'team', header: 'Team' },
		{ id: 'region', header: 'Region' },
		{ id: 'status', header: 'Status' },
		{ id: 'revenue', header: 'Revenue', align: 'end' },
		{ id: 'joined', header: 'Joined' }
	];
</script>

<!-- Every row is in the document: no pagination, no virtualization. -->
<DataTable
	data={rows}
	{columns}
	getRowId={(row) => row.id}
	label="One thousand rows"
	pagination={false}
	stickyHeader
	height="24rem"
/>

Source

• Size scripts: primitives, core, table, styles.
• Fixtures: fixtures/ with the runner run.mjs and the assertion helper assert.mjs.
• Benchmarks: tabs.bench.spec.ts, table.bench.spec.ts; stress: tests/stress.
• Listener gate: listeners.spec.ts; the independent counter in packages/test-utils.
• Claim registry: docs/proof/claims.md; the audit of the checklist: docs/proof.