@ogygia/core 0.11.4 → 0.12.0

package/README.md

@@ -6,4 +6,4 @@ Apps install [`ogygia`](https://www.npmjs.com/package/ogygia), which re-exports
 subpath. Plugin packages (`@ogygia/flags`, `@ogygia/devtools`, …) build on `@ogygia/core` and its
 `@ogygia/core/plugin` door.
 
-Docs: [ogygiajs.dev](https://ogygiajs.dev)
+Docs: [@ogygia/core](https://ogygiajs.dev/docs/core/overview), with [Writing a plugin](https://ogygiajs.dev/docs/core/plugins).

package/dist/KeepHost.svelte

@@ -4,7 +4,7 @@
 // as NestedProvider mirrors it). LiveHost has no `{#if}`: it hydrates a live region's render()
 // output, and a kept island hydrated through it met the server's `[0` branch marker where it
 // expected the component's own, discarding the server DOM on every load. NOT part of the public API.
-import { setNested } from "./context.js";
+import { setNested } from "./nested.js";
 let { component: Component, initialProps } = $props();
 // Seed once from the incoming prop; later pages replace it via setProps(). Intentional initial read.
 // svelte-ignore state_referenced_locally

package/dist/LiveHost.svelte

@@ -4,7 +4,7 @@
 // NestedProvider, its props are `$state` and it exposes `setProps` — so a live tick updates the
 // MOUNTED component reactively instead of tearing it down and re-hydrating. Focus and local island
 // state survive; Svelte reconciles the view. NOT part of the public API.
-import { setNested } from "./context.js";
+import { setNested } from "./nested.js";
 let { component: Component, initialProps } = $props();
 // Seed once from the incoming prop; later ticks replace it via setProps(). Intentional initial read.
 // svelte-ignore state_referenced_locally

package/dist/NestedProvider.svelte

@@ -5,7 +5,7 @@
 // `class:`-driven `position: fixed` drops to `static` for a frame). SELF-CLOSING on purpose: any
 // slot content here would pass an implicit `children` snippet that OVERRIDES the decoded
 // `props.children` (the revived slot/region snippet) and desyncs hydration with an extra anchor.
-import { setNested } from "./context.js";
+import { setNested } from "./nested.js";
 let { component: Component, props } = $props();
 setNested();
 </script>

package/dist/Region.svelte

@@ -104,7 +104,7 @@
 	 *   children?: import('svelte').Snippet;
 	 *   __mode?: 'island' | 'server' | 'lake'; __baked?: boolean;
 	 *   visible?: string | boolean; idle?: boolean; media?: string; load?: boolean; interaction?: boolean;
-	 *   __keep?: string; __entry?: string; __src?: string; __component?: import('svelte').Component; __css?: unknown;
+	 *   __keep?: string; __entry?: string; __component?: import('svelte').Component; __css?: unknown;
 	 *   __load?: () => Promise<import('svelte').Component>;
 	 *   __props?: Record<string, unknown>; __defer?: string; __margin?: string; __hydrate?: string;
 	 *   __hydrateMargin?: string; __module?: string; __cacheTtl?: number; __stitch?: string; __prefetch?: string;
@@ -132,11 +132,9 @@
 		load,
 		interaction,
 		__keep,
-		// island + server shared. `__entry` is the island's IDENTITY (its stable URL); `__src` its
-		// LOCATION — the content-hashed file to load — which only the client build knows (its wrapper
-		// passes the bundler's own name for it). The server finds the location in the build handoff.
+		// island + server shared. `__entry` is the island's IDENTITY (its stable URL, a name); its
+		// LOCATION, the content-hashed file to load, the server finds in the build handoff.
 		__entry = '',
-		__src = '',
 		__component,
 		__css,
 		// The client wrapper's on-demand component fetch (its lazy module answered `undefined`: a
@@ -497,13 +495,15 @@
 	const island_module_url = $derived(nested || !island_entry ? '' : asset(island_entry));
 	// IDENTITY vs LOCATION (server/entry-location.ts): `island_module_url` is the island's identity
 	// (the `entry` attribute, the graph key, the fingerprint input); the file the runtime loads is its
-	// location — content-hashed, so an `immutable` cache never serves a stale one. The client build's
-	// wrapper passes it (`__src`); the server reads the build handoff. None → the identity is loaded.
+	// location — content-hashed, so an `immutable` cache never serves a stale one. The server reads it
+	// from the build handoff (in dev the identity is the location); a region the browser renders has
+	// none, and the runtime finds it in the build's location map (runtime/entry-locations.ts). Only a
+	// location is ever written as a URL to fetch: no location, no URL.
 	const location_of = (/** @type {string} */ identity) => {
 		const found = identity ? entryLocation(identity) : null;
 		return found ? asset(found) : '';
 	};
-	const island_src = $derived(nested || !island_entry ? '' : __src || location_of(island_entry));
+	const island_src = $derived(nested || !island_entry ? '' : location_of(island_entry));
 	// (written LAST on the element: every attribute before it keeps the order it had before
 	// locations, so HTML rewriters and scans keyed on `entry="…" wake="…"` still match)
 
@@ -605,7 +605,7 @@
 		for (const dep of deps) add(asset(dep));
 		for (const m of live_entries) {
 			// (the file the snippet's import fetches: its location, when the build named one)
-			add(location_of(m) || asset(m));
+			add(location_of(m));
 			for (const dep of islandDeps(m)) add(asset(dep));
 		}
 		return hrefs;
@@ -637,10 +637,8 @@
 	// island only, at `fetchpriority="low"` (document-tail.ts `modulepreload_tag`): nothing it
 	// downloads is needed for first paint, so it must never outrank the CSS and the LCP image.
 	const island_kit_hint_hrefs = $derived(
-		// (the entry's LOCATION: the file its import fetches, not the stable name)
-		is_csr && hydrate_attr === 'load' && island_module_url
-			? [island_src || island_module_url, ...island_graph_hrefs]
-			: []
+		// (the entry's LOCATION: the file its import fetches; an entry with none gets no hint)
+		is_csr && hydrate_attr === 'load' && island_src ? [island_src, ...island_graph_hrefs] : []
 	);
 	// Both ride the document tail on a Kit page (see `tail` above); the head everywhere else, so a
 	// self-contained render root carries its own.
@@ -688,7 +686,7 @@
 	// nav. The endpoint (which fetches the hole's HTML) is minted from `__entry` above, independently.
 	const server_region_entry = $derived(!nested && __module ? asset(__module) : '');
 	// …and its location, the file that import fetches (as for an island)
-	const server_region_src = $derived(!nested && __module ? __src || location_of(__module) : '');
+	const server_region_src = $derived(!nested && __module ? location_of(__module) : '');
 
 	// A hydrating hole's props: ADJACENT and self-contained (the hole's HTML is spliced by the
 	// runtime), unkeyed, in whichever lane the props qualify for (props-wire.ts).
@@ -966,14 +964,23 @@
 		return html;
 	});
 
+	// THE HEAD IS SERVER OUTPUT. Every piece of it is a fact only the render knows (the build's
+	// handoff, the request's claims), and the browser knows none of them: a URL it built here would
+	// be a guess — an identity, a name with no file. Svelte keeps the server's nodes when it hydrates
+	// the head, but a Kit-hydrated document's head is often mounted afresh (the handle rewrote it),
+	// and a region Kit mounts on a client-side navigation has no server render at all: either way
+	// the client writes nothing. What a client-mounted region loads it loads through its own
+	// `import()`, which the bundler resolves to the file and preloads with its dependencies.
 	const head_html = $derived(
-		(is_island
-			? runtime_script + island_preload_head + island_css_html + kit_island_meta
-			: is_server
-				? runtime_script + server_preload + hole_css_html
-				: runtime_script) +
-			region_css_html +
-			content_css_html
+		typeof window !== 'undefined'
+			? ''
+			: (is_island
+					? runtime_script + island_preload_head + island_css_html + kit_island_meta
+					: is_server
+						? runtime_script + server_preload + hole_css_html
+						: runtime_script) +
+					region_css_html +
+					content_css_html
 	);
 
 	// ────────────────────────────────────────────────────── held: live / deferred ──

package/dist/Region.svelte.d.ts

@@ -14,7 +14,6 @@ type Region = {
         interaction?: boolean | undefined;
         __keep?: string | undefined;
         __entry?: string | undefined;
-        __src?: string | undefined;
         __component?: Component<any, any, string> | undefined;
         __css?: unknown;
         __load?: (() => Promise<Component<any, any, string>>) | undefined;
@@ -47,7 +46,6 @@ declare const Region: import("svelte").Component<{
     interaction?: boolean;
     __keep?: string;
     __entry?: string;
-    __src?: string;
     __component?: import("svelte").Component;
     __css?: unknown;
     __load?: () => Promise<import("svelte").Component>;

package/dist/SlotBoundary.svelte

@@ -5,7 +5,7 @@
 * (`<ogygia-region>` + payload) so the runtime can wake it independently after the parent ADOPTS the
 * slot DOM. Server-only in practice (the client adopts, never re-renders slot children).
 */
-import { setNested } from "./context.js";
+import { setNested } from "./nested.js";
 let { children } = $props();
 setNested(false);
 </script>

package/dist/compiler/bom.js

@@ -2,7 +2,7 @@
 /**
 * A leading UTF-8 byte-order mark is invisible text. Svelte's `parse` drops it, so every AST offset
 * it reports is one short of the raw source, and a pass that edits the raw source by those offsets
-* (MagicString) lands one character early — splitting a tag name (`<qds-butto data-og-opaquen`, a
+* (MagicString) lands one character early — splitting a tag name (`<ds-butto data-og-opaquen`, a
 * field build). The compiler therefore takes the mark off at the doors where source comes in (the
 * per-file transform, the barrel rewrite, the file reader), so every pass sees exactly the text its
 * parser saw. Dropping it changes nothing a browser or a bundler reads.

package/dist/compiler/browser.d.ts

@@ -6,6 +6,6 @@ import { JsRegion, OgCall, find_og_calls, is_js_module, og_js_regions, split_fir
 import { og_member } from "./macros/wire.js";
 import { BuildCache, __set_build_cache_root, configure_build_cache } from "../build-cache.js";
 import { contentCssKey as content_css_key } from "../plugin/utils.js";
-import { dedent } from "./macros/dedent.js";
+import { dedent } from "./dedent.js";
 import { run_browser_macros } from "./macros/browser.js";
 export { BuildCache, CLIENT_BINDING_STUB, type CompilerHost, type JsRegion, type OgCall, type ParseResult, type RawParse, __set_build_cache_root, configure_build_cache, content_css_key, createHash, dedent, find_og_calls, fs, is_js_module, islandVirtualId, og_js_regions, og_member, parse_module, path, run_browser_macros, set_host, set_parser, split_first_string, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/browser.js

@@ -6,6 +6,6 @@ import { find_og_calls, is_js_module, og_js_regions, split_first_string } from "
 import { og_member } from "./macros/wire.js";
 import { BuildCache, __set_build_cache_root, configure_build_cache } from "../build-cache.js";
 import { contentCssKey as content_css_key } from "../plugin/utils.js";
-import { dedent } from "./macros/dedent.js";
+import { dedent } from "./dedent.js";
 import { run_browser_macros } from "./macros/browser.js";
 export { BuildCache, CLIENT_BINDING_STUB, __set_build_cache_root, configure_build_cache, content_css_key, createHash, dedent, find_og_calls, fs, is_js_module, islandVirtualId, og_js_regions, og_member, parse_module, path, run_browser_macros, set_host, set_parser, split_first_string, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/ctx.d.ts

@@ -160,7 +160,7 @@ export declare class CompileCtx {
    *  runs. Both the stable name and the content-hashed file carry it, so a name says which runtime. */
   runtime_features(program_feature_hash: string): string;
   /** The runtime's STABLE name (`RUNTIME_HASH` ⊕ its features): its identity — the key the handoff
-   *  maps to the content-hashed file the page loads — and the name of that file's shim. Computed here
+   *  maps to the content-hashed file the page loads (a name, not a file). Computed here
    *  (not the caller) so both build legs name it identically. `program_feature_hash` is
    *  `Program.runtime_feature_hash`, threaded in by the caller so this stays a pure naming function. */
   runtime_chunk_filename(program_feature_hash: string): string;

package/dist/compiler/ctx.js

@@ -2,7 +2,7 @@ import { fs } from "./host.js";
 import { strip_bom } from "./bom.js";
 import { islandVirtualId } from "./ids.js";
 import { parse_module } from "./parse/oxc.js";
-import { islandChunkFileName, islandPublicUrl, wrapperVirtualId } from "./region/transform.js";
+import { STABLE_NAME_DIR, islandChunkFileName, islandPublicUrl, wrapperVirtualId } from "./region/transform.js";
 // src/compiler/ctx.ts
 /**
 * `CompileCtx` — the resolved compile context: the config the transform phase reads, plus its
@@ -156,12 +156,12 @@ var CompileCtx = class {
 		return `${program_feature_hash}${this.client_hooks ? "h" : ""}`;
 	}
 	/** The runtime's STABLE name (`RUNTIME_HASH` ⊕ its features): its identity — the key the handoff
-	*  maps to the content-hashed file the page loads — and the name of that file's shim. Computed here
+	*  maps to the content-hashed file the page loads (a name, not a file). Computed here
 	*  (not the caller) so both build legs name it identically. `program_feature_hash` is
 	*  `Program.runtime_feature_hash`, threaded in by the caller so this stays a pure naming function. */
 	runtime_chunk_filename(program_feature_hash) {
 		const feat = this.runtime_features(program_feature_hash);
-		return `${this.app_dir}/immutable/og-runtime.${this.runtime_hash}${feat ? "-" + feat : ""}.js`;
+		return `${this.app_dir}/${STABLE_NAME_DIR}/og-runtime.${this.runtime_hash}${feat ? "-" + feat : ""}.js`;
 	}
 	/** App-internal URL of the runtime chunk (leading slash + appDir; NO base). SSR bakes it as the
 	*  `<script src>`, then `asset()` prepends base / the assets CDN at render time. */

package/dist/compiler/{macros/dedent.d.ts → dedent.d.ts}

@@ -8,5 +8,16 @@
  * their literal column contribution to the prefix (the common prefix is computed on raw characters,
  * so mixed tabs/spaces still de-indent correctly as long as the leading run is consistent — which it
  * is for machine-indented source).
+ *
+ * Also a TAG, for the code the compiler generates (its virtual modules), written as the code itself:
+ *
+ *     dedent`
+ *         export const dev = ${is_dev};
+ *     `
+ *
+ * The template's own text is de-indented first and the values go in after, so a value spanning lines
+ * (a generated block) never decides the indent. Values are interpolated as a template literal would
+ * (cooked strings: `\\n` in the template is a newline).
  */
-export declare function dedent(text: string): string;
+export declare function dedent(text: string): string;
+export declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;

package/dist/compiler/dedent.js

@@ -0,0 +1,43 @@
+// src/compiler/dedent.ts
+const CRLF_G = /\r\n?/g;
+const LEADING_INDENT_RE = /^[\t ]*/;
+function dedent(first, ...values) {
+	if (typeof first === "string") return dedent_text(first);
+	let text = first[0];
+	for (let i = 1; i < first.length; i++) text += SLOT + (i - 1) + SLOT + first[i];
+	const flat = dedent_text(text);
+	if (values.length === 0) return flat;
+	let out = "";
+	let at = 0;
+	for (;;) {
+		const open = flat.indexOf(SLOT, at);
+		if (open === -1) return out + flat.slice(at);
+		const close = flat.indexOf(SLOT, open + 1);
+		out += flat.slice(at, open) + String(values[Number(flat.slice(open + 1, close))]);
+		at = close + 1;
+	}
+}
+/** The placeholder edge for a tag's value while its template is de-indented. */
+const SLOT = "\0";
+function dedent_text(text) {
+	const lines = text.replace(CRLF_G, "\n").split("\n");
+	while (lines.length && lines[0].trim() === "") lines.shift();
+	while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
+	if (!lines.length) return "";
+	let common = null;
+	for (const line of lines) {
+		if (line.trim() === "") continue;
+		const lead = LEADING_INDENT_RE.exec(line)[0];
+		if (common === null) common = lead;
+		else {
+			let i = 0;
+			const max = Math.min(common.length, lead.length);
+			while (i < max && common[i] === lead[i]) i++;
+			common = common.slice(0, i);
+		}
+		if (common === "") break;
+	}
+	const n = common?.length ?? 0;
+	return lines.map((line) => line.trim() === "" ? "" : line.slice(n)).join("\n");
+}
+export { dedent };

package/dist/compiler/driver.d.ts

@@ -158,6 +158,9 @@ export declare class Compiler {
    *  bundle end turns them into the hashed file names the handoff maps the stable names to. */
   readonly island_entry_refs: Map<string, string>;
   runtime_entry_ref: string | null;
+  /** The location map's served path (`/<appDir>/immutable/og-locations.<hash>.json`), once
+   *  `location_map` wrote it: the handoff carries it to the server (`locations`). */
+  location_map_url: string | null;
   /**
    * At the bundle's end (the names are final): each entry's IDENTITY → its LOCATION. `islands` maps
    * an island entry's hashed file to its identity (the collector keys every map by identity);
@@ -170,8 +173,8 @@ export declare class Compiler {
     runtime_file: string | null;
     locations: Record<string, string>;
   };
-  /** One hydrate island's entry, content-hashed by the bundler (its stable-name shim is written at
-   *  the bundle's end: `entry_shims`). */
+  /** One hydrate island's entry, content-hashed by the bundler (the location maps that name it are
+   *  written at the bundle's end: `location_maps`). */
   emit_island_entry(emitFile: EmitChunk, rid: string, virtualPath: string): void;
   /**
    * The output file pattern for one of OUR entries (by the chunk name `emit_island_entry` / the
@@ -182,11 +185,11 @@ export declare class Compiler {
    */
   entry_file_pattern(chunk_name: string | undefined): string | null;
   /**
-   * The stable-name shims (link/entry-shim.ts), for the bundle's end (the names are final): one per
-   * island entry, plus the runtime's — each a plain file at the old stable name re-exporting the
-   * hashed file. `get_file_name` is the bundler's `this.getFileName`.
+   * The build's location maps (link/location-map.ts), for the bundle's end (the names are final):
+   * every island entry's identity → its hashed file, content-hashed and at the one fixed name.
+   * `get_file_name` is the bundler's `this.getFileName`. Empty with no island.
    */
-  entry_shims(get_file_name: (ref: string) => string): {
+  location_maps(get_file_name: (ref: string) => string): {
     fileName: string;
     source: string;
   }[];

package/dist/compiler/driver.js

@@ -1,15 +1,15 @@
 import { createHash, dir_entries, fs, path } from "./host.js";
 import { fnv1a32 } from "../runtime/hash.js";
 import { CLIENT_BINDING_STUB, is_island_path, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
-import { clean_stale_ogygia_dirs, hasAnyCsrTrueRoute, kit_dirs, routeCsrIsFalse, routeCsrIsTrue } from "./kit.js";
+import { clean_stale_ogygia_dirs, hasAnyCsrTrueRoute, is_route_component, kit_dirs, routeCsrIsFalse, routeCsrIsTrue } from "./kit.js";
 import { run_module_macros } from "./macros/pipeline.js";
 import { is_script_request } from "./script-request.js";
-import { generateHydrateFeaturesSource, generateRuntimeEntrySource, resolveFeatures } from "./link/runtime-entry.js";
+import { generateHydrateFeaturesSource, generateRuntimeEntrySource, generateRuntimeFlagsSource, resolveFeatures } from "./link/runtime-entry.js";
 import { resolveFoucImportSpec } from "./fouc-css.js";
 import { appendSvelteModuleRegistrations, appendTransportRegistrations, moduleHasTransportable, svelteModuleHasTransportable } from "./content/transportables.js";
 import { APP_SHIM_IMPORT, FOREIGN_HYDRATE_MARK, rewrite_lake_import_to_placeholder } from "./region/emit.js";
 import { island_deps_module } from "./link/island-deps.js";
-import { island_shim_source, runtime_shim_source } from "./link/entry-shim.js";
+import { location_map_files } from "./link/location-map.js";
 import { context_string_keys, source_uses_ogygia_context } from "./link/context-detect.js";
 import { collect_flag_sites } from "./flags.js";
 import { router_css_module, router_css_roots } from "./link/router-css.js";
@@ -20,7 +20,7 @@ import { PAGE_DATA_READS_TOKEN, server_island_ids, server_islands_module, server
 import { manifest_module } from "./link/manifest.js";
 import { dev_hmr_client_source } from "./dev/dev-hmr.js";
 import { island_vpaths_affected_by_file, same_module_path } from "./dev/hmr.js";
-import { PROFILER_MAPS_PLACEHOLDER, RESOLVED, V_DEVTOOLS_BOOT, V_DEVTOOLS_BOOT_URL, V_DEVTOOLS_META, V_DEV_HMR, V_DEV_HMR_URL, V_FN_MANIFEST, V_HYDRATE_FEATURES, V_ISLAND_DEPS, V_KIT_TRANSPORT, V_MANIFEST, V_PROFILER_MAPS, V_RATE_LIMIT, V_REGION_ENDPOINT, V_REGION_TTL, V_REQUEST_EVENT, V_ROUTER_CONFIG, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_RUNTIME, V_RUNTIME_ENTRY, V_RUNTIME_URL, V_SECRET, V_SERVER_ISLANDS, V_SERVER_MANIFEST, V_SERVER_PLUGINS, V_SESSION_COOKIE, V_SIGN, V_TRANSPORT, V_TRANSPORTABLES, V_TRANSPORTABLES_EAGER } from "./ids.js";
+import { PROFILER_MAPS_PLACEHOLDER, RESOLVED, V_DEVTOOLS_BOOT, V_DEVTOOLS_BOOT_URL, V_DEVTOOLS_META, V_DEV_HMR, V_DEV_HMR_URL, V_FN_MANIFEST, V_HYDRATE_FEATURES, V_ISLAND_DEPS, V_KIT_TRANSPORT, V_MANIFEST, V_PROFILER_MAPS, V_RATE_LIMIT, V_REGION_ENDPOINT, V_REGION_TTL, V_REQUEST_EVENT, V_ROUTER_CONFIG, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_RUNTIME, V_RUNTIME_ENTRY, V_RUNTIME_FLAGS, V_RUNTIME_URL, V_SECRET, V_SERVER_ISLANDS, V_SERVER_MANIFEST, V_SERVER_PLUGINS, V_SESSION_COOKIE, V_SIGN, V_TRANSPORT, V_TRANSPORTABLES, V_TRANSPORTABLES_EAGER } from "./ids.js";
 import { host_key, strip_id } from "./program.js";
 import { mentions_page_store, page_data_keys_answer } from "./link/page-keys.js";
 import { export_names, is_registry_stub_id, registry_client_id, registry_client_path, registry_client_source, registry_stub_names, registry_stub_source, static_script_specs } from "./link/registry-stub.js";
@@ -46,8 +46,13 @@ const RUNTIME_ENTRY_NAME = "og-runtime";
 const LEADING_SLASH = /^\//;
 const BACKSLASH_G = /\\/g;
 const COMPONENT_EXT_RE = /\.(svelte|js|ts)$/;
-/** A Kit route host file (`+page.svelte`, `+layout.ts`, …) — the page node's own client modules. */
-const ROUTE_HOST_FILE_RE = /^\+(page|layout)\.(svelte|ts|js|mjs)$/;
+/** A Kit route option module (`+page.ts`, `+layout.js`, …) — the page node's own client modules
+*  beside its component (kit.ts `is_route_component`). */
+const ROUTE_HOST_FILE_RE = /^\+(page|layout)\.(ts|js|mjs)$/;
+/** The real binding modules a host imports for a marked region (ids.ts `regionBindingVirtualId`,
+*  transform.ts `wrapperVirtualId`). */
+const REGION_BINDING_PREFIX = "virtual:ogygia/region/";
+const WRAPPER_PREFIX = "virtual:ogygia/wrapper/";
 /** A `.ts`/`.js` module that can be a region registry (a minted `.ts` region host). */
 const TS_REGISTRY_EXT_RE = /\.(ts|js|mjs)$/;
 /** A Svelte rune module (`.svelte.ts` / `.svelte.js`). */
@@ -60,6 +65,10 @@ const SERVER_DIR_RE = /\/(src\/lib\/server|server)\//;
 /** Static import / export-from / `import()` specifiers, for the island-graph dep walk (shared `g`
 *  regex — `walk_dep` resets `lastIndex` before each scan). */
 const IMPORT_SPEC_G = /\bfrom\s*['"]([^'"\n]+)['"]|\bimport\s*['"]([^'"\n]+)['"]|\bimport\s*\(\s*['"]([^'"\n]+)['"]/g;
+const PAGE_FREE_APP_MODULES = /* @__PURE__ */ new Set(["$app/environment", "$app/paths"]);
+const ASSET_EXTS = "css|scss|sass|less|styl|pcss|postcss|json|svg|png|jpe?g|gif|webp|avif|ico|bmp|woff2?|ttf|otf|eot|txt|wasm|mp4|webm|mp3|wav";
+const ASSET_EXT_RE = new RegExp(`\\.(?:${ASSET_EXTS})$`, "i");
+const PAGE_FREE_UNRESOLVED_RE = new RegExp(`^svelte(?:\\/[\\w/-]+)?$|\\.(?:${ASSET_EXTS})(?:\\?[^/]*)?$`, "i");
 /** The extensions an extension-less island import may resolve to (bare, then index files). */
 const ISLAND_DEP_EXTS = [
 	"",
@@ -283,7 +292,7 @@ var Compiler = class {
 		const { prof, P, outHash } = this.profiler;
 		const ssr = opts.ssr !== false;
 		const routesDir = kit_dirs(ctx.root).routes_dir;
-		const is_layout_host = path.basename(id) === "+layout.svelte";
+		const is_layout_host = is_route_component(path.basename(id), "layout");
 		const link_virtual = opts.linkVirtual !== void 0 ? opts.linkVirtual : ssr || !routeCsrIsFalse(id, routesDir) || is_layout_host && hasAnyCsrTrueRoute(routesDir);
 		const route_csr = routeCsrIsTrue(id, routesDir) ? true : routeCsrIsFalse(id, routesDir) ? false : void 0;
 		const cache_key = `${id}\0${ssr ? "s" : "c"}\0${link_virtual ? "1" : "0"}\0${route_csr === true ? "t" : route_csr === false ? "f" : "n"}`;
@@ -384,7 +393,9 @@ var Compiler = class {
 				const src = ctx.read_file(full);
 				if (src == null) return;
 				if (!runtime_marks.context && source_uses_ogygia_context(src)) runtime_marks.context = true;
-				if (!program.crosses_wire && (name.endsWith(".remote.ts") || name.endsWith(".remote.js") || source_crosses_wire(src))) program.crosses_wire = true;
+				const remote = name.endsWith(".remote.ts") || name.endsWith(".remote.js");
+				if (remote) runtime_marks.remoteSeeds = true;
+				if (!program.crosses_wire && (remote || source_crosses_wire(src))) program.crosses_wire = true;
 				{
 					const specs = extract_module_specs(src);
 					if (specs.length) program.module_specs.set(full, specs);
@@ -453,6 +464,7 @@ var Compiler = class {
 			}
 		}
 		if (transportable_modules.size > 0) runtime_marks.wire = true;
+		runtime_marks.page = program.island_reads_page || ctx.foreign_hydrate || ctx.client_plugins.length > 0;
 		runtime_marks.complete = true;
 		program.runtime_feature_hash = createHash("sha256").update(resolveFeatures(runtime_marks).join(",")).digest("hex").slice(0, 8);
 	}
@@ -519,16 +531,25 @@ var Compiler = class {
 				island_graph.add(norm);
 				added.push(norm);
 			}
-			if (!SOURCE_EXT_RE.test(norm)) return;
+			if (!SOURCE_EXT_RE.test(norm)) {
+				if (!ASSET_EXT_RE.test(norm)) this.program.island_reads_page = true;
+				return;
+			}
 			const src = ctx.read_file(norm);
 			if (src == null) return;
 			IMPORT_SPEC_G.lastIndex = 0;
 			let m;
 			while (m = IMPORT_SPEC_G.exec(src)) {
 				const spec = m[1] || m[2] || m[3];
-				if (!spec || spec[0] === "\0" || spec.startsWith("$app/") || spec.startsWith("$env/") || spec.startsWith("virtual:")) continue;
+				if (!spec || spec[0] === "\0") continue;
+				if (spec.startsWith("$app/")) {
+					if (!PAGE_FREE_APP_MODULES.has(spec)) this.program.island_reads_page = true;
+					continue;
+				}
+				if (spec.startsWith("$env/") || spec.startsWith("virtual:")) continue;
 				const dep = resolve_dep(spec, norm);
 				if (dep) walk(dep);
+				else if (!PAGE_FREE_UNRESOLVED_RE.test(spec)) this.program.island_reads_page = true;
 			}
 		};
 		walk(componentAbs);
@@ -589,7 +610,7 @@ var Compiler = class {
 	* `emitRuntime`), then one chunk per deduped HYDRATE region id. IDENTITY vs LOCATION: SSR bakes the
 	* stable name (`island_public_url`) as the region's identity; the file the browser loads is named
 	* by its content (the bundler hashes it), and the bundle end hands the stable → hashed map to the
-	* server (the handoff's `entries`). The stable name is emitted too, as a shim of the hashed file.
+	* server (the handoff's `entries`) and to the browser (the location maps).
 	* csr=false hosts omit wrapper imports so this emit owns the module. Idempotent per id.
 	*/
 	#router_css_roots_cache = null;
@@ -674,6 +695,9 @@ var Compiler = class {
 	*  bundle end turns them into the hashed file names the handoff maps the stable names to. */
 	island_entry_refs = /* @__PURE__ */ new Map();
 	runtime_entry_ref = null;
+	/** The location map's served path (`/<appDir>/immutable/og-locations.<hash>.json`), once
+	*  `location_map` wrote it: the handoff carries it to the server (`locations`). */
+	location_map_url = null;
 	/**
 	* At the bundle's end (the names are final): each entry's IDENTITY → its LOCATION. `islands` maps
 	* an island entry's hashed file to its identity (the collector keys every map by identity);
@@ -704,8 +728,8 @@ var Compiler = class {
 			locations
 		};
 	}
-	/** One hydrate island's entry, content-hashed by the bundler (its stable-name shim is written at
-	*  the bundle's end: `entry_shims`). */
+	/** One hydrate island's entry, content-hashed by the bundler (the location maps that name it are
+	*  written at the bundle's end: `location_maps`). */
 	emit_island_entry(emitFile, rid, virtualPath) {
 		this.program.emitted_island_chunks.add(rid);
 		this.island_entry_refs.set(rid, emitFile({
@@ -727,28 +751,17 @@ var Compiler = class {
 		return `${this.#ctx.app_dir}/immutable/[name].[hash].js`;
 	}
 	/**
-	* The stable-name shims (link/entry-shim.ts), for the bundle's end (the names are final): one per
-	* island entry, plus the runtime's — each a plain file at the old stable name re-exporting the
-	* hashed file. `get_file_name` is the bundler's `this.getFileName`.
+	* The build's location maps (link/location-map.ts), for the bundle's end (the names are final):
+	* every island entry's identity → its hashed file, content-hashed and at the one fixed name.
+	* `get_file_name` is the bundler's `this.getFileName`. Empty with no island.
 	*/
-	entry_shims(get_file_name) {
+	location_maps(get_file_name) {
 		const ctx = this.#ctx;
-		const out = [];
-		for (const [rid, ref] of this.island_entry_refs) {
-			const fileName = ctx.island_chunk_filename(rid);
-			out.push({
-				fileName,
-				source: island_shim_source(fileName, get_file_name(ref))
-			});
-		}
-		if (this.runtime_entry_ref) {
-			const fileName = this.runtime_chunk_filename();
-			out.push({
-				fileName,
-				source: runtime_shim_source(fileName, get_file_name(this.runtime_entry_ref))
-			});
-		}
-		return out;
+		const pairs = [];
+		for (const [rid, ref] of this.island_entry_refs) pairs.push([ctx.island_chunk_filename(rid), get_file_name(ref)]);
+		const files = location_map_files(ctx.app_dir, pairs, (source) => createHash("sha256").update(source).digest("hex").slice(0, 12));
+		this.location_map_url = files.length ? "/" + files[0].fileName : null;
+		return files;
 	}
 	/**
 	* Emit one ogygia VIRTUAL module's source: the config/capability virtuals (secret / sign / rate-limit
@@ -782,6 +795,11 @@ var Compiler = class {
 			const ch = client_hooks_boot(ctx);
 			return ch.imports + code + ch.call;
 		}
+		if (id === RESOLVED("virtual:ogygia/runtime-flags")) {
+			if (!ctx.is_build) return generateRuntimeFlagsSource({}, true);
+			this.prescan();
+			return generateRuntimeFlagsSource(program.runtime_marks);
+		}
 		if (id === RESOLVED("virtual:ogygia/hydrate-features")) {
 			if (!ctx.is_build) {
 				const rt = dev_runtime_of(ctx.runtime_dir);
@@ -789,7 +807,8 @@ var Compiler = class {
 				return rt?.ts ? code.split(".js\";").join(".ts\";") : code;
 			}
 			this.prescan();
-			return `import ${JSON.stringify(V_FN_MANIFEST)};\n` + generateHydrateFeaturesSource(program.runtime_marks, ctx.runtime_dir).code;
+			const marks = program.runtime_marks;
+			return (marks.wire === true || marks.context === true || program.crosses_wire ? `import ${JSON.stringify(V_FN_MANIFEST)};\n` : "") + generateHydrateFeaturesSource(marks, ctx.runtime_dir).code;
 		}
 		if (id === RESOLVED("virtual:ogygia-runtime")) {
 			const ch = client_hooks_boot(ctx);
@@ -901,6 +920,7 @@ var Compiler = class {
 		if (source === "virtual:ogygia-runtime") return RESOLVED(V_RUNTIME);
 		if (source === "virtual:ogygia/runtime-entry") return RESOLVED(V_RUNTIME_ENTRY);
 		if (source === "virtual:ogygia/hydrate-features") return RESOLVED(V_HYDRATE_FEATURES);
+		if (source === "virtual:ogygia/runtime-flags") return RESOLVED(V_RUNTIME_FLAGS);
 		if (source === "virtual:ogygia/dev-hmr") return RESOLVED(V_DEV_HMR);
 		if (source === "virtual:ogygia/dev-hmr-url") return RESOLVED(V_DEV_HMR_URL);
 		if (source === "virtual:ogygia/devtools-boot") return RESOLVED(V_DEVTOOLS_BOOT);
@@ -924,6 +944,7 @@ var Compiler = class {
 		if (source === "virtual:ogygia/request-event") return RESOLVED(V_REQUEST_EVENT);
 		if (source === "virtual:ogygia/region-endpoint") return RESOLVED(V_REGION_ENDPOINT);
 		if (source === "virtual:ogygia/client-binding-stub") return ctx.client_binding_stub_file;
+		if (!ssr && ctx.is_build && importer && (source.startsWith(REGION_BINDING_PREFIX) || source.startsWith(WRAPPER_PREFIX)) && this.#links_client_stub(importer)) return ctx.client_binding_stub_file;
 		if (source.startsWith("virtual:ogygia/fouc-css/") || source.startsWith("virtual:ogygia/fouc-scoped/")) return RESOLVED(source);
 		if (source === "virtual:ogygia/transport") return RESOLVED(V_TRANSPORT);
 		if (source === "virtual:ogygia/transportables") return RESOLVED(V_TRANSPORTABLES);
@@ -993,11 +1014,24 @@ var Compiler = class {
 	}
 	/** True for a csr=false route host file (`+page`/`+layout` `.svelte`/`.ts`/`.js`). A `+page.ts`
 	*  shares its route's world with the sibling `.svelte` host. */
+	/** A route COMPONENT whose client leg links the binding stub — `transform`'s `link_virtual` rule,
+	*  for a host that could not apply it itself: csr=false, and not a layout of an app with a
+	*  csr=true route (Kit can hydrate that layout: a csr=true child page, or an error render). */
+	#links_client_stub(importer) {
+		const importer_abs = strip_id(importer);
+		const routes_dir = kit_dirs(this.#ctx.root).routes_dir;
+		if (!importer_abs.startsWith(routes_dir + path.sep)) return false;
+		const base = path.basename(importer_abs);
+		if (is_route_component(base, "layout")) return routeCsrIsFalse(importer_abs, routes_dir) && !hasAnyCsrTrueRoute(routes_dir);
+		return is_route_component(base, "page") && routeCsrIsFalse(importer_abs, routes_dir);
+	}
 	#is_csr_false_route_host(importer) {
 		const importer_abs = strip_id(importer);
 		const routes_dir = kit_dirs(this.#ctx.root).routes_dir;
 		if (!importer_abs.startsWith(routes_dir + path.sep)) return false;
-		const m = ROUTE_HOST_FILE_RE.exec(path.basename(importer_abs));
+		const base = path.basename(importer_abs);
+		if (is_route_component(base, "page") || is_route_component(base, "layout")) return routeCsrIsFalse(importer_abs, routes_dir);
+		const m = ROUTE_HOST_FILE_RE.exec(base);
 		if (!m) return false;
 		return routeCsrIsFalse(path.join(importer_abs, "..", `+${m[1]}.svelte`), routes_dir);
 	}

package/dist/compiler/ids.d.ts

@@ -10,6 +10,9 @@ export declare const V_RUNTIME = "virtual:ogygia-runtime";
 export declare const V_RUNTIME_ENTRY = "virtual:ogygia/runtime-entry";
 /** Generated hydrate-phase feature module — imported statically by the hydrate core (link/runtime-entry.ts). */
 export declare const V_HYDRATE_FEATURES = "virtual:ogygia/hydrate-features";
+/** Generated build-time constants for code the always-on core gates in place (link/runtime-entry.ts
+ *  `generateRuntimeFlagsSource`): the bundler inlines them and drops what they switch off. */
+export declare const V_RUNTIME_FLAGS = "virtual:ogygia/runtime-flags";
 export declare const V_DEV_HMR = "virtual:ogygia/dev-hmr";
 export declare const V_DEV_HMR_URL = "virtual:ogygia/dev-hmr-url";
 export declare const V_DEVTOOLS_BOOT = "virtual:ogygia/devtools-boot";

package/dist/compiler/ids.js

@@ -11,6 +11,9 @@ const V_RUNTIME = "virtual:ogygia-runtime";
 const V_RUNTIME_ENTRY = "virtual:ogygia/runtime-entry";
 /** Generated hydrate-phase feature module — imported statically by the hydrate core (link/runtime-entry.ts). */
 const V_HYDRATE_FEATURES = "virtual:ogygia/hydrate-features";
+/** Generated build-time constants for code the always-on core gates in place (link/runtime-entry.ts
+*  `generateRuntimeFlagsSource`): the bundler inlines them and drops what they switch off. */
+const V_RUNTIME_FLAGS = "virtual:ogygia/runtime-flags";
 const V_DEV_HMR = "virtual:ogygia/dev-hmr";
 const V_DEV_HMR_URL = "virtual:ogygia/dev-hmr-url";
 const V_DEVTOOLS_BOOT = "virtual:ogygia/devtools-boot";
@@ -83,4 +86,4 @@ const regionBindingVirtualId = (iid) => `virtual:ogygia/region/${iid}.js`;
 * applies one level up: what a page ships is decided by what it RENDERED, never by its import graph.
 */
 const lazyEntryVirtualId = (iid) => `virtual:ogygia/lazy/${iid}.js`;
-export { PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, RESOLVED, V_DEVTOOLS_BOOT, V_DEVTOOLS_BOOT_URL, V_DEVTOOLS_META, V_DEV_HMR, V_DEV_HMR_URL, V_FN_MANIFEST, V_HYDRATE_FEATURES, V_ISLAND_DEPS, V_KIT_TRANSPORT, V_KIT_WIRE, V_MANIFEST, V_PROFILER_MAPS, V_RATE_LIMIT, V_REGION_ENDPOINT, V_REGION_TTL, V_REQUEST_EVENT, V_ROUTER_CONFIG, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_RUNTIME, V_RUNTIME_ENTRY, V_RUNTIME_URL, V_SECRET, V_SERVER_ISLANDS, V_SERVER_MANIFEST, V_SERVER_PLUGINS, V_SESSION_COOKIE, V_SIGN, V_TRANSPORT, V_TRANSPORTABLES, V_TRANSPORTABLES_EAGER, islandVirtualId, lazyEntryVirtualId, regionBindingVirtualId };
+export { PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, RESOLVED, V_DEVTOOLS_BOOT, V_DEVTOOLS_BOOT_URL, V_DEVTOOLS_META, V_DEV_HMR, V_DEV_HMR_URL, V_FN_MANIFEST, V_HYDRATE_FEATURES, V_ISLAND_DEPS, V_KIT_TRANSPORT, V_KIT_WIRE, V_MANIFEST, V_PROFILER_MAPS, V_RATE_LIMIT, V_REGION_ENDPOINT, V_REGION_TTL, V_REQUEST_EVENT, V_ROUTER_CONFIG, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_RUNTIME, V_RUNTIME_ENTRY, V_RUNTIME_FLAGS, V_RUNTIME_URL, V_SECRET, V_SERVER_ISLANDS, V_SERVER_MANIFEST, V_SERVER_PLUGINS, V_SESSION_COOKIE, V_SIGN, V_TRANSPORT, V_TRANSPORTABLES, V_TRANSPORTABLES_EAGER, islandVirtualId, lazyEntryVirtualId, regionBindingVirtualId };