@skgo/sveltekit-adapter 0.3.1 → 0.3.3

package/README.md

@@ -9,7 +9,7 @@ the Go process renders pages with, and a manifest naming the routes, remote
 functions and server loads Go must answer.
 
 ```sh
-pnpm add -D @skgo/sveltekit-adapter@0.3.1
+pnpm add -D @skgo/sveltekit-adapter@0.3.3
 ```
 
 Use the same version as the `github.com/tylergannon/skgo` requirement in your

package/package.json

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

package/skgo-adapter/env.js

@@ -61,6 +61,7 @@ async function fromApp(specifier) {
 
 const { rolldown } = await fromApp('vite/rolldown');
 const { transformSync } = await fromApp('vite/rolldown/experimental');
+const { parseAst } = await fromApp('vite/rolldown/parseAst');
 // `fetchModule` operates on the app's own `DevEnvironment`, so it has to be
 // the app's copy for the same reason rolldown is: a second module realm's
 // vite does not recognise this one's environments.
@@ -480,6 +481,7 @@ function engineTransform(code, id, { lowered, helpers } = {}) {
 			'=> Promise.reject(new Error("skgo: no dynamic import in the SSR engine"))'
 		);
 	}
+	out = wrapFieldInitialisers(out, id);
 	if (!UNPARSEABLE.test(out)) {
 		return out === code ? null : { code: out, map: null };
 	}
@@ -495,6 +497,128 @@ function engineTransform(code, id, { lowered, helpers } = {}) {
 	return { code: lower, map: null };
 }
 
