@skgo/sveltekit-adapter 0.31.0 → 0.32.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@skgo/sveltekit-adapter",
-	"version": "0.31.0",
+	"version": "0.32.1",
 	"description": "SvelteKit adapter for skgo: builds a frontend that a Go binary renders and answers",
 	"keywords": [
 		"adapter",

package/skgo-adapter/entry.js

@@ -23,7 +23,7 @@ import {
 import { HandledHttpError } from '@sveltejs/kit/internal';
 import * as devalue from 'skgo:devalue';
 import { decoders, init_transport, parse } from 'skgo:kit/transport';
-import { components, universalLoads } from 'skgo:nodes';
+import { componentLoaders, universalLoaders } from 'skgo:nodes';
 import { transport } from 'skgo:hooks';
 import { serialize_data } from 'skgo:kit/serialize-data';
 import { create_universal_fetch } from 'skgo:kit/load-data';
@@ -227,13 +227,18 @@ async function build_props(req, url, event, state, fetched, serialized) {
 	};
 
 	const branch = req.branch ?? [];
-	const error_components = (req.error_components ?? []).map((i) =>
-		i == null ? undefined : components[i]
-	);
+	const error_components = await Promise.all((req.error_components ?? []).map(async (i) => {
+		try {
+			return i == null ? undefined : await componentLoaders[i]?.();
+		} catch {
+			// Kit skips error components that cannot load (runtime/error-chain.js).
+			return undefined;
+		}
+	}));
 
 	const props = new Props({
 		page,
-		tree: new RenderNode(components[branch[0].node], undefined),
+		tree: new RenderNode(await componentLoaders[branch[0].node]?.(), undefined),
 		form,
 		error: req.error ?? undefined
 	});
@@ -243,7 +248,7 @@ async function build_props(req, url, event, state, fetched, serialized) {
 
 	for (let i = 0; i < branch.length; i += 1) {
 		const server_data = node_data(branch[i]);
-		const load = universalLoads[branch[i].node];
+		const load = await universalLoaders[branch[i].node]?.();
 		const parent_data = data;
 		const result = load
 			? await with_request_store({ event, state }, () =>
@@ -270,7 +275,7 @@ async function build_props(req, url, event, state, fetched, serialized) {
 
 		if (i < branch.length - 1) {
 			current_node = current_node.child = new RenderNode(
-				components[branch[i + 1].node],
+				await componentLoaders[branch[i + 1].node]?.(),
 				error_components[i + 1]
 			);
 		}

package/skgo-adapter/env-private.js

@@ -11,6 +11,7 @@ export function protectEnvironmentFiles({ root, kitOut, output, base = '/', toke
 	const files = [
 		resolve(root, '.svelte-kit/skgo-env-values.js'),
 		resolve(root, '.svelte-kit/skgo-env-runtime.json'),
+		resolve(root, '.svelte-kit/skgo-dev-supervisor.json'),
 		resolve(root, kitOut, 'generated/build/env/config.js'),
 		resolve(root, kitOut, 'generated/dev/env/config.js'),
 		resolve(root, output, 'env.json')

package/skgo-adapter/env.js

@@ -29,7 +29,7 @@ import { execFileSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { protectEnvironmentFiles } from './env-private.js';
 import { existsSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { dirname, isAbsolute, join, posix as posixPath, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 /**
@@ -460,7 +460,7 @@ export function nodeTable(root, nodes) {
 	nodes.forEach((node, i) => {
 		if (node.universal) {
 			imports.push(`import * as U${i} from ${JSON.stringify(join(root, node.universal))};`);
-			loads.push(`U${i}.load`);
+			loads.push(`() => U${i}.load`);
 		} else {
 			loads.push('undefined');
 		}
@@ -469,9 +469,9 @@ export function nodeTable(root, nodes) {
 			return;
 		}
 		imports.push(`import N${i} from ${JSON.stringify(join(root, node.component))};`);
-		table.push(`N${i}`);
+		table.push(`() => N${i}`);
 	});
-	return `${imports.join('\n')}\nexport const components = [${table.join(', ')}];\nexport const universalLoads = [${loads.join(', ')}];\n`;
+	return `${imports.join('\n')}\nexport const componentLoaders = [${table.join(', ')}];\nexport const universalLoaders = [${loads.join(', ')}];\n`;
 }
 
 /**
@@ -613,26 +613,21 @@ function posix(p) {
  */
 function devNodeTable(manifest, root) {
 	if (!manifest) throw new Error('skgo: the live Kit manifest is not ready');
-	/** @type {string[]} */
-	const imports = [];
-	/** @type {string[]} */
-	const table = [];
+	const components = [];
 	const loads = [];
-	for (const [index, node] of manifest.nodes.entries()) {
-		if (node.universal) {
-			imports.push(`import * as U${index} from ${JSON.stringify(resolve(root, node.universal))};`);
-			loads.push(`U${index}.load`);
-		} else {
-			loads.push('undefined');
-		}
-		if (!node.component) {
-			table.push('undefined');
-			continue;
-		}
-		imports.push(`import N${index} from ${JSON.stringify(resolve(root, node.component))};`);
-		table.push(`N${index}`);
+	for (const node of manifest.nodes) {
+		// Kit's dev manifest supplies lazy component functions and resolves
+		// universal modules only when that node belongs to the requested page
+		// (exports/vite/dev/generate_manifest.js). Keep imports behind calls so
+		// bringing up the renderer cannot evaluate unrelated route modules.
+		components.push(node.component
+			? `() => import(${JSON.stringify(resolve(root, node.component))}).then(m => m.default)`
+			: 'undefined');
+		loads.push(node.universal
+			? `() => import(${JSON.stringify(resolve(root, node.universal))}).then(m => m.load)`
+			: 'undefined');
 	}
-	return `${imports.join('\n')}\nexport const components = [${table.join(', ')}];\nexport const universalLoads = [${loads.join(', ')}];\n`;
+	return `export const componentLoaders = [${components.join(', ')}];\nexport const universalLoaders = [${loads.join(', ')}];\n`;
 }
 
 /**
@@ -1268,6 +1263,55 @@ function errorText(e) {
 // Values are validated by Go once before Kit loads its environment declaration.
 // This must be a real file: Kit imports env.ts in a separate Vite server with
 // configFile:false, where this adapter's virtual modules do not exist.
+// The Go supervisor publishes readiness through Vite's existing HMR protocol.
+// This is adapter glue: the browser keeps using Vite's own client and overlay.
+export function goSupervisorReload() {
+	return {
+		name: 'skgo-supervisor-reload',
+		configureServer(server) {
+			const token = randomBytes(32).toString('hex');
+			const file = join(server.config.root, '.svelte-kit/skgo-dev-supervisor.json');
+			// Vite's client imports @vite/env. Import analysis rewrites that to
+			// its installed env.mjs, either under root or through /@fs/. Publish
+			// only this exact bootstrap dependency, never an application prefix.
+			const envFile = app.resolve('vite/dist/client/env.mjs').replaceAll('\\', '/');
+			const root = server.config.root.replaceAll('\\', '/').replace(/\/$/, '');
+			const envURL = envFile.startsWith(root + '/') ? envFile.slice(root.length) : posixPath.join('/@fs/', envFile);
+			const clientFiles = [server.config.base.replace(/\/$/, '') + envURL];
+			mkdirSync(dirname(file), { recursive: true });
+			writeFileSync(file, JSON.stringify({ token, base: server.config.base, clientFiles }), { mode: 0o600 });
+			chmodSync(file, 0o600);
+			let failure;
+			server.ws.on('vite:client:connect', (_, client) => {
+				if (failure) client.send(failure);
+			});
+			server.middlewares.use((req, res, next) => {
+				if ((req.url || '').split('?')[0] !== '/__skgo_dev/supervisor') return next();
+				if (req.method !== 'POST' || req.headers['x-skgo-dev-token'] !== token) {
+					res.statusCode = 403; res.end('Forbidden'); return;
+				}
+				let body = '', size = 0;
+				req.setEncoding('utf8');
+				req.on('data', chunk => {
+					size += Buffer.byteLength(chunk);
+					if (size <= 1048576) body += chunk;
+				});
+				req.on('end', () => {
+					let message;
+					try { message = JSON.parse(body); } catch {}
+					if (size > 1048576 || !message || typeof message.diagnostic !== 'string') {
+						res.statusCode = 400; res.end('Invalid supervisor status'); return;
+					}
+					failure = message.diagnostic ? { type: 'error', err: { message: message.diagnostic, stack: '', plugin: 'skgo' } } : undefined;
+					// Kit also omits path for full-reload: app.html is not the page URL.
+					server.ws.send(failure || { type: 'full-reload' });
+					res.statusCode = 204; res.end();
+				});
+			});
+		}
+	};
+}
+
 export function goEnvironmentValues(output = 'build') {
 	let token = '';
 	let kitOut = '.svelte-kit';

package/skgo-adapter.js

@@ -21,7 +21,7 @@ import {
  remoteEndpoint,
 	remoteLoad
 } from './skgo-adapter/prerender.js';
-import { gojaDevEnvironment, gojaDevUnchangedFiles, gojaEnvironment, goEnvironmentValues, nodeTable, SSR_TARGET } from './skgo-adapter/env.js';
+import { gojaDevEnvironment, gojaDevUnchangedFiles, gojaEnvironment, goEnvironmentValues, goSupervisorReload, nodeTable, SSR_TARGET } from './skgo-adapter/env.js';
 import { prerenderModules } from './skgo-adapter/prerender-modules.js';
 import { identity } from './skgo-adapter/identity.js';
 import { checkEndpoints, validateGenerated } from './skgo-adapter/generated.js';
@@ -116,7 +116,7 @@ export default function skgo({ out = 'build', precompress = true, prerenderPacka
 		// compiles the SSR bundle in is also declared in `vite dev`, where Go
 		// pulls one transformed module at a time out of it instead. Each plugin
 		// states its own `apply`, so only one of them is ever live.
-		vite: { plugins: { pre: [prerenderOwnerPlugin, prerenderModules()], post: [environment.plugin, goja.plugin, gojaDevEnvironment(), gojaDevUnchangedFiles({ out })] } },
+		vite: { plugins: { pre: [prerenderOwnerPlugin, prerenderModules()], post: [environment.plugin, goSupervisorReload(), goja.plugin, gojaDevEnvironment(), gojaDevUnchangedFiles({ out })] } },
 		async adapt(builder) {
 			let failure;
 			try {