@ogygia/core 0.12.3 → 0.13.0

package/dist/LateIsland.svelte

@@ -7,15 +7,16 @@
 	 * Where the app runs Svelte's async mode, the build imports LateIslandAwait.svelte in this one's
 	 * place, which holds the navigation until the code is in (vite/late-island.ts).
 	 */
+	import { OgygiaError } from './messages/island.js';
 	/** @type {{ load: () => Promise<import('svelte').Component>, props: Record<string, unknown>, children?: import('svelte').Snippet }} */
 	let { load, props, children } = $props();
 	/** @type {import('svelte').Component | undefined} */
 	let Component = $state(undefined);
-	// (a failed load renders nothing)
+	// (a failed load renders nothing, and is said)
 	// svelte-ignore state_referenced_locally
 	load().then(
 		(c) => (Component = c),
-		() => {}
+		(error) => console.error(new OgygiaError('island_load_failed', { entry: null }), error)
 	);
 </script>
 

package/dist/LateIslandAwait.svelte

@@ -6,12 +6,16 @@
 	 * (an island nested in it awaits in the same batch). Without async mode this file does not compile,
 	 * which is why it is never the default.
 	 */
+	import { OgygiaError } from './messages/island.js';
 	/** @type {{ load: () => Promise<import('svelte').Component>, props: Record<string, unknown>, children?: import('svelte').Snippet }} */
 	let { load, props, children } = $props();
-	// (a failed load renders nothing)
+	// (a failed load renders nothing, and is said)
 	// one load per island, read once on purpose (as in LateIsland.svelte)
 	// svelte-ignore state_referenced_locally
-	const Component = await load().catch(() => undefined);
+	const Component = await load().catch((error) => {
+		console.error(new OgygiaError('island_load_failed', { entry: null }), error);
+		return undefined;
+	});
 </script>
 
 {#if Component}<Component {...props}>{@render children?.()}</Component>{/if}

package/dist/Region.svelte

@@ -62,7 +62,8 @@
 	import { document_tail, island_graph_script, modulepreload_tag } from './server/document-tail.js';
 	import { plan_props_wire, props_sidecar } from './server/props-wire.js';
 	import { region_css_tag } from './server/region-css.js';
-	import { escape_amp, escape_amp_quot, escape_attr } from './escape.js';
+	import { escape_amp_quot, escape_attr } from './escape.js';
+	import { warn } from './messages/island.js';
 	import {
 		isNested,
 		setNested,
@@ -73,7 +74,8 @@
 		documentIsCsrTrue,
 		claimRuntimeEmit,
 		claim_region_css,
-		claim_kit_island
+		claim_kit_island,
+		note_early_hole
 	} from './context.js';
 	import {
 		prepare_region_props,
@@ -216,10 +218,7 @@
 	// the promise and its stylesheet resolve). The model is "loading UI lives on the region" — say so.
 	// svelte-ignore state_referenced_locally
 	if (of_is_promise && !placeholder && !children && import.meta.env && import.meta.env.DEV) {
-		console.warn(
-			'[ogygia] <Region of={promise}> has no `placeholder` — the region will sit empty until the ' +
-				'promise resolves and its stylesheet loads. Add {#snippet placeholder()}…{/snippet} for the wait.'
-		);
+		warn('region_promise_no_placeholder');
 	}
 	// A promise is PromiseRegion's (the template hands it over): how it waits — in the render where the
 	// app runs async mode, a late slot on a streamed document, after hydration otherwise — is decided
@@ -409,7 +408,7 @@
 					entry === '?' ? '' : entry
 				);
 			} catch {
-				/* isolated render without a live page — the recorder is unset there anyway */
+				// ok: an isolated render without a live page; the recorder is unset there anyway
 			}
 		});
 	}
