@dokebi/template-inertia 0.4.1 → 0.4.4

package/dist/vite-host.js

@@ -3,17 +3,49 @@
 // `{ type: 'dokebi-vite-host', state: 'ready', url, key }` over the IPC channel; dev passes them to
 // the app as DOKEBI_VITE_DEV_URL and DOKEBI_VITE_DEV_KEY. The host outlives app restarts.
 // A start failure is reported as `state: 'failed'` and the process exits 1.
-import { ConsoleLogger } from '@dokebi/core';
+// Its settings come from dokebi.yaml (`options.dokebi-template-inertia`, read once at start):
+// `devDepsRepairIntervalMs` (D-0128).
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { ConsoleLogger, loadConfig } from '@dokebi/core';
 import { diagnostics } from '@dokebi/core/libraries';
+import { options } from './options.js';
 import { startViteHost } from './vite-dev.js';
 const { describeError } = diagnostics;
 const LEVELS = new Set(['debug', 'info', 'warn', 'error', 'silent']);
 const asked = process.env.DOKEBI_LOG_LEVEL?.trim().toLowerCase() ?? '';
 const logger = new ConsoleLogger({ level: LEVELS.has(asked) ? asked : 'info' }, { plugin: 'dokebi-template-inertia', process: 'vite-host' });
