gofront 1.2.0 → 1.2.2

package/README.md

@@ -387,16 +387,13 @@ gofront <dir>                    compile all *.go in directory → stdout
 gofront <input> -o out.js        write output to file (prints elapsed compile time e.g. "15ms")
 gofront <input> --check                    type-check only
 gofront <input> --watch                    watch for changes and recompile
-gofront <input> -o out.js --serve          watch + serve with live reload & SPA fallback (default port 3000)
+gofront <input> -o out.js --serve          watch + serve with live reload (default port 3000)
 gofront <input> -o out.js --serve --port 8080  use a custom port
-gofront <input> -o out.js --copy-assets    compile and synchronize static assets from package.json assetCopy
 gofront <input> --source-map               append inline source map (single file or directory; multi-file packages emit per-file mappings)
 gofront <input> --minify                   minify output (built-in minifier)
 gofront <input> --minify --mangle          minify and rename local identifiers
 gofront <file.go> --ast                    dump AST (debug)
 gofront <file.go> --tokens                 dump tokens (debug)
-gofront test [dir] [--dom]                 run unit tests (-v verbose, -run <regex>)
-gofront prep [dir]                         copy static assets and bundle vendor dependencies
 gofront init [dir]                         scaffold a new project
 gofront --version / -v                     print version
 gofront --help / -h                        print this help
@@ -404,89 +401,6 @@ gofront --help / -h                        print this help
 
 ---
 
-## Unit testing (`gofront test`)
-
-GoFront provides native, Go-idiomatic unit testing out of the box:
-
-- Files ending in `*_test.go` are automatically excluded from production builds (`gofront .`, `gofront -o app.js`) and compiled only when running tests.
-- Built-in `testing` standard library package with `*testing.T`.
-- Discover and execute `func TestXxx(t *testing.T)` functions with standard Go-style output.
-
-### Writing a test
-
-```go
-package store
-
-import "testing"
-
-func TestAddTodo(t *testing.T) {
-    store := NewTodoStore()
-    store.Add("Buy milk")
-
-    if store.Count() != 1 {
-        t.Errorf("expected 1 item, got %d", store.Count())
-    }
-}
-```
-
-Subtests and skips are fully supported:
-
-```go
-func TestFilter(t *testing.T) {
-    t.Run("active", func(t *testing.T) {
-        // subtest logic
-    })
-    t.Run("completed", func(t *testing.T) {
-        if testing.Short() {
-            t.Skip("skipping in short mode")
-        }
-    })
-}
-```
-
-### Running tests
-
-```sh
-gofront test                  # run tests in current directory
-gofront test ./src            # run tests in specific directory
-gofront test -v               # verbose output (RUN, PASS/FAIL, logs)
-gofront test -run "Todo"      # run only tests matching regex pattern
-gofront test --dom            # initialize JSDOM for DOM/gom/templ tests
-```
-
----
-
-## Static assets & vendor bundling
-
-GoFront includes native tooling to manage static assets and package external npm dependencies for the browser without requiring external wrappers or complex build tools.
-
-### Asset copying (`assetCopy`)
-
-Specify static assets (fonts, stylesheets, images) in `package.json` (or `gofront.json`):
-
-```json
-{
-  "assetCopy": [
-    { "source": "node_modules/@fontsource/raleway/files", "dest": "app/fonts" },
-    { "source": "node_modules/prismjs/themes", "dest": "app/css/prism-themes" }
-  ]
-}
-```
-
-Run `gofront prep` to copy them, or pass `--copy-assets` to automatically synchronize assets on build.
-
-### Vendor bundling (`gofront prep`)
-
-Package external npm dependencies for the browser:
-
-```sh
-gofront prep
-```
-
-GoFront inspects your `dependencies`, dynamically uses `rolldown` or `esbuild` from your `devDependencies`, and bundles them into an ES module (defaulting to `app/vendor.js` or `vendor.js`).
-
----
-
 ## Multi-file packages
 
 All `.go` files in a directory share the same namespace and are compiled as one unit.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.2.0",
