@svelte-lean/vite 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @svelte-lean/vite
+
+## 0.1.0
+
+### Minor Changes
+
+- eb039db: Initial release: the `svelteLean()` plugin for Vite 6, 7 and 8 discovers static `data-slean="…"` markers in Svelte markup and injects only the registration modules that are used, with a behavior manifest and an optional build report.
+
+### Patch Changes
+
+- Updated dependencies [eb039db]
+  - @svelte-lean/primitives@0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ömer Say
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,229 @@
+# @svelte-lean/vite
+
+[Documentation](https://svelte-lean.vercel.app/docs/architecture/build-time-discovery) ·
+[Installation](https://svelte-lean.vercel.app/docs/installation) ·
+[Repository](https://github.com/say16/svelte-lean/tree/main/packages/vite) ·
+[Changelog](https://github.com/say16/svelte-lean/blob/main/packages/vite/CHANGELOG.md)
+
+Build-time behavior discovery for Svelte Lean. The plugin reads Svelte markup for static
+`data-slean="…"` markers and adds the matching registration modules to the compiled module, so an
+application ships the behavior runtime it uses and nothing else. Markup that only uses native
+behaviors (button, dialog, popover, …) gets no import and no runtime.
+
+## Install
+
+```sh
+yarn add -D @svelte-lean/vite
+yarn add @svelte-lean/primitives
+```
+
+Peer dependencies: `vite` 6, 7 or 8, and `@svelte-lean/primitives` (optional; the built-in
+registration modules come from it). No production dependencies. Node `^20.19.0 || >=22.12.0`, the
+range of Vite 7 and 8.
+
+The repository builds and tests with Vite 7 (`docs/compatibility.md`); the nightly workflow runs the
+same suite against `vite@latest`. Vite 8 was also checked by hand before the first release: a
+SvelteKit application on Vite 8.3 and `@sveltejs/vite-plugin-svelte` 7.3 with the packed
+tarballs, through `vite build`, `vite preview` and `vite dev`.
+
+## Usage with SvelteKit
+
+```ts
+// vite.config.ts
+import { sveltekit } from '@sveltejs/kit/vite';
+import { svelteLean } from '@svelte-lean/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+	plugins: [svelteLean(), sveltekit()]
+});
+```
+
+Plain Vite with `@sveltejs/vite-plugin-svelte` is the same: `plugins: [svelteLean(), svelte()]`.
+
+`svelteLean()` returns two plugins: `svelte-lean:scan` (`enforce: 'pre'`) reads the Svelte source
+before the compiler, and `svelte-lean:inject` (`enforce: 'post'`) adds the imports after it.
+`vite-plugin-svelte` compiles in a normal-phase plugin, so the pair works whether it is placed
+before or after `sveltekit()`; `tests/build.test.ts` builds the fixture app with both orders (plain
+Vite + `vite-plugin-svelte`). Put it first so the scanner sees the source before any preprocessor.
+The ordering against SvelteKit itself is verified by the `apps/playground` build, which uses
+`plugins: [svelteLean(), sveltekit()]`.
+
+## What is injected
+
+Given `src/routes/settings/+page.svelte` containing `<div data-slean="tabs">…</div>`, the compiled
+module receives, after the compiler output:
+
+```js
+import '@svelte-lean/primitives/tabs/register';
+```
+
+The exact format: one `import '<specifier>';` statement per registration module, single quotes,
+sorted by specifier, de-duplicated, each on its own line, appended after the compiled code and
+terminated by a newline. Appending keeps every existing line and column in place, so the transform
+returns `map: null` and the Svelte compiler's source map stays valid. ES module imports are hoisted,
+so the registration module evaluates before the component code exactly as a prepended import
+would.
+
+Bundlers de-duplicate modules: a hundred files that use tabs still produce one copy of the
+registration module in the graph. Registration in `@svelte-lean/core` is idempotent, so mixing
+injected imports with manual ones is safe.
+
+## Static-only contract
+
+Discovered:
+
+```svelte
+<div data-slean="tabs">
+<div data-slean='tabs'>
+<div data-slean=tabs>
+```
+
+Not discovered (dynamic):
+
+```svelte
+<div data-slean={kind}>
+<div data-slean="tabs-{suffix}">
+```
+
+Dynamic markers are recorded in the manifest and reported once per file:
+
+```
+Dynamic behavior identifiers cannot be auto-discovered.
+Found:
+  src/lib/Panel.svelte:12:2  data-slean={kind}
+Use a static identifier such as data-slean="tabs", or import the registration module
+manually (for example import '@svelte-lean/primitives/tabs/register').
+```
+
+## Manual escape hatch
+
+Automatic discovery is never mandatory. Without the plugin, with a dynamic identifier, or in a
+build that is not Vite, register a behavior yourself:
+
+```ts
+import '@svelte-lean/primitives/tabs/register';
+```
+
+This is the same module the plugin injects, so the runtime behavior is identical.
+
+## Options
+
+```ts
+svelteLean({
+	include: ['**/*.svelte'], // files to scan; globs (relative to the Vite root or absolute) or RegExp
+	exclude: ['**/node_modules/**'],
+	package: '@svelte-lean/primitives', // re-bases the built-in registration specifiers
+	behaviors: {}, // name → module specifier, or false for "no runtime"
+	manifest: true, // true | false | path; true = node_modules/.svelte-lean/manifest.json
+	report: false, // print a build report after the client bundle is written
+	warnDynamic: true, // warn about data-slean={…}
+	ssr: 'skip' // 'skip' | 'inject'
+});
+```
+
+| Option        | Default                     | Notes                                                                                                                                                                           |
+| ------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `include`     | `['**/*.svelte']`           | Globs support `**`, `*`, `?` and `{a,b}`. Style and `?raw`-style sub-requests are never touched.                                                                                |
+| `exclude`     | `['**/node_modules/**']`    | Tested after `include`.                                                                                                                                                         |
+| `package`     | `'@svelte-lean/primitives'` | Built-in specifiers that start with `@svelte-lean/primitives/` are rewritten to start with this value.                                                                          |
+| `behaviors`   | `{}`                        | Overrides and extends `BUILTIN_BEHAVIORS`. A string is injected as written (bare, relative to the component file, or absolute); `false` marks a behavior that needs no runtime. |
+| `manifest`    | `true`                      | Written at `buildEnd` of production builds. Not written in dev or after a failed build.                                                                                         |
+| `report`      | `false`                     | Printed at `closeBundle` for the client build only (SSR builds are silent).                                                                                                     |
+| `warnDynamic` | `true`                      | Warnings go through the plugin context (`this.warn`), so they carry file and position.                                                                                          |
+| `ssr`         | `'skip'`                    | Registration modules are SSR-safe (no `document` access at evaluation), so `'inject'` is only a server bundle size choice; the browser-only runtime does nothing on the server. |
+
+Built-in behaviors (`BUILTIN_BEHAVIORS`): every Tier 1 and Tier 2 primitive (`tabs`, `menu`,
+`listbox`, `combobox`, `select`, `date-picker`, …) maps to `@svelte-lean/primitives/<name>/register`;
+the Tier 0 primitives (`button`, `dialog`, `popover`, `disclosure`, `checkbox`, `switch`,
+`radio-group`, …) map to `false`. `radio` is also accepted as a native name: the ADR 0001 vocabulary
+for `<input type="radio">`, with no primitive contract of its own. The scanner records no marker for
+a bare `<select data-slean="select">`: that is the Tier 0 styled native select, and only the owned
+select (`<div data-slean="select">`, ADR 0007) needs the runtime.
+A test in the primitives package keeps this table equal to its `BEHAVIORS` map, so a new Tier 1
+primitive cannot be added there without a registration module here. A name outside this table
+and `behaviors` is unknown: it is reported once, listed in the manifest, and nothing is injected
+for it.
+
+## Manifest
+
+`node_modules/.svelte-lean/manifest.json` (or the configured path) after a production build:
+
+```json
+{
+	"version": 1,
+	"behaviors": {
+		"button": { "files": ["src/lib/Toolbar.svelte"], "module": null },
+		"tabs": {
+			"files": ["src/routes/settings/+page.svelte"],
+			"module": "@svelte-lean/primitives/tabs/register"
+		}
+	},
+	"dynamic": {
+		"src/lib/Panel.svelte": [{ "line": 12, "expression": "{kind}" }]
+	},
+	"unknown": []
+}
+```
+
+`files` are relative to the Vite root and sorted; `module` is `null` for native and unknown
+behaviors. The manifest is a build artifact for diagnostics and tooling; it is not shipped to the
+browser.
+
+## Build report
+
+With `report: true`:
+
+```
+svelte-lean build report
+  native-only  button, dialog
+  runtime      tabs -> @svelte-lean/primitives/tabs/register
+                 src/routes/settings/+page.svelte
+  unknown      none
+  dynamic      src/lib/Panel.svelte:12 data-slean={kind}
+  manifest     node_modules/.svelte-lean/manifest.json
+```
+
+The report only states what the scan observed. Bundle sizes and listener counts are measured by
+the consumer fixtures in `fixtures/*`, not estimated here.
+
+## Scanner scope
+
+The scanner is lexical and does not use the Svelte compiler. It skips `<script>` and `<style>`
+content, HTML comments, quoted attribute values (including `{…}` expressions inside them) and
+`{…}` expressions in text, so a marker inside a string literal is not a false positive. Inside an
+expression, string, template and regular-expression literals and comments are skipped, so quotes
+or braces in `s.replace(/"/g, '')` do not unbalance it. Markers inside `{#if}`, `{#each}` and
+other blocks are found like any other markup. If an expression never closes, the scanner stops
+there, records the position in `ScanResult.unterminated` and the plugin warns once per file with
+the line and column, because markup after that point is not discovered. It does not see markup
+produced at runtime (`{@html …}`) and, by default, does not scan files under `node_modules`; a
+library that renders Svelte Lean markup should either be added to `include` or import its
+registration modules itself.
+
+In development the scan runs on every transform and warnings are repeated after a file changes.
+The manifest and report are build-only.
+
+## Dev server and dependency pre-bundling
+
+The registration imports are added after Vite's dependency scan has read the source, so a
+pre-bundled `@svelte-lean/primitives` would be discovered on the first page that uses a behavior,
+re-optimized, and that page fully reloaded. The plugin therefore adds `options.package` and
+`@svelte-lean/core` to `optimizeDeps.exclude` (through its `config` hook). Both are plain ES
+modules without CommonJS or third-party dependencies, so the dev server serves them as they are:
+one copy of the core runtime, and hot updates of a registration module keep the shared listeners.
+A package you list in `optimizeDeps.include` yourself is left to your configuration.
+
+## Programmatic API
+
+```ts
+import {
+	svelteLean, // (options?) => Plugin[]
+	scan, // (source, id?) => { id, behaviors: Set<string>, dynamic: DynamicMarker[], unterminated }
+	BUILTIN_BEHAVIORS // name → registration module | false
+} from '@svelte-lean/vite';
+```
+
+Types: `SvelteLeanOptions`, `ScanResult`, `DynamicMarker`, `BehaviorManifest`, `ManifestBehavior`.
+The option resolver, the manifest builder, the report formatter and the import injector are
+internal; their behavior is observable through the plugin, the manifest file and the report.

package/dist/behaviors.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedOptions } from './types.js';
+export declare const DEFAULT_PACKAGE = "@svelte-lean/primitives";
+/**
+ * Behaviors known to the plugin without configuration. A string is the registration module that is
+ * injected when the behavior is used; `false` marks a native (Tier 0) behavior that ships no
+ * runtime, so its marker is recorded for the manifest and report only.
+ */
+export declare const BUILTIN_BEHAVIORS: Readonly<Record<string, string | false>>;
+export type BehaviorResolution = {
+    kind: 'runtime';
+    module: string;
+} | {
+    kind: 'native';
+} | {
+    kind: 'unknown';
+};
+/**
+ * Maps a behavior name to what the build should do with it. `options.behaviors` wins over the
+ * built-in table; built-in specifiers are re-based onto `options.package`.
+ */
+export declare function resolveBehavior(name: string, options: Pick<ResolvedOptions, 'behaviors' | 'package'>): BehaviorResolution;
+/** Sorted, de-duplicated registration modules for a set of behavior names. */
+export declare function modulesFor(names: Iterable<string>, options: Pick<ResolvedOptions, 'behaviors' | 'package'>): string[];

package/dist/behaviors.js

@@ -0,0 +1,106 @@
+export const DEFAULT_PACKAGE = '@svelte-lean/primitives';
+/**
+ * Behaviors known to the plugin without configuration. A string is the registration module that is
+ * injected when the behavior is used; `false` marks a native (Tier 0) behavior that ships no
+ * runtime, so its marker is recorded for the manifest and report only.
+ */
+export const BUILTIN_BEHAVIORS = Object.freeze({
+    button: false,
+    dialog: false,
+    popover: false,
+    disclosure: false,
+    checkbox: false,
+    switch: false,
+    // `radio-group` is the name `@svelte-lean/primitives` uses (its contract and `BEHAVIORS` key).
+    // `radio` is a native alias from the ADR 0001 vocabulary with no primitive contract. `select` is
+    // the owned select (Tier 2, ADR 0007); the scanner records no marker for a bare
+    // `<select data-slean="select">`, the Tier 0 styled native select. Both are documented in
+    // README.md and checked by the drift test in packages/primitives/tests/registry.test.ts, which
+    // keeps this table equal to `BEHAVIORS`.
+    'radio-group': false,
+    radio: false,
+    select: `${DEFAULT_PACKAGE}/select/register`,
+    tabs: `${DEFAULT_PACKAGE}/tabs/register`,
+    menu: `${DEFAULT_PACKAGE}/menu/register`,
+    listbox: `${DEFAULT_PACKAGE}/listbox/register`,
+    combobox: `${DEFAULT_PACKAGE}/combobox/register`,
+    'date-field': false,
+    calendar: `${DEFAULT_PACKAGE}/calendar/register`,
+    'date-picker': `${DEFAULT_PACKAGE}/date-picker/register`,
+    input: false,
+    field: false,
+    segmented: false,
+    rating: false,
+    slider: false,
+    'otp-field': false,
+    'file-field': false,
+    'color-field': false,
+    autocomplete: false,
+    'alert-dialog': false,
+    drawer: false,
+    accordion: false,
+    card: false,
+    separator: false,
+    avatar: false,
+    badge: false,
+    tag: false,
+    kbd: false,
+    carousel: false,
+    alert: false,
+    progress: false,
+    meter: false,
+    spinner: false,
+    skeleton: false,
+    breadcrumb: false,
+    pagination: false,
+    steps: false,
+    toggle: `${DEFAULT_PACKAGE}/toggle/register`,
+    'toggle-group': `${DEFAULT_PACKAGE}/toggle-group/register`,
+    toolbar: `${DEFAULT_PACKAGE}/toolbar/register`,
+    'range-slider': `${DEFAULT_PACKAGE}/range-slider/register`,
+    'number-field': `${DEFAULT_PACKAGE}/number-field/register`,
+    tree: `${DEFAULT_PACKAGE}/tree/register`,
+    tooltip: `${DEFAULT_PACKAGE}/tooltip/register`,
+    toast: `${DEFAULT_PACKAGE}/toast/register`,
+    'button-group': false,
+    'scroll-area': false,
+    descriptions: false,
+    timeline: false,
+    empty: false,
+    splitter: `${DEFAULT_PACKAGE}/splitter/register`,
+    'context-menu': `${DEFAULT_PACKAGE}/context-menu/register`,
+    'file-drop': `${DEFAULT_PACKAGE}/file-drop/register`,
+    'hover-card': `${DEFAULT_PACKAGE}/hover-card/register`,
+    menubar: `${DEFAULT_PACKAGE}/menubar/register`
+});
+/**
+ * Maps a behavior name to what the build should do with it. `options.behaviors` wins over the
+ * built-in table; built-in specifiers are re-based onto `options.package`.
+ */
+export function resolveBehavior(name, options) {
+    const custom = Object.hasOwn(options.behaviors, name) ? options.behaviors[name] : undefined;
+    if (custom === false)
+        return { kind: 'native' };
+    if (typeof custom === 'string')
+        return { kind: 'runtime', module: custom };
+    const builtin = Object.hasOwn(BUILTIN_BEHAVIORS, name) ? BUILTIN_BEHAVIORS[name] : undefined;
+    if (builtin === false)
+        return { kind: 'native' };
+    if (typeof builtin === 'string') {
+        const module = builtin.startsWith(DEFAULT_PACKAGE + '/')
+            ? options.package + builtin.slice(DEFAULT_PACKAGE.length)
+            : builtin;
+        return { kind: 'runtime', module };
+    }
+    return { kind: 'unknown' };
+}
+/** Sorted, de-duplicated registration modules for a set of behavior names. */
+export function modulesFor(names, options) {
+    const modules = new Set();
+    for (const name of names) {
+        const resolution = resolveBehavior(name, options);
+        if (resolution.kind === 'runtime')
+            modules.add(resolution.module);
+    }
+    return [...modules].sort();
+}

package/dist/filter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Module id filtering. Vite ids are absolute posix paths, optionally followed by a query
+ * (`?svelte&type=style&lang.css`) or hash. Only the component request itself is scanned and
+ * injected into; style/script sub-requests and `?raw`-style requests are left alone.
+ */
+export declare function normalizePath(path: string): string;
+/** Splits an id into its file path (posix) and query string (without `?`). */
+export declare function parseId(id: string): {
+    file: string;
+    query: string;
+};
+/** True for the request that carries the component source (not a style/raw/url sub-request). */
+export declare function isComponentRequest(query: string): boolean;
+/**
+ * Converts a small glob dialect to a RegExp: `**` (any path, `**\/` also matches zero segments),
+ * `*` (within one segment), `?` (one character) and `{a,b}` alternatives.
+ */
+export declare function globToRegExp(glob: string): RegExp;
+export type IdFilter = (id: string) => boolean;
+/** Path of `file` relative to `root`, in posix form, or `null` when it is outside the root. */
+export declare function relativeToRoot(root: string, file: string): string | null;
+/**
+ * Builds the include/exclude filter. Every pattern is tested against the absolute file path and,
+ * when the file lives under `root`, against the root-relative path, so `src/**\/*.svelte` and
+ * `**\/*.svelte` both behave as expected.
+ */
+export declare function createIdFilter(options: {
+    root: string;
+    include: Array<string | RegExp>;
+    exclude: Array<string | RegExp>;
+}): IdFilter;

package/dist/filter.js

@@ -0,0 +1,103 @@
+/**
+ * Module id filtering. Vite ids are absolute posix paths, optionally followed by a query
+ * (`?svelte&type=style&lang.css`) or hash. Only the component request itself is scanned and
+ * injected into; style/script sub-requests and `?raw`-style requests are left alone.
+ */
+const SKIPPED_QUERY_KEYS = ['type', 'raw', 'url', 'inline', 'direct', 'worker', 'sharedworker'];
+export function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+/** Splits an id into its file path (posix) and query string (without `?`). */
+export function parseId(id) {
+    const hash = id.indexOf('#');
+    const withoutHash = hash === -1 ? id : id.slice(0, hash);
+    const q = withoutHash.indexOf('?');
+    if (q === -1)
+        return { file: normalizePath(withoutHash), query: '' };
+    return { file: normalizePath(withoutHash.slice(0, q)), query: withoutHash.slice(q + 1) };
+}
+/** True for the request that carries the component source (not a style/raw/url sub-request). */
+export function isComponentRequest(query) {
+    if (query === '')
+        return true;
+    const params = new URLSearchParams(query);
+    return !SKIPPED_QUERY_KEYS.some((key) => params.has(key));
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Converts a small glob dialect to a RegExp: `**` (any path, `**\/` also matches zero segments),
+ * `*` (within one segment), `?` (one character) and `{a,b}` alternatives.
+ */
+export function globToRegExp(glob) {
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                if (glob[i + 2] === '/') {
+                    re += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    re += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if (c === '{') {
+            const close = glob.indexOf('}', i);
+            if (close === -1) {
+                re += '\\{';
+            }
+            else {
+                const alternatives = glob
+                    .slice(i + 1, close)
+                    .split(',')
+                    .map((part) => escapeRegExp(part.trim()));
+                re += '(?:' + alternatives.join('|') + ')';
+                i = close;
+            }
+        }
+        else {
+            re += escapeRegExp(c);
+        }
+    }
+    return new RegExp('^' + re + '$');
+}
+/** Path of `file` relative to `root`, in posix form, or `null` when it is outside the root. */
+export function relativeToRoot(root, file) {
+    const base = root.endsWith('/') ? root : root + '/';
+    return file.startsWith(base) ? file.slice(base.length) : null;
+}
+function toMatchers(patterns) {
+    return patterns.map((pattern) => (pattern instanceof RegExp ? pattern : globToRegExp(pattern)));
+}
+/**
+ * Builds the include/exclude filter. Every pattern is tested against the absolute file path and,
+ * when the file lives under `root`, against the root-relative path, so `src/**\/*.svelte` and
+ * `**\/*.svelte` both behave as expected.
+ */
+export function createIdFilter(options) {
+    const root = normalizePath(options.root);
+    const include = toMatchers(options.include);
+    const exclude = toMatchers(options.exclude);
+    const matches = (matchers, candidates) => matchers.some((matcher) => candidates.some((candidate) => matcher.test(candidate)));
+    return (id) => {
+        const { file, query } = parseId(id);
+        if (!isComponentRequest(query))
+            return false;
+        const relative = relativeToRoot(root, file);
+        const candidates = relative === null ? [file] : [file, relative];
+        if (!matches(include, candidates))
+            return false;
+        return !matches(exclude, candidates);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { svelteLean } from './plugin.js';
+export { scan } from './scanner.js';
+export { BUILTIN_BEHAVIORS } from './behaviors.js';
+export type { SvelteLeanOptions, ScanResult, DynamicMarker, BehaviorManifest, ManifestBehavior } from './types.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+// Public entry. `svelteLean()` is the product; `scan()` and `BUILTIN_BEHAVIORS` are exported for
+// tooling that wants the same discovery without the plugin. Everything else in src/ is internal.
+export { svelteLean } from './plugin.js';
+export { scan } from './scanner.js';
+export { BUILTIN_BEHAVIORS } from './behaviors.js';

package/dist/manifest.d.ts

@@ -0,0 +1,13 @@
+import type { BehaviorManifest, DynamicMarker, ResolvedOptions } from './types.js';
+export interface ManifestInput {
+    /** Vite root, posix. */
+    root: string;
+    /** Absolute posix file → static behavior names found in it. */
+    usage: ReadonlyMap<string, ReadonlySet<string>>;
+    /** Absolute posix file → dynamic markers found in it. */
+    dynamic: ReadonlyMap<string, readonly DynamicMarker[]>;
+    options: Pick<ResolvedOptions, 'behaviors' | 'package'>;
+}
+/** Builds the manifest from scan state. Pure and deterministic: every list is sorted. */
+export declare function createManifest(input: ManifestInput): BehaviorManifest;
+export declare function writeManifest(path: string, manifest: BehaviorManifest): Promise<void>;

package/dist/manifest.js

@@ -0,0 +1,43 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { resolveBehavior } from './behaviors.js';
+import { relativeToRoot } from './filter.js';
+function displayPath(root, file) {
+    return relativeToRoot(root, file) ?? file;
+}
+/** Builds the manifest from scan state. Pure and deterministic: every list is sorted. */
+export function createManifest(input) {
+    const filesByBehavior = new Map();
+    for (const [file, names] of input.usage) {
+        for (const name of names) {
+            let files = filesByBehavior.get(name);
+            if (!files)
+                filesByBehavior.set(name, (files = new Set()));
+            files.add(displayPath(input.root, file));
+        }
+    }
+    const behaviors = {};
+    const unknown = [];
+    for (const name of [...filesByBehavior.keys()].sort()) {
+        const resolution = resolveBehavior(name, input.options);
+        if (resolution.kind === 'unknown')
+            unknown.push(name);
+        behaviors[name] = {
+            files: [...filesByBehavior.get(name)].sort(),
+            module: resolution.kind === 'runtime' ? resolution.module : null
+        };
+    }
+    const dynamic = {};
+    const dynamicFiles = [...input.dynamic]
+        .filter(([, markers]) => markers.length > 0)
+        .map(([file, markers]) => [displayPath(input.root, file), markers])
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    for (const [file, markers] of dynamicFiles) {
+        dynamic[file] = markers.map(({ line, expression }) => ({ line, expression }));
+    }
+    return { version: 1, behaviors, dynamic, unknown };
+}
+export async function writeManifest(path, manifest) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(manifest, null, '\t') + '\n');
+}

package/dist/plugin.d.ts

@@ -0,0 +1,33 @@
+import type { Plugin } from 'vite';
+import type { ResolvedOptions, SvelteLeanOptions } from './types.js';
+export declare const SCAN_PLUGIN_NAME = "svelte-lean:scan";
+export declare const INJECT_PLUGIN_NAME = "svelte-lean:inject";
+export declare const DEFAULT_MANIFEST_PATH = "node_modules/.svelte-lean/manifest.json";
+export declare function resolveOptions(options?: SvelteLeanOptions): ResolvedOptions;
+/**
+ * Appends one side-effect import per registration module. Imports are hoisted by the module
+ * system, so evaluation order is identical to a prepended import, while appending keeps every
+ * existing line and column in place: `map: null` is then the correct source-map answer ("the
+ * transform did not move code"), and the compiler's map for the module stays valid.
+ */
+export declare function appendImports(code: string, modules: readonly string[]): string;
+/**
+ * Packages kept out of the dev server's dependency pre-bundling. The registration imports are
+ * added by the inject transform, after Vite's dependency scan has read the raw source, so a
+ * pre-bundled package would be discovered on the first page that uses a behavior, re-optimized,
+ * and the page fully reloaded. Excluded, the packages are served as the plain ES modules they are
+ * (no CommonJS, no dependencies outside the scope), core stays a single instance, and HMR of the
+ * registration modules behaves as it does for linked workspace packages. A package the user lists
+ * in `optimizeDeps.include` is left to the user.
+ */
+export declare function optimizeDepsExclude(options: Pick<ResolvedOptions, 'package'>, userConfig?: {
+    optimizeDeps?: {
+        include?: string[];
+    };
+}): string[];
+/**
+ * Creates the two plugins. `svelte-lean:scan` (`enforce: 'pre'`) reads Svelte source before the
+ * compiler and records which behaviors each file uses; `svelte-lean:inject` (`enforce: 'post'`)
+ * adds the registration imports to the compiled module. They share state through this closure.
+ */
+export declare function svelteLean(userOptions?: SvelteLeanOptions): Plugin[];