cluaupp 1.4.1 → 1.5.1

package/src/flare/parse.ts

@@ -1,6 +1,6 @@
 import type { FlareField, FlareQuery, FlarePacket, FlareSchema, FlareSide, FlareType } from "./types.js";
 
-const TYPES: Record<string, FlareType> = {
+export const FLARE_TYPE_ALIASES: Record<string, FlareType> = {
 	u8: "u8",
 	u16: "u16",
 	u32: "u32",
@@ -28,14 +28,14 @@ const TYPES: Record<string, FlareType> = {
 	Player: "Player",
 };
 
-const IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+export const FLARE_IDENT = "[A-Za-z_][A-Za-z0-9_]*";
 
 function fail(file: string, line: number, message: string): never {
 	throw new Error(`cluaupp flare: ${file}:${line}: ${message}`);
 }
 
 function parseType(raw: string, file: string, line: number): FlareType {
-	const mapped = TYPES[raw];
+	const mapped = FLARE_TYPE_ALIASES[raw];
 	if (!mapped) {
 		fail(file, line, `unknown type '${raw}'`);
 	}
@@ -53,7 +53,7 @@ function parseFields(list: string, file: string, line: number): FlareField[] {
 		if (!piece) {
 			continue;
 		}
-		const match = piece.match(new RegExp(`^(${IDENT})\\s+(${IDENT})$`));
+		const match = piece.match(new RegExp(`^(${FLARE_IDENT})\\s+(${FLARE_IDENT})$`));
 		if (!match) {
 			fail(file, line, `expected 'Type name' in '${piece}'`);
 		}
@@ -76,6 +76,7 @@ function parseSide(raw: string, file: string, line: number): FlareSide {
 export function parseFlare(source: string, filePath: string, defaultName: string): FlareSchema {
 	const file = filePath.replace(/\\/g, "/");
 	let name = defaultName;
+	let version: number | undefined;
 	const packets: FlarePacket[] = [];
 	const queries: FlareQuery[] = [];
 	let packetId = 1;
@@ -89,6 +90,12 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
+		const verStmt = line.match(/^version\s+(\d+)\s*;?$/i);
+		if (verStmt) {
+			version = Number(verStmt[1]);
+			continue;
+		}
+
 		const opt = line.match(/^opt\s+name\s*=\s*(.+)$/i);
 		if (opt) {
 			const value = opt[1].trim().replace(/^["']|["']$/g, "");
@@ -99,9 +106,15 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
+		const optVer = line.match(/^opt\s+version\s*=\s*(\d+)\s*;?$/i);
+		if (optVer) {
+			version = Number(optVer[1]);
+			continue;
+		}
+
 		const packet = line.match(
 			new RegExp(
-				`^packet\\s+(${IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
+				`^packet\\s+(${FLARE_IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
 				"i",
 			),
 		);
@@ -121,7 +134,7 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
-		const query = line.match(new RegExp(`^query\\s+(${IDENT})\\s*\\((.*)\\)\\s*->\\s*(${IDENT})\\s*$`, "i"));
+		const query = line.match(new RegExp(`^query\\s+(${FLARE_IDENT})\\s*\\((.*)\\)\\s*->\\s*(${FLARE_IDENT})\\s*$`, "i"));
 		if (query) {
 			if (queryId > 255) {
 				fail(file, lineNo, "too many queries (max 255)");
@@ -143,5 +156,5 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 		fail(file, 1, "schema is empty — add a packet or query");
 	}
 
-	return { name, sourcePath: file, packets, queries };
+	return { name, sourcePath: file, version, packets, queries };
 }

package/src/flare/types.ts

@@ -48,6 +48,8 @@ export type FlareQuery = {
 export type FlareSchema = {
 	name: string;
 	sourcePath: string;
+	/** Optional schema version from `version N;` / `opt version = N`. */
+	version?: number;
 	packets: FlarePacket[];
 	queries: FlareQuery[];
 };

package/src/intellisense.ts

@@ -7,6 +7,7 @@ import type { ProjectConfig } from "./types.js";
 import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
 import { hasClpp } from "./clpp/runner.js";
 import { isSourceFile } from "./clpp/paths.js";
+import { editorBin } from "./editor-install.js";
 
 export type CluauppDiagnostic = {
 	line: number;
@@ -82,17 +83,32 @@ function writeVscode(root: string): void {
 		"*.server.clpp": "clpp",
 		"*.client.clpp": "clpp",
 		"*.plugin.clpp": "clpp",
+		"*.flare": "flare",
+		"*.hive": "hive",
+		"*.mint": "mint",
+		"*.bloom": "bloom",
+		"*.helm": "helm",
+		"*.shift": "shift",
+		"*.axiom": "axiom",
 	};
 	writeJson(settingsPath, {
 		...current,
 		"files.associations": associations,
+		"[luau]": {
+			...((current["[luau]"] && typeof current["[luau]"] === "object" && !Array.isArray(current["[luau]"]))
+				? (current["[luau]"] as Record<string, unknown>)
+				: {}),
+			"editor.insertSpaces": false,
+			"editor.tabSize": 4,
+			"editor.detectIndentation": false,
+		},
 	});
 
 	const extensionsPath = path.join(root, ".vscode", "extensions.json");
 	const extensions = readJsonObject(extensionsPath);
 	writeJson(extensionsPath, {
 		...extensions,
-		recommendations: uniqueStrings(extensions.recommendations),
+		recommendations: uniqueStrings(extensions.recommendations, ["kartzdev.cluaupp-flare"]),
 		unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
 	});
 }
@@ -103,8 +119,32 @@ export function diagnosticsFor(_source?: string, _fileName?: string): CluauppDia
 	return [];
 }
 
+function writeStylua(root: string): void {
+	const dest = path.join(root, "stylua.toml");
+	const body = `# cluaupp roblox luau
+syntax = "Luau"
+column_width = 120
+line_endings = "Unix"
+indent_type = "Tabs"
+indent_width = 4
+quote_style = "AutoPreferDouble"
+call_parentheses = "Always"
+collapse_simple_statement = "Never"
+`;
+	if (fs.existsSync(dest)) {
+		const existing = fs.readFileSync(dest, "utf8");
+		if (!existing.includes("cluaupp roblox luau") && existing.trim() !== "") {
+			return;
+		}
+	}
+	if (!fs.existsSync(dest) || fs.readFileSync(dest, "utf8") !== body) {
+		fs.writeFileSync(dest, body, "utf8");
+	}
+}
+
 export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {
 	writeVscode(root);
+	writeStylua(root);
 }
 
 export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
@@ -112,7 +152,7 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 	if (!fs.existsSync(from)) {
 		return [];
 	}
-	const id = `kartzdev.cluaupp-diagnostics-${pkg.version}`;
+	const id = `kartzdev.cluaupp-flare-${pkg.version}`;
 	const homes = [path.join(os.homedir(), ".cursor", "extensions"), path.join(os.homedir(), ".vscode", "extensions")];
 	const installed: string[] = [];
 	for (const home of homes) {
@@ -120,16 +160,50 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 			continue;
 		}
 		fs.mkdirSync(home, { recursive: true });
+		try {
+			for (const name of fs.readdirSync(home)) {
+				if (name.startsWith("kartzdev.cluaupp-flare-") && name !== id) {
+					fs.rmSync(path.join(home, name), { recursive: true, force: true });
+				}
+			}
+		} catch {
+			// ignore prune errors
+		}
 		const dest = path.join(home, id);
 		copyDir(from, dest);
 		fs.writeFileSync(path.join(dest, "cluaupp.root"), path.resolve(cluauppRoot), "utf8");
+		const manifestPath = path.join(dest, "package.json");
+		if (fs.existsSync(manifestPath)) {
+			try {
+				const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as Record<string, unknown>;
+				manifest.version = pkg.version;
+				fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, "\t")}\n`, "utf8");
+			} catch {
+				// keep the copied manifest
+			}
+		}
 		installed.push(dest);
 	}
+
+	const bin = editorBin();
+	if (bin && installed[0]) {
+		spawnSync(bin, ["--install-extension", installed[0], "--force"], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 120000,
+		});
+	}
 	return installed;
 }
 
 export async function installEditorSupport() {
 	const local = installEditorExtension();
+	if (local.length > 0) {
+		console.log("cluaupp: schema IntelliSense installed (.flare .hive .mint .bloom .helm .shift .axiom)");
+		for (const dest of local) {
+			console.log(" ", dest);
+		}
+	}
 	if (hasClpp()) {
 		const result = spawnSync("clpp", ["install"], { encoding: "utf8", windowsHide: true });
 		if (result.status === 0) {

package/src/lsp.ts

@@ -1,30 +1,173 @@
 import {
-	createConnection,
+	CompletionItemKind,
+	DiagnosticSeverity,
+	MarkupKind,
+	ParameterInformation,
 	ProposedFeatures,
+	SignatureInformation,
+	SymbolKind,
 	TextDocuments,
 	TextDocumentSyncKind,
+	createConnection,
+	type CompletionItem,
+	type Diagnostic,
+	type DocumentSymbol,
+	type Hover,
+	type SignatureHelp,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import {
+	completionsAt,
+	hoverAt,
+	isFlareDocument,
+	signatureAt,
+	symbolsIn,
+	diagnoseFlare,
+	type FlareCompletionKind,
+	type FlareSeverity,
+} from "./flare/language.js";
 import { pkg } from "./package-info.js";
 
+const KIND: Record<FlareCompletionKind, CompletionItemKind> = {
+	keyword: CompletionItemKind.Keyword,
+	type: CompletionItemKind.TypeParameter,
+	snippet: CompletionItemKind.Snippet,
+	value: CompletionItemKind.EnumMember,
+	field: CompletionItemKind.Field,
+};
+
+const SEVERITY: Record<FlareSeverity, DiagnosticSeverity> = {
+	error: DiagnosticSeverity.Error,
+	warning: DiagnosticSeverity.Warning,
+	hint: DiagnosticSeverity.Hint,
+};
+
+const SYMBOL: Record<"packet" | "query" | "option", SymbolKind> = {
+	packet: SymbolKind.Event,
+	query: SymbolKind.Method,
+	option: SymbolKind.Namespace,
+};
+
+function flareDiagnostics(document: TextDocument): Diagnostic[] {
+	return diagnoseFlare(document.getText(), document.uri).map((item) => ({
+		range: {
+			start: { line: item.line, character: item.start },
+			end: { line: item.line, character: Math.max(item.end, item.start + 1) },
+		},
+		message: item.message,
+		severity: SEVERITY[item.severity],
+		source: "flare",
+	}));
+}
+
 export function start(_options: { projectRoot?: string } = {}): void {
 	const connection = createConnection(ProposedFeatures.all);
 	const documents = new TextDocuments(TextDocument);
 
 	connection.onInitialize(() => ({
 		capabilities: {
-			textDocumentSync: TextDocumentSyncKind.Full,
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			completionProvider: {
+				triggerCharacters: [" ", "(", ",", ">", "="],
+				resolveProvider: false,
+			},
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			signatureHelpProvider: {
+				triggerCharacters: ["(", ","],
+			},
 		},
-		serverInfo: { name: "cluaupp", version: pkg.version },
+		serverInfo: { name: "cluaupp-flare", version: pkg.version },
 	}));
 
-	const clear = (uri: string) => {
-		connection.sendDiagnostics({ uri, diagnostics: [] });
+	const publish = (document: TextDocument) => {
+		if (!isFlareDocument(document.uri)) {
+			connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
+			return;
+		}
+		connection.sendDiagnostics({ uri: document.uri, diagnostics: flareDiagnostics(document) });
 	};
 
-	documents.onDidOpen((event) => clear(event.document.uri));
-	documents.onDidChangeContent((event) => clear(event.document.uri));
-	documents.onDidClose((event) => clear(event.document.uri));
+	documents.onDidOpen((event) => publish(event.document));
+	documents.onDidChangeContent((event) => publish(event.document));
+	documents.onDidClose((event) => {
+		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+	});
+
+	connection.onCompletion((params): CompletionItem[] => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return [];
+		}
+		return completionsAt(document.getText(), params.position.line, params.position.character).map((item) => ({
+			label: item.label,
+			kind: KIND[item.kind],
+			detail: item.detail,
+			documentation: { kind: MarkupKind.Markdown, value: item.documentation },
+			insertText: item.insertText,
+			insertTextFormat: item.snippet ? 2 : 1,
+			sortText: item.sortText,
+		}));
+	});
+
+	connection.onHover((params): Hover | null => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return null;
+		}
+		const hover = hoverAt(document.getText(), params.position.line, params.position.character);
+		if (!hover) {
+			return null;
+		}
+		return {
+			contents: { kind: MarkupKind.Markdown, value: hover.contents },
+			range: {
+				start: { line: params.position.line, character: hover.start },
+				end: { line: params.position.line, character: hover.end },
+			},
+		};
+	});
+
+	connection.onDocumentSymbol((params): DocumentSymbol[] => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return [];
+		}
+		return symbolsIn(document.getText()).map((symbol) => ({
+			name: symbol.name,
+			detail: symbol.detail,
+			kind: SYMBOL[symbol.kind],
+			range: {
+				start: { line: symbol.line, character: 0 },
+				end: { line: symbol.line, character: Math.max(symbol.end, 1) },
+			},
+			selectionRange: {
+				start: { line: symbol.line, character: symbol.start },
+				end: { line: symbol.line, character: Math.max(symbol.end, symbol.start + 1) },
+			},
+		}));
+	});
+
+	connection.onSignatureHelp((params): SignatureHelp | null => {
+		const document = documents.get(params.textDocument.uri);
+		if (!document || !isFlareDocument(document.uri)) {
+			return null;
+		}
+		const signature = signatureAt(document.getText(), params.position.line, params.position.character);
+		if (!signature) {
+			return null;
+		}
+		const info = SignatureInformation.create(
+			signature.label,
+			signature.documentation,
+			...signature.parameters.map((parameter) => ParameterInformation.create(parameter.label, parameter.documentation)),
+		);
+		return {
+			signatures: [info],
+			activeSignature: 0,
+			activeParameter: signature.activeParameter,
+		};
+	});
 
 	documents.listen(connection);
 	connection.listen();

package/src/native/index.ts

@@ -280,15 +280,14 @@ function compileHelm(source: string, file: string, defaultName: string): NativeE
 		id += 1;
 	}
 	const { headerRel, luauRel } = emitPaths(file, name);
-	const headerFns = commands
-		.map((cmd) => {
-			const params = cmd.args.map((arg) => `${arg.type === "i32" ? "int" : arg.type} ${arg.name}`).join(", ");
-			return `\tvoid ${cmd.name}(${params});`;
-		})
+	const headerCmds = commands
+		.map((cmd, index) => `\t// command ${cmd.name} permission ${cmd.permission}\n\tconst int ${cmd.name} = ${index + 1};`)
 		.join("\n");
 	const header = `${headerBanner("helm")}
+#include <clpp/libs/helm.clh>
 namespace ${name} {
-${headerFns}
+${headerCmds}
+	HelmSession Open(Player player);
 }
 `;
 	const rows = commands
@@ -417,7 +416,7 @@ function compileHive(source: string, file: string, defaultName: string): NativeE
 #include <clpp/libs/hive.clh>
 namespace ${name} {
 ${components.map((item, index) => `\tconst int ${item.name} = ${index + 1};`).join("\n")}
-	HiveWorld New();
+	auto New();
 }
 `;
 	const rows = components
@@ -443,32 +442,242 @@ return ${name}
 	return { headerRel, headerPath: headerRel, header, luauRel, luau };
 }
 
+/** Mirrors Axiom.Groups + axiom.clh prototypes for IntelliSense on selected namespaces. */
+const AXIOM_GROUP_DECLS: Record<string, string[]> = {
+	Scalar: [
+		"double Clamp(double value, double min, double max);",
+		"double Map(double value, double inMin, double inMax, double outMin, double outMax);",
+		"double Wrap(double value, double min, double max);",
+		"double Sign(double value);",
+		"double Round(double value);",
+		"double Round(double value, int digits);",
+		"double Snap(double value, double step);",
+		"double PingPong(double t, double length);",
+		"double Saturate(double value);",
+		"double Fract(double value);",
+		"double InvLerp(double from, double to, double value);",
+		"double Approach(double current, double target, double maxDelta);",
+		"bool IsFinite(double value);",
+		"double Abs(double value);",
+		"double Min(double a, double b);",
+		"double Max(double a, double b);",
+		"double Pow(double base, double exp);",
+		"double Sqrt(double value);",
+		"double Cbrt(double value);",
+		"double Hypot(double a, double b);",
+		"double Log(double value);",
+		"double Exp(double value);",
+		"double Smoothstep(double edge0, double edge1, double x);",
+		"double Smootherstep(double edge0, double edge1, double x);",
+		"double Gcd(double a, double b);",
+		"double Lcm(double a, double b);",
+		"bool IsEven(double value);",
+		"bool IsOdd(double value);",
+		"double Factorial(double n);",
+		"double Scale(double value, int index);",
+	],
+	Lerp: [
+		"double Lerp(double from, double to, double alpha);",
+		"double LerpClamped(double from, double to, double alpha);",
+		"Vector2 LerpVector2(Vector2 from, Vector2 to, double alpha);",
+		"Vector3 LerpVector3(Vector3 from, Vector3 to, double alpha);",
+		"Vector3 LerpVector(Vector3 from, Vector3 to, double alpha);",
+		"Color3 LerpColor3(Color3 from, Color3 to, double alpha);",
+		"CFrame LerpCFrame(CFrame from, CFrame to, double alpha);",
+		"UDim2 LerpUDim2(UDim2 from, UDim2 to, double alpha);",
+		"double LerpAngle(double from, double to, double alpha);",
+		"double Inverse(double from, double to, double value);",
+	],
+	Vector: [
+		"Vector3 Project(Vector3 a, Vector3 b);",
+		"Vector3 Reject(Vector3 a, Vector3 b);",
+		"Vector3 Reflect(Vector3 incident, Vector3 normal);",
+		"double Angle(Vector3 a, Vector3 b);",
+		"double Distance(Vector3 a, Vector3 b);",
+		"double Distance2(Vector2 a, Vector2 b);",
+		"CFrame Orthonormal(Vector3 forward);",
+		"CFrame Orthonormal(Vector3 forward, Vector3 up);",
+		"Vector3 Slerp(Vector3 a, Vector3 b, double t);",
+		"CFrame LookAt(Vector3 from, Vector3 look);",
+	],
+	CFrame: ["CFrame SlerpCFrame(CFrame a, CFrame b, double t);", "CFrame Flat(CFrame cf);"],
+	Easing: [
+		"double InSine(double t);",
+		"double OutSine(double t);",
+		"double InOutSine(double t);",
+		"double InQuad(double t);",
+		"double OutQuad(double t);",
+		"double InOutQuad(double t);",
+		"double InCubic(double t);",
+		"double OutCubic(double t);",
+		"double InOutCubic(double t);",
+		"double InQuart(double t);",
+		"double OutQuart(double t);",
+		"double InOutQuart(double t);",
+		"double InQuint(double t);",
+		"double OutQuint(double t);",
+		"double InOutQuint(double t);",
+		"double InExpo(double t);",
+		"double OutExpo(double t);",
+		"double InOutExpo(double t);",
+		"double InCirc(double t);",
+		"double OutCirc(double t);",
+		"double InOutCirc(double t);",
+		"double InBack(double t);",
+		"double OutBack(double t);",
+		"double InOutBack(double t);",
+		"double InElastic(double t);",
+		"double OutElastic(double t);",
+		"double InOutElastic(double t);",
+		"double InBounce(double t);",
+		"double OutBounce(double t);",
+		"double InOutBounce(double t);",
+		"double Linear(double t);",
+	],
+	Bezier: [
+		"Vector3 CubicBezier(double t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3);",
+		"Vector3 QuadraticBezier(double t, Vector3 p0, Vector3 p1, Vector3 p2);",
+		"CFrame Hover(double elapsed, Vector3 anchor, Vector3 look);",
+		"CFrame Float(double elapsed, Vector3 anchor, Vector3 look);",
+		"CFrame FloatSpin(double elapsed, CFrame anchor);",
+	],
+	Geometry: [
+		"bool AabbContains(Vector3 point, Vector3 min, Vector3 max);",
+		"bool SphereContains(Vector3 point, Vector3 center, double radius);",
+		"Vector3 RayPlane(Vector3 origin, Vector3 dir, Vector3 point, Vector3 normal);",
+		"Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c);",
+		"Vector3 ClosestPointOnSegment(Vector3 p, Vector3 a, Vector3 b);",
+	],
+	Trig: [
+		"double Deg(double rad);",
+		"double Rad(double deg);",
+		"double DeltaAngle(double from, double to);",
+		"double AngleDiff(double from, double to);",
+		"double DeltaAngleDegrees(double from, double to);",
+		"double NormalizeAngle(double angle);",
+		"double Sin(double x);",
+		"double Cos(double x);",
+		"double Tan(double x);",
+		"double Asin(double x);",
+		"double Acos(double x);",
+		"double Atan2(double y, double x);",
+	],
+	Probability: [
+		"double RandomRange(double min, double max);",
+		"double Random(double min, double max);",
+		"int Weighted(LuaArray<double> weights);",
+		"double Gaussian();",
+		"double Gaussian(double mean, double std);",
+		"double Average(LuaArray<double> values);",
+		"double Sum(LuaArray<double> values);",
+	],
+	Noise: [
+		"double HashU32(double n);",
+		"double Value1(double x);",
+		"double Value2(double x, double y);",
+		"double Value3(double x, double y, double z);",
+	],
+	Color: [
+		"Color3 FromHSV(double h, double s, double v);",
+		"Color3 Contrast(Color3 color, double amount);",
+		"Color3 LerpHSV(Color3 a, Color3 b, double t);",
+	],
+};
+
+function axiomFnDecls(): Record<string, string[]> {
+	const byFn: Record<string, string[]> = {};
+	for (const decls of Object.values(AXIOM_GROUP_DECLS)) {
+		for (const decl of decls) {
+			const match = decl.match(/\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+			if (!match) {
+				continue;
+			}
+			const fn = match[1];
+			if (!byFn[fn]) {
+				byFn[fn] = [];
+			}
+			byFn[fn].push(decl);
+		}
+	}
+	return byFn;
+}
+
+const AXIOM_FN_DECLS = axiomFnDecls();
+
+function axiomHeaderBody(groups: string[], fns: string[], file: string, lineNo: number): string {
+	const decls: string[] = [];
+	const seen = new Set<string>();
+	const pushDecl = (decl: string) => {
+		if (seen.has(decl)) {
+			return;
+		}
+		seen.add(decl);
+		decls.push(`\t${decl}`);
+	};
+	for (const group of groups) {
+		const key = Object.keys(AXIOM_GROUP_DECLS).find((name) => name.toLowerCase() === group.toLowerCase());
+		if (!key) {
+			fail(
+				file,
+				lineNo,
+				`unknown group "${group}" — use Scalar Lerp Vector CFrame Easing Bezier Geometry Trig Probability Noise Color`,
+			);
+		}
+		decls.push(`\t// group ${key}`);
+		for (const decl of AXIOM_GROUP_DECLS[key]) {
+			pushDecl(decl);
+		}
+	}
+	for (const fn of fns) {
+		const key = Object.keys(AXIOM_FN_DECLS).find((name) => name.toLowerCase() === fn.toLowerCase());
+		if (!key) {
+			fail(file, lineNo, `unknown fn "${fn}" — use a name from axiom.clh (e.g. fn LerpVector2)`);
+		}
+		decls.push(`\t// fn ${key}`);
+		for (const decl of AXIOM_FN_DECLS[key]) {
+			pushDecl(decl);
+		}
+	}
+	return decls.join("\n");
+}
+
 function compileAxiom(source: string, file: string, defaultName: string): NativeEmit {
 	const { name, lines } = parseOptName(source, file, defaultName);
 	const groups: string[] = [];
+	const fns: string[] = [];
+	let lastLine = 1;
 	for (const tagged of lines) {
 		const [lineNoRaw, line] = tagged.split("\t");
 		const lineNo = Number(lineNoRaw);
-		const match = line.match(new RegExp(`^group\\s+(${IDENT})\\s*$`, "i"));
-		if (!match) {
-			fail(file, lineNo, `expected group Scalar`);
+		lastLine = lineNo;
+		const groupMatch = line.match(new RegExp(`^group\\s+(${IDENT})\\s*$`, "i"));
+		if (groupMatch) {
+			groups.push(groupMatch[1]);
+			continue;
+		}
+		const fnMatch = line.match(new RegExp(`^fn\\s+(${IDENT})\\s*$`, "i"));
+		if (fnMatch) {
+			fns.push(fnMatch[1]);
+			continue;
 		}
-		groups.push(match[1]);
+		fail(file, lineNo, `expected group Lerp or fn LerpVector2`);
 	}
-	if (groups.length === 0) {
-		fail(file, 1, "schema is empty — add group Scalar");
+	if (groups.length === 0 && fns.length === 0) {
+		fail(file, 1, "schema is empty — add group Lerp or fn LerpVector2");
 	}
+	const body = axiomHeaderBody(groups, fns, file, lastLine);
+	const selectArgs = [...groups, ...fns].map((item) => `"${item}"`).join(", ");
 	const { headerRel, luauRel } = emitPaths(file, name);
 	const header = `${headerBanner("axiom")}
 #include <clpp/libs/axiom.clh>
 namespace ${name} {
-${groups.map((group) => `\t// group ${group}`).join("\n")}
+${body}
 }
 `;
 	const luau = `${luauBanner()}local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local Axiom = require(ReplicatedStorage.CluauppLibs.Axiom)
-local ${name} = Axiom.Select({ ${groups.map((group) => `"${group}"`).join(", ")} })
--- out/ only binds groups: ${groups.join(", ")}
+local ${name} = Axiom.Select({ ${selectArgs} })
+-- out/ binds: ${[...groups.map((g) => `group ${g}`), ...fns.map((f) => `fn ${f}`)].join(", ")}
 return ${name}
 `;
 	return { headerRel, headerPath: headerRel, header, luauRel, luau };