-const send = (message) => process.send?.(message);
+/** Started by dokebi dev (an IPC channel); `process.send` stays defined after the channel closes. */
+const underDev = typeof process.send === 'function';
+/**
+ * A report to dokebi dev while its channel is open. Sent on a closed channel, Node emits an
+ * `error` event on process (ERR_IPC_CHANNEL_CLOSED) that nothing handles: the host crashed.
+ */
+const send = (message) => {
+    if (process.connected)
+        process.send?.(message);
+};
+/**
+ * The host's settings from the project's dokebi.yaml (the app's own file, DOKEBI_CONFIG; an empty
+ * value means dokebi.yaml, as for the CLI).
+ */
+async function settings() {
+    const file = resolve(process.env.DOKEBI_CONFIG || join(process.cwd(), 'dokebi.yaml'));
+    if (!existsSync(file)) {
+        logger.log('debug', 'Vite dev host uses default settings (no dokebi.yaml)', { file });
+        return {};
+    }
+    const document = await loadConfig(file);
+    const parsed = options.parse(document.options['dokebi-template-inertia'] ?? {});
+    logger.log('debug', 'Vite dev host settings read', {
+        file,
+        depsRepairIntervalMs: parsed.devDepsRepairIntervalMs,
+    });
+    return { depsRepairIntervalMs: parsed.devDepsRepairIntervalMs };
+}
 let host;
 try {
-    host = await startViteHost(logger, process.cwd());
+    host = await startViteHost(logger, process.cwd(), await settings());
 }
 catch (error) {
     logger.log('error', 'Vite dev host failed to start', {
@@ -35,16 +67,36 @@ if (host) {
             return;
         stopping = true;
         // Rejections become an error log and exit code 1 here (D-0047).
-        void started.close().then(() => logger.log('debug', 'Vite dev host stopped', { signal }), (error) => {
+        void started
+            .close()
+            .then(() => logger.log('debug', 'Vite dev host stopped', { signal }), (error) => {
             process.exitCode = 1;
             logger.log('error', 'Vite dev host failed to stop', {
                 code: 'INERTIA_VITE_HOST_FAILED',
                 signal,
                 error: describeError(error),
             });
+        })
+            // The IPC channel of dokebi dev keeps the process alive after the close: let it go, so the
+            // host exits now instead of at dokebi dev's SIGKILL 5 s later.
+            .finally(() => {
+            if (process.connected)
+                process.disconnect();
         });
     };
     process.on('SIGTERM', () => stop('SIGTERM'));
+    // dokebi dev went away without stopping the host (killed, crashed): its IPC channel closes.
+    // Nobody can reach or stop this host any more, and it would keep its port, its watcher and the
+    // dependency cache marker (a later `dokebi dev` then warns INERTIA_VITE_HOST_SHARED).
+    const orphaned = () => {
+        if (stopping)
+            return;
+        logger.log('warn', 'Vite dev host lost dokebi dev; stopping', {
+            code: 'INERTIA_VITE_HOST_ORPHANED',
+        });
+        stop('disconnect');
+    };
+    process.once('disconnect', orphaned);
     // Under dokebi dev (an IPC channel) a terminal Ctrl+C reaches the whole process group: the app
     // drains first and dev stops the host after it (SIGTERM). Alone, Ctrl+C stops the host.
     process.on('SIGINT', () => {
@@ -53,10 +105,15 @@ if (host) {
         else
             stop('SIGINT');
     });
-    logger.log('info', 'Vite dev host ready', {
-        code: 'INERTIA_VITE_HOST',
-        url: started.url,
-        hosts: started.hosts,
-    });
-    send({ type: 'dokebi-vite-host', state: 'ready', url: started.url, key: started.key });
+    // The channel closed while Vite was starting (before the listener above): that event is gone.
+    if (underDev && !process.connected)
+        orphaned();
+    else {
+        logger.log('info', 'Vite dev host ready', {
+            code: 'INERTIA_VITE_HOST',
+            url: started.url,
+            hosts: started.hosts,
+        });
+        send({ type: 'dokebi-vite-host', state: 'ready', url: started.url, key: started.key });
+    }
 }

package/dist/vite-plugin.d.ts

@@ -0,0 +1,69 @@
+import { type Logger } from '@dokebi/core';
+import { type DevFilesOptions, type DevFilesPatch, type DevMiddleware, type ResolvedFilesShape } from './vite-files.js';
+export { DEV_FILES_DENY, type DevFilesOptions, type DokebiDevFilesPlugin, dokebiDevFiles, } from './vite-files.js';
+/** Specifier → the URL the app serves it at (@dokebi/seal, `GET /dokebi/seal/*`). */
+export declare const SERVED_MODULES: Readonly<Record<string, string>>;
+/** Where the dev server answers the re-export of a served module (under `base`). */
+export declare const DEV_MODULE_PREFIX = "/@dokebi-served/";
+export interface DokebiInertiaViteOptions extends DevFilesOptions {
+    /**
+     * The logger of the plugin's debug records (D-0047). Default: a console logger at
+     * `DOKEBI_LOG_LEVEL` (`info` when unset), the level `dokebi dev` passes to its processes.
+     */
+    readonly logger?: Logger;
+}
+/** The part of Vite's resolved config this plugin reads. */
+type ResolvedConfigShape = ResolvedFilesShape;
+/** The part of Vite's dev server this plugin uses (connect middlewares). */
+interface DevServerShape {
+    readonly middlewares: {
+        use(handler: DevMiddleware): unknown;
+    };
+}
+/**
+ * The rolldown plugin of Vite's dependency optimizer (`optimizeDeps.rolldownOptions.plugins`,
+ * D-0119): served specifiers and dev ids are externals there, never files to read, crawl or bundle.
+ */
+export interface DokebiServedDepsPlugin {
+    readonly name: 'dokebi-inertia:served-deps';
+    readonly resolveId: {
+        readonly order: 'pre';
+        handler(source: string, importer: string | undefined): {
+            id: string;
+            external: true;
+        } | null;
+    };
+}
+/** What the `config` hook adds to the dev server's config (Vite merges it into the user's). */
+export interface DokebiInertiaConfigPatch {
+    readonly optimizeDeps: {
+        readonly rolldownOptions: {
+            readonly plugins: readonly DokebiServedDepsPlugin[];
+        };
+    };
+    /** The dev file policy (D-0129). */
+    readonly server?: DevFilesPatch['server'];
+}
+/** A Vite plugin (structural, so this package needs no Vite types). */
+export interface DokebiInertiaVitePlugin {
+    readonly name: 'dokebi-inertia';
+    readonly enforce: 'pre';
+    config(config: unknown, env: {
+        command: 'build' | 'serve';
+    }): DokebiInertiaConfigPatch | null;
+    configResolved(config: ResolvedConfigShape): void;
+    resolveId(source: string, importer: string | undefined, options?: {
+        ssr?: boolean;
+    }): {
+        id: string;
+        external: true | 'absolute';
+    } | null;
+    load(id: string): string | null;
+    configureServer(server: DevServerShape): void;
+}
+/**
+ * The plugin for `plugins: [vue(), dokebiInertia()]` of an Inertia app's vite.config.ts: imports
+ * of the modules in {@link SERVED_MODULES} load the file the app serves (one instance per page)
+ * in the client build and the dev server, and stay untouched in server rendering.
+ */
+export declare function dokebiInertia(options?: DokebiInertiaViteOptions): DokebiInertiaVitePlugin;

package/dist/vite-plugin.js

@@ -0,0 +1,173 @@
+// `@dokebi/template-inertia/vite`: the Vite plugin of an Inertia app's vite.config.ts (D-0062
+// addendum 2026-10-20). Some browser modules must exist once per page: the seal client keeps its
+// bridge (the opened seal, the clock offset) in module state, so the `sealInertia(http)` bootstrap
+// of views/app.js, `sealedFetch` in pages and `currentSealBridge()` must be one instance. The
+// app's server serves that instance (`/dokebi/seal/http.mjs`, from @dokebi/seal). This plugin
+// makes every `import … from '@dokebi/seal/http'` of the app's browser code load the served file
+// instead of bundling a second copy without a bridge:
+//
+// - `vite build` (client): the import stays an import of `/dokebi/seal/http.mjs` (an absolute
+//   external), so the bundle carries no copy and no import map is needed.
+// - dev server (`dokebi dev`): Vite prefixes absolute imports with `base`, so the import goes to
+//   `<base>@dokebi-served/seal/http.mjs` instead, which this plugin answers before Vite with
+//   `export * from "/dokebi/seal/http.mjs"`: the page still loads the served file, once.
+// - server rendering (SSR builds, `ssrLoadModule`): untouched. Node resolves the package as usual
+//   (a sealed page is never server rendered, D-0062 §5).
+// - Vite's dependency optimizer (dev, `optimizeDeps`, D-0119): its scan asks this plugin too,
+//   takes only the id of the answer and reads `/@dokebi-served/…` as a file, which fails the whole
+//   scan ("Failed to run dependency scan. Skipping dependency pre-bundling"). The `config` hook
+//   adds a rolldown plugin to `optimizeDeps.rolldownOptions.plugins` (Vite 8, the version the CLI
+//   installs) that answers the served specifiers and dev ids first, as externals: the scan
+//   neither reads nor crawls them and pre-bundles the app's real dependencies as usual, and a
+//   pre-bundled dependency that imports `@dokebi/seal/http` keeps the import, which Vite then
+//   points at the dev re-export like any other (no bundled copy).
+//
+// It does not import @dokebi/seal: the served paths are the seal plugin's public contract.
+//
+// D-0129: the plugin also carries the dev file policy of `vite-files.ts` (what the dev server may
+// serve: strict, a narrowed allow list, a deny list the app cannot shrink, a short 403 for
+// remote hosts), so an upgrade of this package secures every vite.config that uses it.
+import { ConsoleLogger } from '@dokebi/core';
+import { DevFilesPolicy, } from './vite-files.js';
+export { DEV_FILES_DENY, dokebiDevFiles, } from './vite-files.js';
+/** Specifier → the URL the app serves it at (@dokebi/seal, `GET /dokebi/seal/*`). */
+export const SERVED_MODULES = Object.freeze({
+    '@dokebi/seal/http': '/dokebi/seal/http.mjs',
+    '@dokebi/seal/forms': '/dokebi/seal/forms.mjs',
+});
+/** Where the dev server answers the re-export of a served module (under `base`). */
+export const DEV_MODULE_PREFIX = '/@dokebi-served/';
+const LEVELS = new Set(['debug', 'info', 'warn', 'error', 'silent']);
+function defaultLogger() {
+    const asked = process.env.DOKEBI_LOG_LEVEL?.trim().toLowerCase() ?? '';
+    return new ConsoleLogger({ level: LEVELS.has(asked) ? asked : 'info' }, { plugin: 'dokebi-template-inertia', process: 'vite' });
+}
+/** `/dokebi/seal/http.mjs` → `/@dokebi-served/seal/http.mjs` (the id of its dev re-export). */
+function devId(served) {
+    return `${DEV_MODULE_PREFIX}${served.replace(/^\/dokebi\//, '')}`;
+}
+/**
+ * The dependency optimizer's view of the served modules (D-0119): a served specifier
+ * (`@dokebi/seal/http`) or a dev id (`/@dokebi-served/seal/http.mjs`, with or without `base`)
+ * stays itself, as an external. Only the optimizer's scan and pre-bundling run it; the dev
+ * server's module graph and `vite build` never do.
+ */
+function servedDepsPlugin(logger, devIds) {
+    return {
+        name: 'dokebi-inertia:served-deps',
+        resolveId: {
+            order: 'pre',
+            handler(source, importer) {
+                if (SERVED_MODULES[source] === undefined &&
+                    !devIds.some((id) => source === id || source.endsWith(id)))
+                    return null;
+                if (logger.isEnabled('debug'))
+                    logger.log('debug', 'Inertia Vite plugin kept a served module out of dependency pre-bundling', {
+                        source,
+                        importer,
+                    });
+                return { id: source, external: true };
+            },
+        },
+    };
+}
+/**
+ * The plugin for `plugins: [vue(), dokebiInertia()]` of an Inertia app's vite.config.ts: imports
+ * of the modules in {@link SERVED_MODULES} load the file the app serves (one instance per page)
+ * in the client build and the dev server, and stay untouched in server rendering.
+ */
+export function dokebiInertia(options = {}) {
+    const logger = options.logger ?? defaultLogger();
+    const files = new DevFilesPolicy(logger, {
+        ...(options.allow ? { allow: options.allow } : {}),
+        ...(options.deny ? { deny: options.deny } : {}),
+    }, 'dokebi-inertia');
+    let command = 'serve';
+    let base = '/';
+    /** Dev re-export id → the served URL it re-exports. */
+    const dev = new Map(Object.values(SERVED_MODULES).map((served) => [devId(served), served]));
+    /** Request path (with and without `base`) → the module text the dev server answers. */
+    const answers = new Map();
+    return {
+        name: 'dokebi-inertia',
+        enforce: 'pre',
+        config(config, env) {
+            // The client build has no dependency optimizer; the dev server's scan and pre-bundling get
+            // the served modules as externals (Vite merges this array into the app's own plugins).
+            const policy = files.config(config, env.command);
+            if (env.command !== 'serve')
+                return null;
+            logger.log('debug', 'Inertia Vite plugin keeps served modules out of dependency pre-bundling', {
+                modules: Object.keys(SERVED_MODULES),
+            });
+            return {
+                optimizeDeps: { rolldownOptions: { plugins: [servedDepsPlugin(logger, [...dev.keys()])] } },
+                ...(policy ? { server: policy.server } : {}),
+            };
+        },
+        configResolved(config) {
+            files.configResolved(config);
+            command = config.command;
+            base = config.base || '/';
+            answers.clear();
+            for (const [id, served] of dev) {
+                const text = `export * from ${JSON.stringify(served)};\n`;
+                answers.set(id, text);
+                answers.set(`${base.replace(/\/$/, '')}${id}`, text);
+            }
+            logger.log('debug', 'Inertia Vite plugin keeps served modules out of the bundle', {
+                command,
+                base,
+                modules: SERVED_MODULES,
+            });
+        },
+        resolveId(source, importer, resolveOptions) {
+            const served = SERVED_MODULES[source];
+            if (served === undefined)
+                return null;
+            // Server rendering imports the package as Node resolves it (sealed pages are never SSR).
+            if (resolveOptions?.ssr)
+                return null;
+            const id = command === 'build' ? served : devId(served);
+            if (logger.isEnabled('debug'))
+                logger.log('debug', 'Inertia Vite plugin resolved a served module', {
+                    source,
+                    id,
+                    command,
+                    importer,
+                });
+            return command === 'build' ? { id, external: 'absolute' } : { id, external: true };
+        },
+        load(id) {
+            // Vite pre-transforms the imports it sees, the dev re-export too. The middleware below
+            // answers its URL before Vite does, so this text only fills Vite's module graph; were it
+            // ever served, the page would fail loudly instead of running without the served module.
+            const served = dev.get(id);
+            if (served === undefined)
+                return null;
+            return `throw new Error(${JSON.stringify(`${id} is answered by the dokebi-inertia middleware with export * from "${served}"; Vite served its placeholder instead`)});\n`;
+        },
+        configureServer(server) {
+            // D-0129: the file policy judges every request first, before the re-export and Vite.
+            const guard = files.middleware();
+            if (guard)
+                server.middlewares.use(guard);
+            // Added before Vite's own middlewares (the hook returns nothing): the re-export is served
+            // as written, without Vite's import rewriting (which would prefix the path with `base`).
+            server.middlewares.use((request, response, next) => {
+                const path = String(request.url ?? '').split('?', 1)[0] ?? '';
+                const text = answers.get(path);
+                if (text === undefined || (request.method !== 'GET' && request.method !== 'HEAD')) {
+                    next();
+                    return;
+                }
+                if (logger.isEnabled('debug'))
+                    logger.log('debug', 'Inertia Vite plugin answered a served module re-export', { path });
+                response.statusCode = 200;
+                response.setHeader('content-type', 'text/javascript; charset=utf-8');
+                response.setHeader('cache-control', 'no-cache');
+                response.end(request.method === 'HEAD' ? '' : text);
+            });
+        },
+    };
+}

package/dist/vite-watch.d.ts

@@ -0,0 +1,44 @@
+import type { Logger } from '@dokebi/core';
+/** The part of Vite's server the filter uses. */
+interface WatchedServer {
+    watcher: {
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+    };
+}
+/** The plugin as Vite takes it (this package does not depend on Vite's types). */
+export interface StaleEventPlugin {
+    name: string;
+    enforce: 'pre';
+    configureServer(server: WatchedServer): void;
+    load(this: {
+        environment?: {
+            name?: string;
+        };
+    } | undefined, id: string, options?: {
+        ssr?: boolean;
+    }): null;
+}
+/**
+ * The records and the decision. `record(file, environment)` keeps the first state an environment
+ * saw; `stale(file)` answers whether an event for the file is no change and, when it is a change,
+ * moves every record of the file to the new state.
+ */
+export declare class ServedFiles {
+    #private;
+    constructor(logger: Logger);
+    /** Events dropped so far. */
+    get dropped(): number;
+    /** Records the state of `file` for `environment` unless it has one (a missing file: none). */
+    record(file: string, environment: string): void;
+    /** Records the config files of `root` before Vite reads them. */
+    recordConfig(root: string): void;
+    /** Whether an event for `file` is no change (dropped); a change updates the records. */
+    stale(file: string, event: string): boolean;
+}
+/**
+ * The Vite plugin of the host: records module files on their first load (`enforce: 'pre'`, so the
+ * state is taken before Vite reads the file) and drops watcher events that are no change (the
+ * watcher's `emit`, so module invalidation, HMR, reloads and config restarts all skip them).
+ */
+export declare function staleEventFilter(files: ServedFiles, logger: Logger): StaleEventPlugin;
+export {};

package/dist/vite-watch.js

@@ -0,0 +1,176 @@
+// File events of the Vite host that are not changes (D-0045 addendum 4). On macOS, FSEvents also
+// delivers events for writes made before the watch started (`dokebi init`, `dokebi add`,
+// `npm install`, a checkout right before `dokebi dev`), tens of seconds or minutes late when
+// fseventsd is busy. Vite took each of them for an edit: it invalidated the module, logged
+// `(ssr) page reload views/ssr.js` or sent a reload (buffered until the first page connects, so a
+// page reloaded right after it opened), and restarted itself for a `vite.config.*` event.
+//
+// The filter records a file's state (device, inode, size, modification time) when Vite first loads
+// it in an environment (client, ssr), before Vite reads it, and the config files before Vite
+// starts. A `change`, `add` or `unlink` event of the watcher for a file whose every recorded state
+// equals its state now is dropped before Vite sees it: whatever Vite holds was read from the file
+// as it is. Any other event goes on and the records take the new state, so a real edit is handled
+// at once, as without the filter. Files Vite never loaded through the plugin pipeline (no record)
+// are never filtered.
+import { statSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { diagnostics } from '@dokebi/core/libraries';
+const { describeError } = diagnostics;
+/** Config files Vite looks for in the root (its DEFAULT_CONFIG_FILES). */
+const CONFIG_FILES = [
+    'vite.config.js',
+    'vite.config.mjs',
+    'vite.config.ts',
+    'vite.config.cjs',
+    'vite.config.mts',
+    'vite.config.cts',
+];
+/** The record that stands for "read before Vite started" (config files). */
+const STARTUP = 'startup';
+/** Watcher events that make Vite reload, update or restart. */
+const FILE_EVENTS = new Set(['change', 'add', 'unlink']);
+/** One path form for Vite's ids (`/`) and chokidar's paths (native). */
+const normal = (path) => resolve(path).replaceAll('\\', '/');
+/** The file of a module id, or undefined for virtual and dependency modules. */
+function fileOf(id) {
+    if (id.startsWith('\0'))
+        return undefined;
+    const path = id.replace(/[?#].*$/s, '');
+    if (!isAbsolute(path) || path.includes('/node_modules/'))
+        return undefined;
+    return normal(path);
+}
+/**
+ * The records and the decision. `record(file, environment)` keeps the first state an environment
+ * saw; `stale(file)` answers whether an event for the file is no change and, when it is a change,
+ * moves every record of the file to the new state.
+ */
+export class ServedFiles {
+    #records = new Map();
+    #logger;
+    #dropped = 0;
+    #statFailures = 0;
+    #warnedAt = Number.NEGATIVE_INFINITY;
+    constructor(logger) {
+        this.#logger = logger;
+    }
+    /** Events dropped so far. */
+    get dropped() {
+        return this.#dropped;
+    }
+    /** Records the state of `file` for `environment` unless it has one (a missing file: none). */
+    record(file, environment) {
+        const path = normal(file);
+        let records = this.#records.get(path);
+        if (records?.has(environment))
+            return;
+        const state = this.#read(path);
+        if (state === undefined || state === null)
+            return;
+        if (!records) {
+            records = new Map();
+            this.#records.set(path, records);
+        }
+        records.set(environment, state);
+    }
+    /** Records the config files of `root` before Vite reads them. */
+    recordConfig(root) {
+        for (const name of CONFIG_FILES)
+            this.record(join(root, name), STARTUP);
+    }
+    /** Whether an event for `file` is no change (dropped); a change updates the records. */
+    stale(file, event) {
+        const path = normal(file);
+        const records = this.#records.get(path);
+        if (!records)
+            return false;
+        const state = this.#read(path);
+        if (state !== undefined && state !== null && [...records.values()].every((r) => r === state)) {
+            this.#dropped++;
+            if (this.#dropped === 1 || this.#dropped % 100 === 0)
+                this.#logger.log('debug', 'Vite dev host ignored an event for a file that did not change', {
+                    file: path,
+                    event,
+                    dropped: this.#dropped,
+                });
+            return true;
+        }
+        if (state === undefined || state === null)
+            this.#records.delete(path);
+        else
+            for (const environment of records.keys())
+                records.set(environment, state);
+        if (this.#logger.isEnabled('debug'))
+            this.#logger.log('debug', 'Vite dev host passes a file change', {
+                file: path,
+                event,
+                state: state === undefined ? 'absent' : state === null ? 'unreadable' : 'present',
+            });
+        return false;
+    }
+    /** The state, undefined when absent, null when it cannot be read (logged; the event goes on). */
+    #read(path) {
+        try {
+            const stats = statSync(path);
+            return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            // Once per 10 seconds, with how many failed since the last warning (D-0047).
+            this.#statFailures++;
+            const now = Date.now();
+            if (now - this.#warnedAt >= 10_000) {
+                this.#logger.log('warn', 'Vite dev host could not read the state of a file', {
+                    code: 'INERTIA_VITE_WATCH_STAT_FAILED',
+                    file: path,
+                    repeated: this.#statFailures,
+                    error: describeError(error),
+                });
+                this.#warnedAt = now;
+                this.#statFailures = 0;
+            }
+            return null;
+        }
+    }
+}
+/**
+ * The Vite plugin of the host: records module files on their first load (`enforce: 'pre'`, so the
+ * state is taken before Vite reads the file) and drops watcher events that are no change (the
+ * watcher's `emit`, so module invalidation, HMR, reloads and config restarts all skip them).
+ */
+export function staleEventFilter(files, logger) {
+    return {
+        name: 'dokebi:stale-watch-events',
+        enforce: 'pre',
+        configureServer(server) {
+            const watcher = server.watcher;
+            const emit = watcher.emit;
+            // chokidar emits the event, then `all` with the same arguments: one decision for both.
+            let dropped;
+            watcher.emit = function (event, ...args) {
+                if (typeof event === 'string' && FILE_EVENTS.has(event) && typeof args[0] === 'string') {
+                    dropped = files.stale(args[0], event) ? args[0] : undefined;
+                    if (dropped !== undefined)
+                        return false;
+                }
+                else if (event === 'all' &&
+                    typeof args[1] === 'string' &&
+                    FILE_EVENTS.has(String(args[0]))) {
+                    const skip = dropped === args[1];
+                    dropped = undefined;
+                    if (skip)
+                        return false;
+                }
+                return emit.call(this, event, ...args);
+            };
+            logger.log('debug', 'Vite dev host filters watcher events of unchanged files');
+        },
+        load(id, options) {
+            const file = fileOf(id);
+            if (file)
+                files.record(file, this?.environment?.name ?? (options?.ssr ? 'ssr' : 'client'));
+            return null;
+        },
+    };
+}