+/**
+ * Wraps every class field initialiser that closes over `this` in a plain
+ * function called with the instance, so the initialiser itself only reads
+ * `this` and the closure is made inside an ordinary call.
+ *
+ * goja runs field initialisers with the argument count of whichever function
+ * is executing `new`, and an initialiser that closes over `this` derives its
+ * stack base from that count. Constructed inside a function with parameters —
+ * every component is one — such a class panics the render or throws "Value is
+ * not an Object". Svelte emits exactly that for a class-field `$derived`:
+ * `#graph = derived(() => this.doc.toGraph())`. The engine fix is
+ * dop251/goja#737; once skgo requires a goja carrying it, this goes.
+ *
+ * `(function () { return VALUE; }).call(this)` evaluates VALUE at the same
+ * moment with the same `this` and `new.target`, and an initialiser can hold no
+ * `arguments`, `await` or `yield` for the function to capture instead. An
+ * anonymous function keeps the name the field would have given it by being
+ * defined as a property of that name. `super` cannot move into a plain
+ * function, so an initialiser that reaches it is left alone.
+ *
+ * @param {string} code
+ * @param {string} id
+ */
+function wrapFieldInitialisers(code, id) {
+	const evals = code.includes('eval(');
+	if (!evals && !(code.includes('=>') && /\bthis\b/.test(code))) return code;
+
+	/** @type {Array<{ at: number, text: string, closes: boolean, order: number }>} */
+	const inserts = [];
+	visit(parseAst(code, undefined, id.replace(/\0/g, '_')), (node) => {
+		if (node.type !== 'PropertyDefinition' || !node.value) return;
+		const found = captures(node.value);
+		if (!found.this || found.super) return;
+		const { start, end } = node.value;
+		const order = inserts.length;
+		if (!node.computed && anonymousDefinition(node.value)) {
+			const name = JSON.stringify(node.key.type === 'PrivateIdentifier' ? '#' + node.key.name : String(node.key.name ?? node.key.value));
+			inserts.push({ at: start, text: `(function () { return { ${name}: `, closes: false, order });
+			inserts.push({ at: end, text: ` }[${name}]; }).call(this)`, closes: true, order });
+		} else {
+			inserts.push({ at: start, text: '(function () { return (', closes: false, order });
+			inserts.push({ at: end, text: '); }).call(this)', closes: true, order });
+		}
+	});
+	if (!inserts.length) return code;
+
+	// Fields nest (a class inside an initialiser), so one offset can take several
+	// inserts: whatever closes goes before whatever opens, an inner field closes
+	// before its outer one, and an outer one opens before its inner one. Visit
+	// order is outer first.
+	inserts.sort((a, b) => a.at - b.at || Number(b.closes) - Number(a.closes) || (a.closes ? b.order - a.order : a.order - b.order));
+	let out = '';
+	let from = 0;
+	for (const { at, text } of inserts) {
+		out += code.slice(from, at) + text;
+		from = at;
+	}
+	return out + code.slice(from);
+}
+
+/**
+ * Whether an initialiser closes over `this` — inside an arrow, or through a
+ * direct `eval` — and whether it reaches `super`. Neither crosses an ordinary
+ * function, which has its own of both.
+ *
+ * @param {any} value
+ * @returns {{ this: boolean, super: boolean }}
+ */
+function captures(value) {
+	const found = { this: false, super: false };
+	(function walk(node, arrow) {
+		switch (node.type) {
+			case 'ThisExpression':
+				if (arrow) found.this = true;
+				return;
+			case 'Super':
+				found.super = true;
+				return;
+			case 'FunctionExpression':
+			case 'FunctionDeclaration':
+				return;
+			case 'CallExpression':
+				if (node.callee.type === 'Identifier' && node.callee.name === 'eval') found.this = true;
+				break;
+			case 'ArrowFunctionExpression':
+				arrow = true;
+				break;
+		}
+		for (const child of children(node)) walk(child, arrow);
+	})(value, false);
+	return found;
+}
+
+/** @param {any} node */
+function anonymousDefinition(node) {
+	return (
+		node.type === 'ArrowFunctionExpression' ||
+		((node.type === 'FunctionExpression' || node.type === 'ClassExpression') && !node.id)
+	);
+}
+
+/**
+ * @param {any} node
+ * @param {(node: any) => void} fn
+ */
+function visit(node, fn) {
+	fn(node);
+	for (const child of children(node)) visit(child, fn);
+}
+
+/** @param {any} node */
+function* children(node) {
+	for (const key in node) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item.type === 'string') yield item;
+		} else if (value && typeof value.type === 'string') {
+			yield value;
+		}
+	}
+}
+
 /**
  * Where oxc's lowering helpers live, resolved the way dev has to resolve them:
  * from vite rather than from the app. Under pnpm `@oxc-project/runtime` is a

package/skgo-adapter.js

@@ -104,6 +104,7 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 				},
 				`${out}/ssr/bundle.js`
 			);
+			writeAppManifest(`${out}/ssr/bundle.js`, builder.manifest);
 
 			// Kit's own `builder.compress` writes a `.br` and a `.gz` beside every
 			// file whose extension it compresses, and Go chooses one per request
@@ -114,7 +115,7 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 				await builder.compress(`${out}/prerendered`);
 			}
 
-			// `builder` has no writeJson in kit 3.0.0-next.25 (it existed on the
+			// `builder` has no writeJson in kit 3.0.0-next.27 (it existed on the
 			// kit 2 line); write the manifest ourselves.
 			write(
 				`${out}/skgo.manifest.json`,
@@ -323,11 +324,41 @@ function readPrerendered(builder) {
 }
 
 /**
- * Kit's own server manifest, as an object *and* as text. `generateManifest`
- * returns the source of a module whose only imports sit inside lazy thunks, so
- * importing it resolves nothing and runs no application code — but the source
- * is worth keeping, because the thunks carry information the imported object
- * has already hidden inside closures. See readNodes.
+ * Kit replaces `$app/manifest`'s generated identifiers in its client and
+ * server environments. The Goja renderer is an adapter-owned fourth
+ * environment, so apply the same values after its chunks have been folded into
+ * the one script Go evaluates.
+ *
+ * @param {string} file
+ * @param {typeof import('$app/manifest')} manifest
+ */
+function writeAppManifest(file, manifest) {
+	let source = readFileSync(file, 'utf8');
+	const replacements = {
+		__SVELTEKIT_MANIFEST_ASSETS__: manifest.assets,
+		__SVELTEKIT_MANIFEST_IMMUTABLE__: manifest.immutable,
+		__SVELTEKIT_MANIFEST_PRERENDERED__: manifest.prerendered,
+		__SVELTEKIT_MANIFEST_ROUTES__: manifest.routes
+	};
+	for (const [identifier, value] of Object.entries(replacements)) {
+		source = source.replaceAll(identifier, JSON.stringify(value));
+	}
+	if (source.includes('__SVELTEKIT_MANIFEST_')) {
+		throw new Error(
+			'skgo: the Goja bundle contains a SvelteKit app-manifest value the adapter did not replace'
+		);
+	}
+	writeFileSync(file, source);
+}
+
+/**
+ * Kit's own server manifest, as an object *and* as text. Kit 3 generates a
+ * complete server-instance module instead of returning manifest source. We
+ * remove its eager Server import and constructor and export the manifest it
+ * wrote; every remaining import sits inside a lazy thunk, so importing the
+ * result resolves nothing and runs no application code. The source is worth
+ * keeping because those thunks carry information the imported object has
+ * already hidden inside closures. See readNodes.
  *
  * @param {import('@sveltejs/kit').Builder} builder
  * @returns {Promise<{ manifest: any, source: string }>}
@@ -335,12 +366,44 @@ function readPrerendered(builder) {
 async function readKitManifest(builder) {
 	const dir = builder.getBuildDirectory('skgo');
 	const file = join(dir, 'kit-manifest.js');
-	const source = builder.generateManifest({ relativePath: '.' });
 	mkdirSync(dir, { recursive: true });
-	writeFileSync(file, `export const manifest = ${source};\n`);
+	builder.generateServerInstance(file);
+	let source = readFileSync(file, 'utf8');
+	const original = source;
+	source = source
+		.replace(/^import \{ Server \} from '[^']+';\n/, '')
+		.replace(/^const manifest = /m, 'export const manifest = ')
+		.replace(/\nexport const server = new Server\(manifest\);\n?$/, '\n');
+	if (source === original || !source.includes('export const manifest = ')) {
+		throw new Error(
+			'skgo: kit generated a server instance in an unknown shape; refusing to guess where its manifest is'
+		);
+	}
+	writeFileSync(file, source);
 	try {
 		// The cache buster matters: `vp build` can run twice in one process.
-		return { manifest: (await import(`${pathToFileURL(file).href}?t=${Date.now()}`)).manifest, source };
+		const raw = (await import(`${pathToFileURL(file).href}?t=${Date.now()}`)).manifest;
+		return {
+			// Kit 3.0.0-next.27 made SSRManifest private and flattened its
+			// previous `_` payload. Keep the adapter's consumers on one shape so
+			// their fail-closed checks remain readable while the public generation
+			// API changes underneath them.
+			manifest: raw._
+				? raw
+				: {
+						appDir: raw.app_dir,
+						appPath: raw.app_path,
+						assets: raw.assets,
+						mimeTypes: raw.mime_types,
+						_: {
+							client: raw.client,
+							nodes: raw.nodes,
+							remotes: raw.remotes,
+							routes: raw.routes
+						}
+					},
+			source
+		};
 	} finally {
 		rmSync(file, { force: true });
 	}