@@ -419,11 +418,8 @@
 	// eliminated in builds via the `import.meta.env.DEV` guard.
 	if (nested && (is_island || is_server) && import.meta.env && import.meta.env.DEV) {
 		const entry = untrack(() => (is_server ? __entry : island_entry));
-		console.warn(
-			is_server
-				? `[ogygia] nested server island "${entry}" is inside another island; it renders inline as frozen HTML (no JS ships; islands inside it wake on their own) — 'deferred' ignored.`
-				: `[ogygia] nested island "${entry}" is inside another island; it hydrates with its parent (strategy ignored).`
-		);
+		if (is_server) warn('nested_server_island_inline', { entry: entry || '' });
+		else warn('nested_island_with_parent', { entry: entry || '' });
 	}
 	// Freeze bare snippet PROPS (named-snippet props) to static region snippets (server) so the island
 	// BODY and the serialized PAYLOAD render byte-for-byte identically — hydration then adopts the frozen
@@ -752,7 +748,7 @@
 				props: { children: ogygiaFallback },
 				context: region_contexts
 			});
-			return () => void unmount(app);
+			return () => void unmount(app); // ok: unmount's promise is its outros ending; it never rejects
 		}
 	);
 	// A hole NESTED in an island renders in the page pass (`deferred` ignored, the nested rule) — as a
@@ -816,16 +812,13 @@
 			? []
 			: graph_hrefs(__module, server_region_entry, null)
 	);
-	const server_fetch_preload = $derived.by(() => {
-		// Only `defer: 'load'`: start the endpoint fetch during HTML parse (warms the per-hole load).
-		if (nested || building || __defer !== 'load' || !server_endpoint) return '';
-		const href_attr = escape_amp(server_endpoint);
-		return (
-			LT + 'link rel="preload" as="fetch" crossorigin="anonymous" href="' + href_attr + '"' + GT
-		);
-	});
-	// The fetch preload STAYS in the head: it starts the hole's content request during the HTML parse
-	// (content, not island code). The island graph rides the tail.
+	// Only `defer: 'load'`: its request starts during the HTML parse, from the head's early start
+	// (early-holes.ts), which the handle or `document()` writes once for every such hole. The island
+	// graph rides the tail.
+	if (typeof window === 'undefined' && is_server && !nested && !building)
+		untrack(() => {
+			if (__defer === 'load' && server_endpoint) note_early_hole(server_endpoint);
+		});
 	const server_graph_tail =
 		!!tail &&
 		untrack(() => {
@@ -833,10 +826,9 @@
 			return true;
 		});
 	const server_preload = $derived(
-		server_fetch_preload +
-			(server_graph_tail || !server_graph_hrefs.length
-				? ''
-				: island_graph_script(new Map([[server_region_entry, server_graph_hrefs]])))
+		server_graph_tail || !server_graph_hrefs.length
+			? ''
+			: island_graph_script(new Map([[server_region_entry, server_graph_hrefs]]))
 	);
 
 	// ───────────────────────────────────────────────────────────── lake branch ──
@@ -877,9 +869,7 @@
 			// client-renders from scratch has nothing. (Inside an island an empty element is the lifted
 			// lake, which the runtime fills right after.)
 			if (is_csr && !el.firstChild && import.meta.env && import.meta.env.DEV)
-				console.warn(
-					`[ogygia] lake "${__entry}" was mounted by Kit on the client with no server HTML to adopt (a client-side navigation, or a hydration failure — look for an error above). The runtime restores it from its server HTML when this document rendered it; otherwise it stays empty. A lake is server HTML: keep chrome lakes in a layout that persists across navigations, or serve that route csr=false.`
-				);
+				warn('lake_mounted_without_html', { entry: __entry || '' });
 		}
 	);
 
@@ -1083,7 +1073,7 @@
 					});
 				}
 			} catch {
-				/* devtools emit must never break a render */
+				// ok: a devtools emit never breaks a render; the event is left out of the timeline
 			}
 		});
 	}
@@ -1119,8 +1109,7 @@
 			margin={root_margin || undefined}
 			data-ogygia-keep={__keep || undefined}
 			data-og-fp={island_fp || undefined}
