@ogygia/core 0.11.5 → 0.12.0

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/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

@@ -9,7 +9,7 @@ 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";
@@ -610,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;
@@ -695,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);
@@ -725,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({
@@ -748,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

package/dist/compiler/index.d.ts

@@ -1,4 +1,4 @@
-import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, ImportKeys, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, ImportKeys, STABLE_NAME_DIR, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
 import { RawParse, set_parser } from "./parse/oxc.js";
 import { CssReachOptions, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, FoucAlias, buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, isFoucCssId, isFoucScopedId, listStaticImports, resolveFoucImportSpec, svelteHasStyle } from "./fouc-css.js";
 import { regionId, regionIdentity, strategyKey } from "./region/identity.js";
@@ -8,4 +8,4 @@ import { Program, host_key, strip_id } from "./program.js";
 import { CompileCtx, CompileCtxInit } from "./ctx.js";
 import { 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 } from "./ids.js";
 import { FLAGS_SPEC, FlagSite, collect_flag_sites, flags_manifest } from "./flags.js";
-export { CLIENT_BINDING_STUB, CompileCtx, type CompileCtxInit, Compiler, CssReachOptions, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, type FlagSite, FoucAlias, ISLAND_DIR, ImportKeys, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, type Profiler, Program, RESOLVED, type RawParse, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };
+export { CLIENT_BINDING_STUB, CompileCtx, type CompileCtxInit, Compiler, CssReachOptions, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, type FlagSite, FoucAlias, ISLAND_DIR, ImportKeys, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, type Profiler, Program, RESOLVED, type RawParse, STABLE_NAME_DIR, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/index.js

@@ -1,4 +1,4 @@
-import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, STABLE_NAME_DIR, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
 import { set_parser } from "./parse/oxc.js";
 import { FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, isFoucCssId, isFoucScopedId, listStaticImports, resolveFoucImportSpec, svelteHasStyle } from "./fouc-css.js";
 import { regionId, regionIdentity, strategyKey } from "./region/identity.js";
@@ -8,4 +8,4 @@ import { Program, host_key, strip_id } from "./program.js";
 import { CompileCtx } from "./ctx.js";
 import { 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 } from "./ids.js";
 import { FLAGS_SPEC, collect_flag_sites, flags_manifest } from "./flags.js";
-export { CLIENT_BINDING_STUB, CompileCtx, Compiler, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, ISLAND_DIR, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, Program, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };
+export { CLIENT_BINDING_STUB, CompileCtx, Compiler, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, ISLAND_DIR, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, Program, RESOLVED, STABLE_NAME_DIR, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/link/caps.js

@@ -1,4 +1,5 @@
 import { csrTrueRouteIds, errorCsrTrueRouteIds, page_route_config, rootLayoutCsrTrue } from "../kit.js";
+import { dedent } from "../dedent.js";
 // src/compiler/link/caps.ts
 /**
 * Capability virtual-module emitters — the leg-split sources for the signed-capability family:
@@ -14,8 +15,14 @@ import { csrTrueRouteIds, errorCsrTrueRouteIds, page_route_config, rootLayoutCsr
 * counts — else this build's key.
 */
 function secret_module(ssr, build_secret, build_had_secret) {
-	if (!ssr) return `export const buildKey = '';\nexport const buildHadSecret = false;`;
-	return `export const buildKey = ${JSON.stringify(build_secret)};\nexport const buildHadSecret = ${build_had_secret};`;
+	if (!ssr) return dedent`
+			export const buildKey = '';
+			export const buildHadSecret = false;
+		`;
+	return dedent`
+		export const buildKey = ${JSON.stringify(build_secret)};
+		export const buildHadSecret = ${build_had_secret};
+	`;
 }
 /**
 * `virtual:ogygia/sign` — same split as secret: SSR mints with node:crypto (re-exports the real
@@ -23,12 +30,37 @@ function secret_module(ssr, build_secret, build_had_secret) {
 * length-prefixed canonical form the runtime compares against.
 */
 function sign_module(ssr, hmac_module) {
-	if (!ssr) return "export function sign(_secret, _message) { return ''; }\nexport function verify(_secret, _message, _sig) { return false; }\nexport function region_mac_message(id, exp, props, session = '', ttl = '', render = '') {\n  const enc = new TextEncoder();\n  const lp = (s) => enc.encode(String(s)).byteLength + ':' + String(s);\n  const v1 = lp(id) + '|' + lp(exp) + '|' + lp(props) + '|' + lp(session) + '|' + lp(ttl);\n  return render === '' ? 'v1|' + v1 : 'v2|' + v1 + '|' + lp(render);\n}\n";
-	return `export { sign, verify, region_mac_message } from ${JSON.stringify(hmac_module)};`;
+	if (!ssr) return dedent`
+			export function sign(_secret, _message) {
+				return '';
+			}
+
+			export function verify(_secret, _message, _sig) {
+				return false;
+			}
+
+			export function region_mac_message(id, exp, props, session = '', ttl = '', render = '') {
+				const enc = new TextEncoder();
+				const lp = (s) => enc.encode(String(s)).byteLength + ':' + String(s);
+				const v1 = lp(id) + '|' + lp(exp) + '|' + lp(props) + '|' + lp(session) + '|' + lp(ttl);
+				return render === '' ? 'v1|' + v1 : 'v2|' + v1 + '|' + lp(render);
+			}
+		`;
+	return dedent`
+		export { sign, verify, region_mac_message } from ${JSON.stringify(hmac_module)};
+	`;
 }
 function server_plugins_module(ssr, realms) {
 	if (!ssr || realms.length === 0) return `export const plugins = [];`;
-	return `${realms.map((r, i) => `import p${i} from ${JSON.stringify(r.module)};`).join("\n")}\nexport const plugins = [\n\t${realms.map((r, i) => `{ name: ${JSON.stringify(r.name)}, options: ${JSON.stringify(r.options)}, server: p${i} }`).join(",\n	")}\n];`;
+	const imports = realms.map((r, i) => `import p${i} from ${JSON.stringify(r.module)};`).join("\n");
+	const list = realms.map((r, i) => `{ name: ${JSON.stringify(r.name)}, options: ${JSON.stringify(r.options)}, server: p${i} }`).join(",\n	");
+	return dedent`
+		${imports}
+
+		export const plugins = [
+			${list}
+		];
+	`;
 }
 /** `virtual:ogygia/route-config` — SERVER only: every Kit page route id → the keys the plugins claim
 *  inside Kit's `config` page option, merged the way Kit merges it (a key no level sets is absent).
@@ -50,15 +82,33 @@ function session_cookie_module(ssr, session_cookie) {
 /** `virtual:ogygia/region-ttl` — SERVER only; the capability expiry window for mint, and how long
 *  after expiry an anonymous capability still renews. */
 function region_ttl_module(ssr, region_ttl, renew_window) {
-	if (!ssr) return `export const regionTtl = 3600;\nexport const renewWindow = 0;`;
-	return `export const regionTtl = ${region_ttl};\nexport const renewWindow = ${renew_window};`;
+	if (!ssr) return dedent`
+			export const regionTtl = 3600;
+			export const renewWindow = 0;
+		`;
+	return dedent`
+		export const regionTtl = ${region_ttl};
+		export const renewWindow = ${renew_window};
+	`;
 }
 /** `virtual:ogygia/route-csr` — SERVER only: the csr=true route ids, so a csr=false layout's islands
 *  degrade to inline when the LEAF page is csr=true (Kit hydrates the whole document). The CLIENT leg
 *  is an empty set — the client reads the identical signal from `kit_hydrates_page()`, and the route
 *  list never ships to the browser. */
 function route_csr_module(ssr, routesDir) {
-	if (!ssr) return "export const csr_true_routes = new Set();\nexport const error_csr_true_routes = new Set();\nexport const root_layout_csr_true = true;";
-	return `export const csr_true_routes = new Set(${JSON.stringify(csrTrueRouteIds(routesDir))});\nexport const error_csr_true_routes = new Set(${JSON.stringify(errorCsrTrueRouteIds(routesDir))});\nexport const root_layout_csr_true = ${rootLayoutCsrTrue(routesDir)};`;
+	if (!ssr) return dedent`
+			export const csr_true_routes = new Set();
+			export const error_csr_true_routes = new Set();
+			export const root_layout_csr_true = true;
+		`;
+	return dedent`
+		export const csr_true_routes = new Set(${JSON.stringify(csrTrueRouteIds(routesDir))});
+
+		// The error-render map beside the page map: Kit renders a route's error page with its LAYOUT
+		// branch only, so a 404 under a csr=false page is hydrated whenever the layouts say so.
+		export const error_csr_true_routes = new Set(${JSON.stringify(errorCsrTrueRouteIds(routesDir))});
+
+		export const root_layout_csr_true = ${rootLayoutCsrTrue(routesDir)};
+	`;
 }
 export { rate_limit_module, region_ttl_module, route_config_module, route_csr_module, secret_module, server_plugins_module, session_cookie_module, sign_module };