+	"version": "1.2.2",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {

package/src/asset-manager.js

@@ -16,6 +16,7 @@ import {
 	join,
 	relative,
 	resolve,
+	sep,
 } from "node:path";
 
 export function loadAssetConfig(projectDir) {
@@ -58,7 +59,11 @@ function copyAssetEntry(entry, projectRoot) {
 
 	const destPath = resolve(projectRoot, dest);
 	const relDest = relative(projectRoot, destPath);
-	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+	if (
+		relDest === ".." ||
+		relDest.startsWith(`..${sep}`) ||
+		isAbsolute(relDest)
+	) {
 		throw new Error(
 			`gofront: asset destination '${dest}' is outside project directory`,
 		);

package/src/cli-core.js

@@ -74,7 +74,52 @@ export async function handlePrep(targetDir, options = {}) {
 	return { assets, vendor };
 }
 
-export async function handleTest(targetDir, options = {}) {
-	const resolvedTarget = resolve(targetDir);
-	return runTests(resolvedTarget, options);
+export function parsePrepArgs(argv) {
+	const positional = argv.filter((a) => !a.startsWith("-"));
+	return {
+		targetDir: positional[0] ?? ".",
+		vendorConfig: argv.includes("--minify") ? { minify: true } : {},
+	};
+}
+
+export function formatPrepSummary({ assets, vendor }) {
+	const lines = [];
+	if (assets.copied > 0 || assets.skipped > 0) {
+		lines.push(`copied ${assets.copied} assets (${assets.skipped} skipped)`);
+	}
+	if (vendor.bundled?.length > 0) {
+		const dest = Array.isArray(vendor.dest)
+			? vendor.dest.join(", ")
+			: vendor.dest;
+		const min = vendor.minify ? " (minified)" : "";
+		lines.push(
+			`bundled ${vendor.bundled.length} vendor dependencies → ${dest}${min}`,
+		);
+	}
+	return lines;
+}
+
+export function parseTestArgs(argv) {
+	let run = null;
+	const positional = [];
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "-run" || arg === "--run") {
+			run = argv[++i] ?? null;
+		} else if (arg.startsWith("-run=") || arg.startsWith("--run=")) {
+			run = arg.slice(arg.indexOf("=") + 1);
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+	return {
+		targetDir: positional[0] ?? ".",
+		verbose: argv.includes("-v"),
+		dom: argv.includes("--dom"),
+		run,
+	};
+}
+
+export function handleTest(targetDir, options = {}) {
+	return runTests(targetDir, options);
 }

package/src/codegen/index.js

@@ -333,10 +333,23 @@ export class CodeGen {
 		if (fields.length === 0) {
 			this.line("constructor() {}");
 		} else {
-			const params = fields.map((f) => `${f.name} = ${f.zero}`).join(", ");
+			// A field named like a type used in a default (e.g. `Project Project`)
+			// would shadow that class inside the parameter scope, so alias it.
+			const binding = (f) => {
+				const re = new RegExp(`\\b${f.name}\\b`);
+				return fields.some((o) => re.test(o.zero)) ? `${f.name}$` : f.name;
+			};
+			const params = fields
+				.map((f) => {
+					const b = binding(f);
+					return b === f.name
+						? `${f.name} = ${f.zero}`
+						: `${f.name}: ${b} = ${f.zero}`;
+				})
+				.join(", ");
 			this.line(`constructor({ ${params} } = {}) {`);
 			this.indented(() => {
-				for (const f of fields) this.line(`this.${f.name} = ${f.name};`);
+				for (const f of fields) this.line(`this.${f.name} = ${binding(f)};`);
 			});
 			this.line("}");
 		}

package/src/codegen/statements.js

@@ -448,7 +448,10 @@ export const statementGenMethods = {
 	},
 
 	_genRangeIterExpr(iterType, iteree, lhs) {
-		if (this._isMapRangeType(iterType)) return `Object.entries(${iteree})`;
+		if (this._isMapRangeType(iterType)) {
+			if (lhs.length === 1) return `Object.keys(${iteree})`;
+			return `Object.entries(${iteree})`;
+		}
 		if (this._isStringRangeType(iterType)) {
 			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
 			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;

package/src/dev-server.js

@@ -3,7 +3,7 @@
 
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join, resolve } from "node:path";
+import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export const MIME = {
 	".html": "text/html; charset=utf-8",
@@ -22,6 +22,12 @@ export const MIME = {
 // Injected at the bottom of compiled JS in serve mode.
 export const liveReloadClient = `(function(){var es=new EventSource('/_gofront/events');es.addEventListener('reload',function(){location.reload();});})();`;
 
+// True when `target` is `root` itself or a path inside it (no `..` escape).
+function isInsideDir(root, target) {
+	const rel = relative(root, target);
+	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+
 export function handleDevRequest(req, res, serveDir, clients = new Set()) {
 	// SSE endpoint — browser connects here to receive reload events
 	if (req.url === "/_gofront/events") {
@@ -45,9 +51,8 @@ export function handleDevRequest(req, res, serveDir, clients = new Set()) {
 
 	if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
 
-	const resolvedServe = resolve(serveDir);
 	const filePath = resolve(serveDir, `.${urlPath}`);
-	if (!filePath.startsWith(resolvedServe)) {
+	if (!isInsideDir(resolve(serveDir), filePath)) {
 		res.writeHead(403, { "Content-Type": "text/plain" });
 		res.end("Forbidden");
 		return;

package/src/index.js

@@ -22,10 +22,13 @@ import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
 import {
+	formatPrepSummary,
 	handleInit,
 	handlePrep,
 	handleTest,
 	maybeMinify,
+	parsePrepArgs,
+	parseTestArgs,
 	runCompile,
 } from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
@@ -69,29 +72,11 @@ Usage:
 // ── prep / vendor subcommand ──────────────────────────────────
 
 if (args[0] === "prep" || args[0] === "vendor") {
-	const hasMinify = args.includes("--minify");
-	const filteredArgs = args.slice(1).filter((a) => !a.startsWith("--"));
-	const targetArg = filteredArgs[0] ?? ".";
-	const targetDir = resolve(targetArg);
+	const { targetDir, vendorConfig } = parsePrepArgs(args.slice(1));
 	try {
-		const vendorConfig = hasMinify ? { minify: true } : {};
-		const { assets, vendor } = await handlePrep(targetDir, {
-			vendorConfig,
-		});
-		if (assets.copied > 0 || assets.skipped > 0) {
-			console.error(
-				`gofront: copied ${assets.copied} assets (${assets.skipped} skipped)`,
-			);
-		}
-		if (vendor.bundled?.length > 0) {
-			const destStr = Array.isArray(vendor.dest)
-				? vendor.dest.join(", ")
-				: vendor.dest;
-			const minStr = vendor.minify ? " (minified)" : "";
-			console.error(
-				`gofront: bundled ${vendor.bundled.length} vendor dependencies → ${destStr}${minStr}`,
-			);
-		}
+		const result = await handlePrep(resolve(targetDir), { vendorConfig });
+		for (const line of formatPrepSummary(result))
+			console.error(`gofront: ${line}`);
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);
 		process.exit(1);
@@ -121,35 +106,9 @@ if (args[0] === "init") {
 // ── test subcommand ───────────────────────────────────────────
 
 if (args[0] === "test") {
-	const flags = args.slice(1);
-	let targetDir = ".";
-	let runFilter = null;
-	const nonFlagArgs = [];
-	for (let i = 0; i < flags.length; i++) {
-		const arg = flags[i];
-		if (arg === "-run" || arg === "--run") {
-			runFilter = flags[++i] ?? null;
-			continue;
-		}
-		if (arg.startsWith("-run=") || arg.startsWith("--run=")) {
-			runFilter = arg.slice(arg.indexOf("=") + 1);
-			continue;
-		}
-		if (arg.startsWith("-")) continue;
-		nonFlagArgs.push(arg);
-	}
-	if (nonFlagArgs.length > 0) {
-		targetDir = nonFlagArgs[0];
-	}
-	const verbose = flags.includes("-v");
-	const dom = flags.includes("--dom");
-
+	const { targetDir, ...testOptions } = parseTestArgs(args.slice(1));
 	try {
-		const result = await handleTest(targetDir, {
-			verbose,
-			dom,
-			run: runFilter,
-		});
+		const result = await handleTest(targetDir, testOptions);
 		process.exit(result.exitCode);
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);

package/src/minifier.js

@@ -545,10 +545,18 @@ function _applyRenaming(tokens, renameMap) {
 
 function mangle(code) {
 	const tokens = tokenize(code);
-	const nameGen = shortNameGeneratorFn();
-	const renameMap = new Map();
 	const { declaredLocals } = _collectLocalDecls(tokens);
 	_filterRenameCandidates(declaredLocals);
+
+	const occupied = new Set(MANGLE_GLOBALS);
+	for (const tok of tokens) {
+		if (tok.type === "ident" && !declaredLocals.has(tok.value)) {
+			occupied.add(tok.value);
+		}
+	}
+
+	const nameGen = shortNameGeneratorFn(occupied);
+	const renameMap = new Map();
 	for (const name of declaredLocals) renameMap.set(name, nameGen());
 	return _applyRenaming(tokens, renameMap);
 }
@@ -606,23 +614,27 @@ function collectParams(tokens, openIdx, locals) {
 	}
 }
 
-function* shortNameGenerator() {
+function* shortNameGenerator(occupied = new Set()) {
 	const chars = "abcdefghijklmnopqrstuvwxyz";
 	let index = 0;
 	while (true) {
+		let name;
 		if (index < 26) {
-			yield chars[index++];
+			name = chars[index++];
 		} else {
 			const base = index - 26;
-			yield chars[base % 26] + (Math.floor(base / 26) + 1);
+			name = chars[base % 26] + (Math.floor(base / 26) + 1);
 			index++;
 		}
+		if (!occupied.has(name)) {
+			yield name;
+		}
 	}
 }
 
 // Make it callable (not an iterator interface)
-function shortNameGeneratorFn() {
-	const gen = shortNameGenerator();
+function shortNameGeneratorFn(occupied = new Set()) {
+	const gen = shortNameGenerator(occupied);
 	return () => gen.next().value;
 }
 

package/src/test-runner.js

@@ -4,6 +4,7 @@
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { basename, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { compilePackageTests, gwFilesIn } from "./compiler.js";
 
 export function isTestFunc(decl) {
@@ -17,9 +18,12 @@ export function isTestFunc(decl) {
 	return false;
 }
 
+// Only programs from *_test.go files are scanned, matching Go. Programs
+// without a `_filename` (constructed by hand) are treated as test files.
 export function discoverTests(programs) {
 	const testNames = [];
 	for (const p of programs) {
+		if (p._filename && !p._filename.endsWith("_test.go")) continue;
 		for (const d of p.decls) {
 			if (isTestFunc(d) && !testNames.includes(d.name)) {
 				testNames.push(d.name);
@@ -34,11 +38,16 @@ export function generateTestHarness(bundleJs, testNames, options = {}) {
 	const verbose = Boolean(options.verbose);
 	const dom = Boolean(options.dom);
 	const pkgName = options.pkgName ?? "main";
+	// The harness runs from stdin with cwd = project dir, so a bare "jsdom"
+	// import only works if the project has it locally. Use the resolved path.
+	const jsdomSpec = options.jsdomPath
+		? pathToFileURL(options.jsdomPath).href
+		: "jsdom";
 
 	return `
 ${
 	dom
-		? `import { JSDOM } from "jsdom";
+		? `import { JSDOM } from ${JSON.stringify(jsdomSpec)};
 const __dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
   url: "http://localhost/",
   pretendToBeVisual: true,
@@ -92,37 +101,38 @@ async function __runGoFrontSuite() {
 
   let totalFailures = 0;
   let totalSkipped = 0;
-  const suiteStart = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const now = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
+  const suiteStart = now();
 
-  globalThis.__onSubtestStart = (name) => {
-    if (verbose) {
-      console.log("=== RUN   " + name);
+  // Go-style streaming report. In non-verbose mode only failures and skips are
+  // shown, so the "=== RUN" header is emitted late for failures.
+  const report = (t) => {
+    const elapsed = ((now() - t._start) / 1000).toFixed(2);
+    if (t.skipped) {
+      console.log("--- SKIP: " + t._name + " (" + elapsed + "s)");
+      for (const log of t._logs) console.log("    " + log);
+    } else if (t.failed) {
+      if (!verbose) console.log("=== RUN   " + t._name);
+      for (const log of t._logs) console.log("    " + log);
+      console.log("--- FAIL: " + t._name + " (" + elapsed + "s)");
+    } else if (verbose) {
+      for (const log of t._logs) console.log("    " + log);
+      console.log("--- PASS: " + t._name + " (" + elapsed + "s)");
     }
   };
 
-  globalThis.__onSubtestEnd = (subT) => {
-    const elapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - subT._start) / 1000).toFixed(2);
-    if (subT.skipped) {
-      console.log("--- SKIP: " + subT._name + " (" + elapsed + "s)");
-      for (const log of subT._logs) {
-        console.log("    " + log);
-      }
-    } else if (subT.failed) {
-      if (!verbose) {
-        console.log("=== RUN   " + subT._name);
-      }
-      for (const log of subT._logs) {
-        console.log("    " + log);
-      }
-      console.log("--- FAIL: " + subT._name + " (" + elapsed + "s)");
-    } else if (verbose) {
-      for (const log of subT._logs) {
-        console.log("    " + log);
-      }
-      console.log("--- PASS: " + subT._name + " (" + elapsed + "s)");
-    }
+  // FailNow/SkipNow are control flow; anything else is a panic → failure.
+  const recordTestError = (t, e) => {
+    if (e instanceof __GoFront_FailNow || e instanceof __GoFront_SkipNow) return;
+    t.Fail();
+    t.Log("panic: " + (e?.message ?? String(e)));
   };
 
+  globalThis.__onSubtestStart = (name) => {
+    if (verbose) console.log("=== RUN   " + name);
+  };
+  globalThis.__onSubtestEnd = report;
+
   const __testRegistry = {
 ${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ? ${n} : null`).join(",\n")}
   };
@@ -136,54 +146,21 @@ ${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ?
     }
 
     const t = new __GoFront_T(name);
-    if (verbose) {
-      console.log("=== RUN   " + name);
-    }
+    if (verbose) console.log("=== RUN   " + name);
 
     try {
       const res = fn(t);
-      if (res && typeof res.then === "function") {
-        await res;
-      }
+      if (res && typeof res.then === "function") await res;
     } catch (e) {
-      if (e instanceof __GoFront_FailNow) {
-        // expected on FailNow
-      } else if (e instanceof __GoFront_SkipNow) {
-        // expected on SkipNow
-      } else {
-        t.Fail();
-        t.Log("panic: " + (e?.message ?? String(e)));
-      }
+      recordTestError(t, e);
     }
 
-    const elapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - t._start) / 1000).toFixed(2);
-
-    if (t.skipped) {
-      totalSkipped++;
-      console.log("--- SKIP: " + name + " (" + elapsed + "s)");
-      for (const log of t._logs) {
-        console.log("    " + log);
-      }
-    } else if (t.failed) {
-      totalFailures++;
-      if (!verbose) {
-        console.log("=== RUN   " + name);
-      }
-      for (const log of t._logs) {
-        console.log("    " + log);
-      }
-      console.log("--- FAIL: " + name + " (" + elapsed + "s)");
-    } else {
-      if (verbose) {
-        for (const log of t._logs) {
-          console.log("    " + log);
-        }
-        console.log("--- PASS: " + name + " (" + elapsed + "s)");
-      }
-    }
+    if (t.skipped) totalSkipped++;
+    else if (t.failed) totalFailures++;
+    report(t);
   }
 
-  const suiteElapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - suiteStart) / 1000).toFixed(3);
+  const suiteElapsed = ((now() - suiteStart) / 1000).toFixed(3);
 
   if (totalFailures > 0) {
     console.log("FAIL");
@@ -200,6 +177,16 @@ __runGoFrontSuite();
 `;
 }
 
+// Project-local jsdom wins; fall back to the one next to GoFront (global/npx installs).
+export function resolveJsdomPath(projectDir) {
+	for (const from of [join(projectDir, "dummy.js"), import.meta.url]) {
+		try {
+			return createRequire(from).resolve("jsdom");
+		} catch {}
+	}
+	return null;
+}
+
 function validateTestOptions(options, resolvedDir) {
 	if (options.run) {
 		try {
@@ -209,26 +196,16 @@ function validateTestOptions(options, resolvedDir) {
 		}
 	}
 
+	let jsdomPath = null;
 	if (options.dom) {
-		let jsdomFound = false;
-		try {
-			const req = createRequire(join(resolvedDir, "dummy.js"));
-			req.resolve("jsdom");
-			jsdomFound = true;
-		} catch {}
-		if (!jsdomFound) {
-			try {
-				const req = createRequire(import.meta.url);
-				req.resolve("jsdom");
-				jsdomFound = true;
-			} catch {}
-		}
-		if (!jsdomFound) {
+		jsdomPath = resolveJsdomPath(resolvedDir);
+		if (!jsdomPath) {
 			throw new Error(
 				"gofront: --dom requires 'jsdom' to be installed. Run 'npm install --save-dev jsdom' to enable DOM testing.",
 			);
 		}
 	}
+	return { jsdomPath };
 }
 
 function reportEmptyTests(label, reason, options) {
@@ -290,7 +267,7 @@ function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
 
 export async function runTests(targetDir, options = {}) {
 	const resolvedDir = resolve(targetDir);
-	validateTestOptions(options, resolvedDir);
+	const { jsdomPath } = validateTestOptions(options, resolvedDir);
 
 	const allFiles = gwFilesIn(resolvedDir, { includeTests: true });
 	if (allFiles.length === 0) {
@@ -322,14 +299,11 @@ export async function runTests(targetDir, options = {}) {
 		return reportEmptyTests(pkgName, "no tests to run", options);
 	}
 
-	const harnessJs = generateTestHarness(bundleJsClean(js), testNames, {
+	const harnessJs = generateTestHarness(js, testNames, {
 		...options,
 		pkgName,
+		jsdomPath,
 	});
 
 	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);
 }
-
-function bundleJsClean(js) {
-	return js;
-}

package/src/vendor.js

@@ -13,28 +13,17 @@ import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
-export function getExportNames(pkgName) {
+export function getExportNames(pkgName, globals = {}) {
 	const base = pkgName.replace(/^@[^/]+\//, "");
 	const clean = base.replace(/[^a-zA-Z0-9_]/g, "_");
 	const names = new Set([pkgName, base, clean]);
-
-	if (pkgName === "@emailjs/browser") names.add("emailjs");
-	if (pkgName === "fuse.js") {
-		names.add("Fuse");
-		names.add("fuse");
-	}
-	if (pkgName === "prismjs") {
-		names.add("Prism");
-		names.add("prism");
-	}
-	if (pkgName === "marked") {
-		names.add("marked");
-	}
-
+	const extra = globals[pkgName];
+	for (const name of Array.isArray(extra) ? extra : extra ? [extra] : [])
+		names.add(name);
 	return [...names];
 }
 
-export function generateVendorEntry(packages) {
+export function generateVendorEntry(packages, globals = {}) {
 	const imports = [];
 	const assignments = [];
 	const exports = [];
@@ -43,7 +32,7 @@ export function generateVendorEntry(packages) {
 		const id = `_dep_${idx}`;
 		imports.push(`import * as ${id} from ${JSON.stringify(pkg)};`);
 
-		const names = getExportNames(pkg);
+		const names = getExportNames(pkg, globals);
 		for (const name of names) {
 			assignments.push(
 				`    window[${JSON.stringify(name)}] = ${id}.default || ${id};`,
@@ -91,6 +80,27 @@ export function findBundler(projectDir) {
 	return null;
 }
 
+// Normalises `vendor.globals` ({ pkg: string | string[] }) to { pkg: string[] }.
+function normalizeGlobals(raw) {
+	if (raw === undefined || raw === null) return {};
+	if (typeof raw !== "object" || Array.isArray(raw)) {
+		throw new Error(
+			"gofront: vendor.globals must be an object mapping package names to global names",
+		);
+	}
+	const out = {};
+	for (const [pkg, value] of Object.entries(raw)) {
+		const list = Array.isArray(value) ? value : [value];
+		if (list.some((v) => typeof v !== "string")) {
+			throw new Error(
+				`gofront: vendor.globals[${JSON.stringify(pkg)}] must be a string or array of strings`,
+			);
+		}
+		out[pkg] = list;
+	}
+	return out;
+}
+
 export function loadVendorConfig(projectDir) {
 	const pkgPath = join(projectDir, "package.json");
 	let pkg = {};
@@ -114,6 +124,7 @@ export function loadVendorConfig(projectDir) {
 	let dest = null;
 	let packages = dependencies;
 	let minify = false;
+	let globals = {};
 
 	if (typeof vendorConfig === "string") {
 		dest = vendorConfig;
@@ -121,13 +132,14 @@ export function loadVendorConfig(projectDir) {
 		if (vendorConfig.dest) dest = vendorConfig.dest;
 		if (Array.isArray(vendorConfig.packages)) packages = vendorConfig.packages;
 		if (typeof vendorConfig.minify === "boolean") minify = vendorConfig.minify;
+		globals = normalizeGlobals(vendorConfig.globals);
 	}
 
 	if (!dest) {
 		dest = existsSync(join(projectDir, "app")) ? "app/vendor.js" : "vendor.js";
 	}
 
-	return { dest, packages, minify };
+	return { dest, packages, minify, globals };
 }
 
 export function resolveDestinationPaths(projectRoot, dest) {
@@ -201,6 +213,7 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 	const packages = options.packages ?? config.packages;
 	const dest = options.dest ?? config.dest;
 	const minify = options.minify ?? config.minify ?? false;
+	const globals = { ...config.globals, ...normalizeGlobals(options.globals) };
 
 	if (!packages || packages.length === 0) {
 		return {
@@ -247,7 +260,7 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 		};
 	}
 
-	const entryCode = generateVendorEntry(packages);
+	const entryCode = generateVendorEntry(packages, globals);
 	const entryFile = join(
 		projectRoot,
 		`.gofront-vendor-entry-${Date.now()}.mjs`,