-			src={island_src || undefined}
-			>{#if Component}<Component {...island_props_body} />{/if}</ogygia-region
+			src={island_src || undefined}><Component {...island_props_body} /></ogygia-region
 		><!-- svelte-ignore hydration_html_changed -->{@html island_props_inline}{/if}
 {:else if is_server}
 	{@const Component = __component}

package/dist/boundary.d.ts

@@ -23,8 +23,6 @@ export declare function configure_boundary(p: BoundaryPolicy): void;
 export declare function classify_boundary(value: unknown, key?: string): BoundaryFinding[];
 /** The findings that make a value undroppable-into-HTML (used to explain a dropped context key). */
 export declare function boundary_problems(value: unknown, key?: string): BoundaryFinding[];
-/** Format one finding as the console line for a dropped/degraded context key. */
-export declare function format_boundary_finding(key: string, f: BoundaryFinding): string;
 /**
  * The `import.meta.og.$` rewrite target for NON-function values — the universal boundary
  * assertion. Classifies the value AT THE MARK (creation), so a refusal (DOM node, bare

package/dist/boundary.js

@@ -1,5 +1,6 @@
 import { is_derived_like, is_store } from "./store-transport.js";
 import { wire } from "./live-transport.js";
+import { OgygiaError } from "./messages/island.js";
 // src/boundary.ts
 /**
 * Boundary classifier — guard layer of the transportable seam.
@@ -105,10 +106,6 @@ function classify_boundary(value, key = "") {
 function boundary_problems(value, key = "") {
 	return classify_boundary(value, key).filter((f) => f.kind === "refuse" || f.kind === "warn");
 }
-/** Format one finding as the console line for a dropped/degraded context key. */
-function format_boundary_finding(key, f) {
-	return `[ogygia] context '${key}'${f.path ? ` @ ${f.path}` : ""}: ${f.detail}`;
-}
 /**
 * The `import.meta.og.$` rewrite target for NON-function values — the universal boundary
 * assertion. Classifies the value AT THE MARK (creation), so a refusal (DOM node, bare
@@ -120,8 +117,13 @@ function __og_boundary(value, site) {
 	const refusals = classify_boundary(value).filter((f) => f.kind === "refuse");
 	if (refusals.length) {
 		const f = refusals[0];
-		throw new Error(`[ogygia] ${site} — og.$ value${f.path ? ` @ ${f.path}` : ""}: ${f.detail}` + (refusals.length > 1 ? ` (+${refusals.length - 1} more)` : ""));
+		throw new OgygiaError("boundary_refused", {
+			site,
+			path: f.path || void 0,
+			detail: f.detail,
+			more: refusals.length - 1
+		});
 	}
 	return value;
 }
-export { __og_boundary, boundary_problems, classify_boundary, configure_boundary, format_boundary_finding };
+export { __og_boundary, boundary_problems, classify_boundary, configure_boundary };

package/dist/compiler/debarrel/barrel.d.ts

@@ -1,9 +1,11 @@
 import { ModuleShape } from "./parse.js";
-export interface Host {
+/** `Caller`: who asked for the map (`map(id, spec, caller)`), handed to every resolve of its walk —
+ *  the Vite plugin's transform context, whose own `resolve` knows its environment's conditions. */
+export interface Host<Caller = void> {
   /** The module's source, or null when it cannot be read (virtual, binary, missing). */
   read(id: string): string | null;
-  /** Resolve `spec` from `importer` to a file id; null when Vite cannot. */
-  resolve(spec: string, importer: string): Promise<string | null>;
+  /** Resolve `spec` from `importer` to a file id, as `caller` resolves it; null when Vite cannot. */
+  resolve(spec: string, importer: string, caller: Caller): Promise<string | null>;
   /** May this resolved module be treated as a barrel at all? (matchers + node_modules policy) */
   candidate(id: string, spec: string): boolean;
   /** Is this module forced even though impure? */
@@ -39,17 +41,22 @@ export interface ExportMap {
    *  cached only once the walk that owns them has closed the ring (the set is empty there) */
   cycles: Set<string>;
 }
-export declare class BarrelIndex {
+/** One index caches the maps its callers' walks built, so every caller of one index must resolve
+ *  alike: the Vite plugin keeps one index per environment (a leaf may resolve to another file for
+ *  the client than for the server). */
+export declare class BarrelIndex<Caller = void> {
   #private;
-  constructor(host: Host);
-  /** Drop every cached map/shape that depends on `id` (the file changed). */
+  constructor(host: Host<Caller>);
+  /** Drop every cached map/shape that depends on `id` (the file changed), and every build in flight
+   *  that has met it so far (one it meets later reads the file as it is now). */
   invalidate(id: string): void;
   /** The parsed shape of a module (cached), or null when it cannot be read/parsed. */
   shape(id: string): ModuleShape | null;
   /**
    * The export map of a barrel, or null when the module is not a barrel the plugin may rewrite
    * (not a candidate, impure and not forced, kept, unreadable). `spec` is the specifier the
-   * importer wrote — matchers see both. Concurrent callers share one build.
+   * importer wrote — matchers see both. Concurrent callers share one build; a build resolves as
+   * the `caller` that started it.
    */
-  map(id: string, spec: string): Promise<ExportMap | null>;
+  map(id: string, spec: string, caller: Caller): Promise<ExportMap | null>;
 }

package/dist/compiler/debarrel/barrel.js

@@ -1,4 +1,5 @@
 import { analyze_exports } from "./parse.js";
+import { STALE, flights } from "@ogygia/machine";
 // src/compiler/debarrel/barrel.ts
 /**
 * The barrel index: for a resolved module id, the map `exported name → leaf` — the module and
@@ -11,8 +12,10 @@ import { analyze_exports } from "./parse.js";
 * with `this.resolve`.
 *
 * CONCURRENCY: a bundler transforms hundreds of importers at once, and most of them ask for the same
-* few barrels. One build per barrel is kept in flight (`#pending`) and every concurrent caller awaits
-* it. A cycle is detected against the WALK STACK of the build that is running (a → b → a), never
+* few barrels. The barrels are one flights keyed by id: one build per barrel is in flight and every
+* concurrent caller awaits it. An edit (`invalidate`) drops a barrel whose build or map depends on
+* the changed file: a build in flight then ends STALE, stores nothing, and its callers build again
+* from the files as they are now (dev: a barrel saved while a transform resolves through it). A cycle is detected against the WALK STACK of the build that is running (a → b → a), never
 * against another build's in-flight state; when a walk meets a barrel some other walk is still
 * building, it does not wait (two walks waiting on each other would never finish) — it leaves that
 * name unresolved and marks its own map PROVISIONAL, so the map is served once but not cached, and
@@ -21,19 +24,37 @@ import { analyze_exports } from "./parse.js";
 const STRIP_QUERY_RE = /[?#].*$/;
 const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
 const PARSABLE_RE = /\.(?:[cm]?[jt]sx?|svelte\.[jt]s)$/;
+/** One index caches the maps its callers' walks built, so every caller of one index must resolve
+*  alike: the Vite plugin keeps one index per environment (a leaf may resolve to another file for
+*  the client than for the server). */
 var BarrelIndex = class {
 	#host;
-	#maps = /* @__PURE__ */ new Map();
+	/** One build per barrel: its map is kept until an edit to the barrel or to one of its deps
+	*  (null: not a barrel we rewrite); a provisional map, or one that lacks a ring's names, is
+	*  served to the callers of its build, not kept. */
+	#barrels = flights.keyed()({
+		name: "debarrel-barrel",
+		key: ["id"],
+		ignore: { build: "what the ask that starts the flight found of the file: a barrel is built once, as that caller resolves" },
+		run: async ({ id, build }) => build === null ? null : this.#build_of(id, build.shape, build.walk),
+		keep: (map) => map !== null && (map.provisional || map.cycles.size > 0) ? 0 : Infinity
+	});
+	/** The map each build in flight has met so far (its deps among it), for `invalidate`. */
+	#building = /* @__PURE__ */ new Map();
 	#shapes = /* @__PURE__ */ new Map();
-	#pending = /* @__PURE__ */ new Map();
 	constructor(host) {
 		this.#host = host;
 	}
-	/** Drop every cached map/shape that depends on `id` (the file changed). */
+	/** Drop every cached map/shape that depends on `id` (the file changed), and every build in flight
+	*  that has met it so far (one it meets later reads the file as it is now). */
 	invalidate(id) {
 		const clean = id.replace(STRIP_QUERY_RE, "");
 		this.#shapes.delete(clean);
-		for (const [k, m] of this.#maps) if (k === clean || m && m.deps.has(clean)) this.#maps.delete(k);
+		this.#barrels.drop(({ id: k }, entry) => {
+			if (k === clean) return true;
+			const map = entry.kind === "kept" ? entry.answer : this.#building.get(k);
+			return map != null && map.deps.has(clean);
+		});
 	}
 	/** The parsed shape of a module (cached), or null when it cannot be read/parsed. */
 	shape(id) {
@@ -50,44 +71,45 @@ var BarrelIndex = class {
 	/**
 	* The export map of a barrel, or null when the module is not a barrel the plugin may rewrite
 	* (not a candidate, impure and not forced, kept, unreadable). `spec` is the specifier the
-	* importer wrote — matchers see both. Concurrent callers share one build.
+	* importer wrote — matchers see both. Concurrent callers share one build; a build resolves as
+	* the `caller` that started it.
 	*/
-	async map(id, spec) {
+	async map(id, spec, caller) {
 		const clean = id.replace(STRIP_QUERY_RE, "");
 		if (clean !== id) return null;
 		if (this.#host.kept(clean, spec)) return null;
 		if (!this.#host.candidate(clean, spec)) return null;
-		if (this.#maps.has(clean)) return this.#maps.get(clean);
-		const pending = this.#pending.get(clean);
-		if (pending) return pending;
-		const shape = this.shape(clean);
-		if (!shape) {
-			this.#maps.set(clean, null);
-			return null;
-		}
-		if (!shape.pure && !this.#host.forced(clean, spec)) {
-			this.#maps.set(clean, null);
-			return null;
+		for (;;) {
+			const got = await this.#barrels.get(this.#ask(clean, spec, caller));
+			if (got !== STALE) return got;
 		}
-		return this.#start(clean, shape, /* @__PURE__ */ new Set());
 	}
-	/** Begin one build for `id`, register it as in flight, cache the result unless provisional. */
-	#start(id, shape, walk) {
-		const run = (async () => {
-			try {
-				const built = await this.#build(id, shape, walk);
-				if (!built.provisional && built.cycles.size === 0) this.#maps.set(id, built);
-				return built;
-			} finally {
-				this.#pending.delete(id);
+	/** What a caller of `map()` asks for: the barrel's build, or (it is not one) null. Only the ask
+	*  that starts the barrel's flight runs; a built or building barrel is not looked at again. */
+	#ask(id, spec, caller) {
+		if (this.#barrels.peek({ id }) !== void 0) return {
+			id,
+			build: null
+		};
+		const shape = this.shape(id);
+		if (!shape || !shape.pure && !this.#host.forced(id, spec)) return {
+			id,
+			build: null
+		};
+		return {
+			id,
+			build: {
+				shape,
+				walk: {
+					stack: /* @__PURE__ */ new Set(),
+					caller
+				}
 			}
-		})();
-		this.#pending.set(id, run);
-		return run;
+		};
 	}
-	async #build(id, shape, outer) {
-		const walk = new Set(outer);
-		walk.add(id);
+	/** One build of `id` (a barrel's flight): kept once built unless provisional; STALE to its
+	*  callers when an edit drops it first (it stores nothing then). */
+	async #build_of(id, shape, walk) {
 		const map = {
 			id,
 			entries: /* @__PURE__ */ new Map(),
@@ -98,6 +120,19 @@ var BarrelIndex = class {
 			provisional: false,
 			cycles: /* @__PURE__ */ new Set()
 		};
+		this.#building.set(id, map);
+		try {
+			return await this.#build(map, shape, walk);
+		} finally {
+			if (this.#building.get(id) === map) this.#building.delete(id);
+		}
+	}
+	async #build(map, shape, outer) {
+		const id = map.id;
+		const walk = {
+			stack: /* @__PURE__ */ new Set([...outer.stack, id]),
+			caller: outer.caller
+		};
 		const stars = [];
 		const explicit = /* @__PURE__ */ new Set();
 		for (const rec of shape.exports) if (rec.kind === "own") {
@@ -110,7 +145,7 @@ var BarrelIndex = class {
 			else map.opaque = true;
 		} else if (rec.kind === "star_ns") {
 			explicit.add(rec.exported);
-			const target = await this.#host.resolve(rec.source, id);
+			const target = await this.#host.resolve(rec.source, id, walk.caller);
 			if (target) map.entries.set(rec.exported, {
 				id: target.replace(STRIP_QUERY_RE, ""),
 				namespace: true
@@ -121,7 +156,7 @@ var BarrelIndex = class {
 			type_only: rec.type_only
 		});
 		for (const star of stars) {
-			const target = await this.#host.resolve(star.source, id);
+			const target = await this.#host.resolve(star.source, id, walk.caller);
 			if (!target || target !== target.replace(STRIP_QUERY_RE, "")) {
 				map.opaque = true;
 				continue;
@@ -148,7 +183,7 @@ var BarrelIndex = class {
 	}
 	/** The leaf behind `import { imported } from source` written inside barrel `from`. */
 	async #leaf(from, source, imported, map, walk) {
-		const target = await this.#host.resolve(source, from);
+		const target = await this.#host.resolve(source, from, walk.caller);
 		if (!target) return null;
 		if (target !== target.replace(STRIP_QUERY_RE, "")) return null;
 		map.deps.add(target);
@@ -172,22 +207,34 @@ var BarrelIndex = class {
 	*/
 	async #through(id, parent, walk) {
 		if (this.#host.kept(id, id)) return null;
-		if (this.#maps.has(id)) {
-			const m = this.#maps.get(id) ?? null;
+		const s = this.#barrels.peek({ id });
+		if (s?.kind === "kept") {
+			const m = s.answer;
 			if (m) for (const d of m.deps) parent.deps.add(d);
 			return m;
 		}
-		if (walk.has(id)) {
+		if (walk.stack.has(id)) {
 			if (id !== parent.id) parent.cycles.add(id);
 			return null;
 		}
-		if (this.#pending.has(id)) {
+		if (s !== void 0) {
 			parent.provisional = true;
 			return null;
 		}
 		const shape = this.shape(id);
 		if (!shape || !shape.pure) return null;
-		const built = await this.#start(id, shape, walk);
+		const built = await this.#barrels.get({
+			id,
+			build: {
+				shape,
+				walk
+			}
+		});
+		if (built === STALE) {
+			parent.provisional = true;
+			return null;
+		}
+		if (built === null) return null;
 		if (built.provisional) parent.provisional = true;
 		for (const c of built.cycles) if (c !== parent.id) parent.cycles.add(c);
 		for (const d of built.deps) parent.deps.add(d);
@@ -218,13 +265,13 @@ var BarrelIndex = class {
 			if (leaf) out.set(rec.exported, leaf);
 			else parent.opaque = true;
 		} else if (rec.kind === "star_ns") {
-			const t = await this.#host.resolve(rec.source, target);
+			const t = await this.#host.resolve(rec.source, target, walk.caller);
 			if (t) out.set(rec.exported, {
 				id: t.replace(STRIP_QUERY_RE, ""),
 				namespace: true
 			});
 		} else {
-			const t = await this.#host.resolve(rec.source, target);
+			const t = await this.#host.resolve(rec.source, target, walk.caller);
 			if (!t) {
 				parent.opaque = true;
 				continue;

package/dist/compiler/debarrel/plugin.js

@@ -4,6 +4,7 @@ import { rewrite_module } from "./rewrite.js";
 import { rewrite_svelte } from "./svelte.js";
 import { is_script_request } from "../script-request.js";
 import { strip_bom } from "../bom.js";
+import { line, warn } from "../../messages/build.js";
 import { readFileSync, statSync } from "node:fs";
 import { searchForWorkspaceRoot } from "vite";
 // src/compiler/debarrel/plugin.ts
@@ -40,7 +41,6 @@ function debarrel(options = {}, internal = {}) {
 		return { skip: (decl) => decl.attribute_keys.some((k) => skip_keys.has(k)) || !!locals && locals.size > 0 && decl.specs.some((s) => locals.has(s.local)) };
 	};
 	let root = process.cwd().replace(BACKSLASH_G, "/");
-	let resolver = null;
 	let log = (msg) => console.log(msg);
 	let command = "serve";
 	const mtimes = /* @__PURE__ */ new Map();
@@ -57,23 +57,31 @@ function debarrel(options = {}, internal = {}) {
 	});
 	let report = fresh_report();
 	const warned = /* @__PURE__ */ new Set();
+	const indexes = /* @__PURE__ */ new Map();
+	const index_of = (environment) => {
+		let index = indexes.get(environment);
+		if (index === void 0) indexes.set(environment, index = new BarrelIndex(host));
+		return index;
+	};
+	const invalidate = (id) => {
+		for (const index of indexes.values()) index.invalidate(id);
+	};
 	const host = {
 		read(id) {
 			try {
 				const st = statSync(id);
 				const prev = mtimes.get(id);
-				if (prev !== void 0 && prev !== st.mtimeMs) index.invalidate(id);
+				if (prev !== void 0 && prev !== st.mtimeMs) invalidate(id);
 				mtimes.set(id, st.mtimeMs);
 				return strip_bom(readFileSync(id, "utf8"));
 			} catch {
 				return null;
 			}
 		},
-		async resolve(spec, importer) {
-			if (!resolver) return null;
+		async resolve(spec, importer, caller) {
 			let r;
 			try {
-				r = await resolver.resolve(spec, importer, { skipSelf: true });
+				r = await caller.resolve(spec, importer, { skipSelf: true });
 			} catch {
 				return null;
 			}
@@ -89,7 +97,6 @@ function debarrel(options = {}, internal = {}) {
 		kept: (id, spec) => o.keep.length > 0 && matches_any(o.keep, id, spec),
 		follow_packages: o.follow_packages
 	};
-	const index = new BarrelIndex(host);
 	const is_importer = (id) => {
 		if (id.includes("\0")) return false;
 		if (!is_script_request(id)) return false;
@@ -108,22 +115,20 @@ function debarrel(options = {}, internal = {}) {
 			command = config.command;
 			log = (msg) => config.logger.info(msg);
 		},
-		buildStart() {
-			resolver = this;
-		},
 		async transform(raw, id) {
 			if (!is_importer(id)) return null;
 			const code = strip_bom(raw);
-			resolver = this;
+			const caller = this;
+			const index = index_of(this.environment.name);
 			const t0 = performance.now();
 			if (report.files === 0) report.first_ms = t0;
 			report.files++;
 			const importer = id.replace(QUERY_RE, "");
 			const seen = [];
 			const lookup = async (spec) => {
-				const resolved = await host.resolve(spec, importer);
+				const resolved = await host.resolve(spec, importer, caller);
 				if (!resolved) return null;
-				const map = await index.map(resolved, spec);
+				const map = await index.map(resolved, spec, caller);
 				if (map) seen.push(map);
 				return map;
 			};
@@ -132,7 +137,11 @@ function debarrel(options = {}, internal = {}) {
 				report.skipped.add(importer);
 				if (warned.has(importer)) return;
 				warned.add(importer);
-				console.warn(`[ogygia] barrels: skipped ${short(importer, root)}: ${why.code}${why.line ? ` at ${why.line}:${why.column ?? 1}` : ""} — its imports stay on their barrels`);
+				warn("barrels_component_skipped", {
+					file: short(importer, root),
+					reason: why.code,
+					at: why.line ? `${why.line}:${why.column ?? 1}` : ""
+				});
 			}) : await rewrite_module(code, importer, lookup, policy);
 			for (const map of seen) for (const d of map.deps) if (!d.includes("\0")) this.addWatchFile(d);
 			report.last_ms = performance.now();
@@ -149,14 +158,19 @@ function debarrel(options = {}, internal = {}) {
 				b.importers.add(importer);
 				report.barrels.set(m.barrel, b);
 			}
-			if (o.debug) for (const m of result.moves) log(`[ogygia] barrels: ${short(importer, root)}: ${m.names.join(", ")} ← ${short(m.barrel, root)} → ${m.leaves.map((l) => short(l, root)).join(", ")}`);
+			if (o.debug) for (const m of result.moves) log(line("barrels_rewrite", {
+				file: short(importer, root),
+				names: m.names.join(", "),
+				barrel: short(m.barrel, root),
+				leaves: m.leaves.map((l) => short(l, root)).join(", ")
+			}));
 			return {
 				code: result.code,
 				map: result.map
 			};
 		},
 		watchChange(id) {
-			index.invalidate(id.replace(BACKSLASH_G, "/"));
+			invalidate(id.replace(BACKSLASH_G, "/"));
 		},
 		closeBundle() {
 			if (o.report && command === "build") log(format_report(report, root, o.report === "all" ? Infinity : 8));
@@ -173,8 +187,18 @@ const n = (v) => v.toLocaleString("en-US");
 function format_report(r, root, limit) {
 	const span_s = ((r.last_ms - r.first_ms) / 1e3).toFixed(2);
 	const skipped = r.skipped?.size ? [`  ${n(r.skipped.size)} component${r.skipped.size === 1 ? "" : "s"} skipped (could not be parsed; their imports stay on their barrels): ${[...r.skipped].slice(0, limit).map((id) => short(id, root)).join(", ")}${r.skipped.size > limit ? ` and ${n(r.skipped.size - limit)} more` : ""}`] : [];
-	if (r.importers === 0) return [`[ogygia] barrels: ${n(r.files)} files scanned, no barrel imports to rewrite (${span_s} s)`, ...skipped].join("\n");
-	const head = `[ogygia] barrels: ${n(r.importers)} of ${n(r.files)} files rewritten — ${n(r.imports)} barrel imports → leaves (${n(r.names)} names), ${n(r.barrels.size)} barrels bypassed, ${span_s} s first to last transform`;
+	if (r.importers === 0) return [line("barrels_report_none", {
+		files: n(r.files),
+		seconds: span_s
+	}), ...skipped].join("\n");
+	const head = line("barrels_report", {
+		importers: n(r.importers),
+		files: n(r.files),
+		imports: n(r.imports),
+		names: n(r.names),
+		barrels: n(r.barrels.size),
+		seconds: span_s
+	});
 	const sorted = [...r.barrels.entries()].sort((a, b) => b[1].names - a[1].names);
 	const top = sorted.slice(0, limit);
 	const width = Math.max(...top.map(([, b]) => n(b.names).length));

package/dist/compiler/dev/dev-hmr.d.ts

@@ -20,6 +20,9 @@
  * it blanks the page; a MutationObserver would also delete FOUC styles the SPA router merges
  * in on navigation.
  *
+ * Its `hot.on` listeners are its module run's, and need no scope: Vite drops a replaced module's
+ * `hot.on` listeners itself (the client's `ctxToListenersMap`), and a full reload ends the page.
+ *
  * @internal Emitted by the plugin; exported for unit tests.
  */
 export declare function dev_hmr_client_source(): string;

package/dist/compiler/dev/dev-hmr.js

@@ -21,6 +21,9 @@
 * it blanks the page; a MutationObserver would also delete FOUC styles the SPA router merges
 * in on navigation.
 *
+* Its `hot.on` listeners are its module run's, and need no scope: Vite drops a replaced module's
+* `hot.on` listeners itself (the client's `ctxToListenersMap`), and a full reload ends the page.
+*
 * @internal Emitted by the plugin; exported for unit tests.
 */
 function dev_hmr_client_source() {