cluaupp 1.5.0 → 1.5.1

package/src/cli.ts

@@ -9,9 +9,10 @@ import { clppInstalls, clppManifest, clppVersion, hasClpp, resolveClppBinary } f
 import { installEditorSupport, syncEditorSupport } from "./intellisense.js";
 import { RojoMapper } from "./utils/rojo-mapper.js";
 import { ProcessOrchestrator } from "./utils/process-orchestrator.js";
-import { build as buildProject, init, loadConfig, watch } from "./utils/project.js";
+import { build as buildProject, buildAsync, init, loadConfig, watch } from "./utils/project.js";
 import { transpileSource } from "./transpile.js";
 import type { BuildOptions, BuildResult } from "./types.js";
+import { registerApiCommands, registerTargetCommands, registerPlatformCommands } from "./api-cli.js";
 
 const program = new Command();
 
@@ -45,8 +46,11 @@ program
 	.option("-o, --output <path>", "Luau file or directory")
 	.option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
 	.option("--strict", "Emit --!strict")
-	.option("--format", "Run StyLua on output")
+	.option("--format", "Also run StyLua if it is on PATH")
 	.option("--analyze", "Run luau-analyze on output")
+	.option("--frozen", "Hermetic: fail if API lock / Flare versions / component contracts drift")
+	.option("--no-incremental", "Disable compile cache under .cluaupp/compile-cache")
+	.option("-j, --jobs <n>", "Parallel transpile workers (default: CPU-bounded; env CLUAUPP_JOBS)", (v: string) => Number(v))
 	.action(async (folder: string, options: {
 		input?: string;
 		output?: string;
@@ -54,18 +58,25 @@ program
 		strict?: boolean;
 		format?: boolean;
 		analyze?: boolean;
+		frozen?: boolean;
+		incremental?: boolean;
+		jobs?: number;
 	}) => {
 		if (options.input) {
 			await buildInput(options);
 			return;
 		}
 		try {
-			buildProject(path.resolve(process.cwd(), folder), {
+			const opts = {
 				format: options.format === true,
 				analyze: options.analyze === true,
 				rojo: options.rojo,
 				strict: options.strict === true,
-			});
+				frozen: options.frozen === true,
+				incremental: options.incremental !== false,
+				jobs: Number.isFinite(options.jobs) && (options.jobs as number) > 0 ? options.jobs : undefined,
+			};
+			await buildAsync(path.resolve(process.cwd(), folder), opts);
 		} catch (err) {
 			console.error(err instanceof Error ? err.message : err);
 			process.exit(1);
@@ -77,7 +88,7 @@ program
 	.description("rebuild on save")
 	.argument("[folder]", "project folder", ".")
 	.option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
-	.option("--format", "Run StyLua on output")
+	.option("--format", "Also run StyLua if it is on PATH")
 	.action((folder: string, options: { rojo?: string; format?: boolean }) => {
 		try {
 			watch(path.resolve(process.cwd(), folder), {
@@ -101,7 +112,7 @@ program
 program
 	.command("intellisense")
 	.alias("intelisense")
-	.description("Install Flare IntelliSense and point CL++ at `clpp setup`")
+	.description("Install schema IntelliSense (.flare .hive .mint .bloom .helm .shift .axiom) + sync .vscode; CL++ via clpp install")
 	.argument("[folder]", "project folder", ".")
 	.action(async (folder: string) => {
 		try {
@@ -138,6 +149,10 @@ program
 		}
 	});
 
+registerApiCommands(program);
+registerTargetCommands(program);
+registerPlatformCommands(program);
+
 async function buildInput(options: {
 	input?: string;
 	output?: string;

package/src/clpp/contract.ts

@@ -1,10 +1,22 @@
-/** Stable CL++ ↔ Cluaupp contract (CL++ 0.3.2 / 0.3.3). Cluaupp invokes the `clpp` binary. */
+/** Stable CL++ ↔ Cluaupp contract (CL++ 0.8.x). Cluaupp invokes the `clpp` binary. */
 
 export interface CompileRequest {
 	source: string;
 	fileName: string;
 	strict?: boolean;
 	cwd?: string;
+	/** false = skip high-level opts (fair baseline). Default true when omitted. */
+	optimize?: boolean;
+	/** Path to RobloxTargetProfile JSON (Cluaupp target — not embedded in CLPP). */
+	targetProfilePath?: string;
+	/** Directory holding cached target artifacts. */
+	targetCacheDir?: string;
+	/** Run context from file tags (.server / .client / .plugin). */
+	runContext?: "Server" | "Client" | "Plugin" | "Shared";
+	/** Path to capability-profile.json for Context Safety rules. */
+	capabilityProfilePath?: string;
+	/** Path to Typed DataModel profile JSON (Rojo graph). */
+	datamodelProfilePath?: string;
 }
 
 export interface CompileDiagnostic {
@@ -16,6 +28,14 @@ export interface CompileDiagnostic {
 	severity: string;
 }
 
+export interface ModuleRequireEntry {
+	name: string;
+	from_file?: string;
+	to_file?: string;
+	fromFile?: string;
+	toFile?: string;
+}
+
 export interface CompileArtifact {
 	ok: boolean;
 	luau: string;
@@ -28,6 +48,17 @@ export interface CompileArtifact {
 	libraries: string[];
 	error?: string;
 	diagnostics?: CompileDiagnostic[];
+	sourceMap?: Array<{ luauLine: number; clppLine: number; file: string }>;
+	/** Named `import` / quoted include requires from CL++ (RFC 0003). */
+	requires?: ModuleRequireEntry[];
+	/** Selective @native candidates (RFC 0011). Not auto-applied as blanket. */
+	nativeHints?: string[];
+	/** Monomorphized generic symbols (`name__Type`). */
+	specialized?: string[];
+	/** Dense / SoA / buffer layout candidates. */
+	layoutHints?: string[];
+	/** False when compiled with --no-opt / optimize:false. */
+	optimized?: boolean;
 }
 
 export interface LanguageManifest {
@@ -45,7 +76,7 @@ export interface LanguageManifest {
 	io: Array<{ clpp: string; luau: string }>;
 }
 
-export const MIN_CLPP_VERSION = "0.3.2";
+export const MIN_CLPP_VERSION = "0.8.0";
 
 export const CLPP_INSTALL_HINT =
-	"Install CL++ 0.3.2 or newer (clpp-setup.exe or `clpp setup`) and put `clpp` on PATH. 0.3.3 is the same JSON contract. Instances are class names (`Player player`, not `Player*`). Override with CLPP or CLPP_PATH.";
+	"Install CL++ 0.8.0+ (`clpp` from https://github.com/KartzRbx/CLPP/releases). Put it on PATH. Prefer `import { Name } from \"./x.clh\"` for language modules; angle `#include <clpp/…>` stays for host prelude. Override with CLPP or CLPP_PATH.";

package/src/clpp/format-luau.ts

@@ -0,0 +1,262 @@
+// Roblox Luau style for Cluaupp emit: tabs, indent blocks, leave inner spacing alone.
+
+const TAB = "\t";
+
+type Carry = {
+	long: "none" | "string" | "comment";
+	eq: number;
+};
+
+function longClose(eq: number): string {
+	return `]${"=".repeat(eq)}]`;
+}
+
+function longOpenEq(text: string, index: number): number | null {
+	if (text[index] !== "[") {
+		return null;
+	}
+	let i = index + 1;
+	let eq = 0;
+	while (text[i] === "=") {
+		eq += 1;
+		i += 1;
+	}
+	if (text[i] === "[") {
+		return eq;
+	}
+	return null;
+}
+
+function skipLong(text: string, start: number, eq: number): { next: number; closed: boolean } {
+	const close = longClose(eq);
+	const found = text.indexOf(close, start);
+	if (found === -1) {
+		return { next: text.length, closed: false };
+	}
+	return { next: found + close.length, closed: true };
+}
+
+function firstToken(text: string): string {
+	const match = text.match(/^[A-Za-z_][A-Za-z0-9_]*|^\}/);
+	return match ? match[0] : "";
+}
+
+function identAt(text: string, from: number): string {
+	let j = from;
+	while (j < text.length && /[A-Za-z0-9_]/.test(text[j] || "")) {
+		j += 1;
+	}
+	return text.slice(from, j);
+}
+
+function scanDelta(text: string, carry: Carry): { delta: number; carry: Carry } {
+	let i = 0;
+	let delta = 0;
+	let long = carry.long;
+	let eq = carry.eq;
+
+	const consumeLong = (kind: "string" | "comment", depth: number, from: number): boolean => {
+		const skipped = skipLong(text, from, depth);
+		if (!skipped.closed) {
+			long = kind;
+			eq = depth;
+			i = text.length;
+			return false;
+		}
+		long = "none";
+		eq = 0;
+		i = skipped.next;
+		return true;
+	};
+
+	if (long === "string") {
+		consumeLong("string", eq, 0);
+	} else if (long === "comment") {
+		consumeLong("comment", eq, 0);
+	}
+
+	while (i < text.length) {
+		const ch = text[i] || "";
+		if (ch === "-" && text[i + 1] === "-") {
+			const commentEq = longOpenEq(text, i + 2);
+			if (commentEq !== null) {
+				const openEnd = i + 4 + commentEq;
+				if (!consumeLong("comment", commentEq, openEnd)) {
+					return { delta, carry: { long, eq } };
+				}
+				continue;
+			}
+			break;
+		}
+		if (ch === "'" || ch === '"') {
+			const quote = ch;
+			i += 1;
+			while (i < text.length) {
+				if (text[i] === "\\") {
+					i += 2;
+					continue;
+				}
+				if (text[i] === quote) {
+					i += 1;
+					break;
+				}
+				i += 1;
+			}
+			continue;
+		}
+		const strEq = longOpenEq(text, i);
+		if (strEq !== null) {
+			const openEnd = i + 2 + strEq;
+			if (!consumeLong("string", strEq, openEnd)) {
+				return { delta, carry: { long, eq } };
+			}
+			continue;
+		}
+		if (ch === "{") {
+			delta += 1;
+			i += 1;
+			continue;
+		}
+		if (ch === "}") {
+			delta -= 1;
+			i += 1;
+			continue;
+		}
+		if (/[A-Za-z_]/.test(ch)) {
+			const word = identAt(text, i);
+			i += word.length;
+			if (word === "function" || word === "then" || word === "do" || word === "repeat") {
+				delta += 1;
+			} else if (word === "end" || word === "until") {
+				delta -= 1;
+			}
+			continue;
+		}
+		i += 1;
+	}
+	return { delta, carry: { long, eq } };
+}
+
+export function formatLuauRoblox(source: string): string {
+	const lines = String(source).split(/\r?\n/);
+	const out: string[] = [];
+	let indent = 0;
+	let carry: Carry = { long: "none", eq: 0 };
+
+	for (const raw of lines) {
+		if (raw.trim() === "") {
+			out.push("");
+			continue;
+		}
+
+		if (carry.long !== "none") {
+			out.push(raw.trimEnd());
+			carry = scanDelta(raw, carry).carry;
+			continue;
+		}
+
+		const trimmed = raw.trim();
+		const lead = firstToken(trimmed);
+		const closer = lead === "end" || lead === "until" || lead === "else" || lead === "elseif" || lead === "}";
+		if (closer) {
+			indent = Math.max(0, indent - 1);
+		}
+
+		out.push(`${TAB.repeat(indent)}${trimmed}`);
+
+		const rest = closer ? trimmed.slice(lead.length) : trimmed;
+		const scanned = scanDelta(rest, carry);
+		indent = Math.max(0, indent + scanned.delta);
+		if (lead === "else") {
+			indent += 1;
+		}
+		carry = scanned.carry;
+	}
+
+	return `${collapseBlanks(compactTableFields(spaceScopes(out))).join("\n").replace(/[ \t]+$/gm, "").replace(/\n+$/, "")}\n`;
+}
+
+function lineIndent(line: string): number {
+	const match = line.match(/^\t*/);
+	return match ? match[0].length : 0;
+}
+
+function isComment(line: string): boolean {
+	return line.trimStart().startsWith("--");
+}
+
+function spaceScopes(lines: string[]): string[] {
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i] || "";
+		const next = lines[i + 1];
+		out.push(line);
+		if (next === undefined || line.trim() === "" || next.trim() === "") {
+			continue;
+		}
+		if (lineIndent(line) !== lineIndent(next)) {
+			continue;
+		}
+
+		const lead = firstToken(line.trim());
+		const nextLead = firstToken(next.trim());
+		const nextCloses = nextLead === "else" || nextLead === "elseif" || nextLead === "end" || nextLead === "until" || nextLead === "}";
+		if ((lead === "end" || lead === "until" || lead === "}") && !nextCloses) {
+			out.push("");
+			continue;
+		}
+
+		const nextOpens = nextLead === "if" || nextLead === "for" || nextLead === "while" || nextLead === "repeat";
+		const prevOpens = lead === "if" || lead === "for" || lead === "while" || lead === "repeat" || lead === "else" || lead === "elseif";
+		if (nextOpens && !prevOpens && lead !== "end" && lead !== "until" && lead !== "}" && !isComment(line)) {
+			out.push("");
+		}
+	}
+	return out;
+}
+
+function collapseBlanks(lines: string[]): string[] {
+	const out: string[] = [];
+	for (const line of lines) {
+		if (line.trim() === "" && out.length > 0 && (out[out.length - 1] || "").trim() === "") {
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
+
+function tableName(line: string): string | null {
+	const trimmed = line.trim();
+	const field = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\.[A-Za-z_][A-Za-z0-9_]*\s*=/);
+	if (field) {
+		return field[1];
+	}
+	const ctor = trimmed.match(/^(?:local|const)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\{\s*\}\s*$/);
+	return ctor ? ctor[1] : null;
+}
+
+function compactTableFields(lines: string[]): string[] {
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i] || "";
+		if (line.trim() !== "") {
+			out.push(line);
+			continue;
+		}
+
+		const prev = out[out.length - 1];
+		let nextIndex = i + 1;
+		while (nextIndex < lines.length && (lines[nextIndex] || "").trim() === "") {
+			nextIndex += 1;
+		}
+		const next = lines[nextIndex];
+		const prevTable = prev ? tableName(prev) : null;
+		const nextTable = next !== undefined ? tableName(next) : null;
+		if (prevTable && nextTable && prevTable === nextTable) {
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}

package/src/clpp/index.ts

@@ -1,7 +1,7 @@
-export type { CompileArtifact, CompileDiagnostic, CompileRequest, LanguageManifest } from "./contract.js";
+export type { CompileArtifact, CompileDiagnostic, CompileRequest, LanguageManifest, ModuleRequireEntry } from "./contract.js";
 export { CLPP_INSTALL_HINT, MIN_CLPP_VERSION } from "./contract.js";
 export { compileViaClpp, compileViaClppAsync, clppManifest, clppVersion, hasClpp, resolveClppBinary } from "./runner.js";
-export { clppLuauToGame, shouldSkipInit } from "./postprocess.js";
+export { clppLuauToGame, formatLuauRoblox, rewriteClppEmit, shouldSkipInit } from "./postprocess.js";
 export {
 	SOURCE_EXTS,
 	collectSources,
@@ -16,3 +16,14 @@ export {
 	siblingHeader,
 	toLuauPath,
 } from "./paths.js";
+export {
+	applyNativeHintsToLuau,
+	collectLanguageModulePaths,
+	collectModuleRefs,
+	ensureGameServices,
+	fingerprintSourceWithDeps,
+	planLayoutFromHints,
+	resolveLanguageDeps,
+	resolveModuleFile,
+	rewriteGameRootedRequires,
+} from "./modules.js";

package/src/clpp/modules.ts

@@ -0,0 +1,252 @@
+/**
+ * CL++ 0.8 module surface for the Cluaupp host.
+ * Canonical: `import { Name } from "./path.clh"` — `#include` remains legacy / angle prelude.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+export type ModuleRefKind = "import" | "include";
+
+export interface NamedImportBinding {
+	name: string;
+	alias: string;
+}
+
+export interface ModuleRef {
+	kind: ModuleRefKind;
+	/** Raw path text from source (quoted or angle body). */
+	modulePath: string;
+	/** Angle `#include <…>` (host prelude) — not a language module. */
+	angled: boolean;
+	bindings: NamedImportBinding[];
+	index: number;
+}
+
+const IMPORT_RE =
+	/\bimport\s*\{([^}]*)\}\s*from\s*"([^"]+)"\s*;?/g;
+const INCLUDE_RE = /#\s*include\s*(?:<([^>]+)>|"([^"]+)")/g;
+
+function parseBindings(inner: string): NamedImportBinding[] {
+	const out: NamedImportBinding[] = [];
+	for (const part of inner.split(",")) {
+		const piece = part.trim();
+		if (!piece) continue;
+		const asMatch = /^([A-Za-z_]\w*)\s+as\s+([A-Za-z_]\w*)$/.exec(piece);
+		if (asMatch) {
+			out.push({ name: asMatch[1], alias: asMatch[2] });
+			continue;
+		}
+		const ident = /^([A-Za-z_]\w*)$/.exec(piece);
+		if (ident) {
+			out.push({ name: ident[1], alias: ident[1] });
+		}
+	}
+	return out;
+}
+
+/** Collect every `import { … } from` and quoted/angle `#include` in source order. */
+export function collectModuleRefs(source: string): ModuleRef[] {
+	const refs: ModuleRef[] = [];
+	const text = String(source);
+
+	IMPORT_RE.lastIndex = 0;
+	let m: RegExpExecArray | null;
+	while ((m = IMPORT_RE.exec(text))) {
+		refs.push({
+			kind: "import",
+			modulePath: m[2].replace(/\\/g, "/"),
+			angled: false,
+			bindings: parseBindings(m[1]),
+			index: m.index,
+		});
+	}
+
+	INCLUDE_RE.lastIndex = 0;
+	while ((m = INCLUDE_RE.exec(text))) {
+		const angled = Boolean(m[1]);
+		const modulePath = (m[1] || m[2] || "").replace(/\\/g, "/");
+		if (!modulePath) continue;
+		refs.push({
+			kind: "include",
+			modulePath,
+			angled,
+			bindings: [],
+			index: m.index,
+		});
+	}
+
+	refs.sort((a, b) => a.index - b.index);
+	return refs;
+}
+
+/** Language modules only — named imports + quoted includes (not angle `<clpp/…>`). */
+export function collectLanguageModulePaths(source: string): string[] {
+	const out: string[] = [];
+	const seen = new Set<string>();
+	for (const ref of collectModuleRefs(source)) {
+		if (ref.angled) continue;
+		if (seen.has(ref.modulePath)) continue;
+		seen.add(ref.modulePath);
+		out.push(ref.modulePath);
+	}
+	return out;
+}
+
+export function isAnglePlatformInclude(modulePath: string): boolean {
+	const p = modulePath.replace(/\\/g, "/").toLowerCase();
+	return (
+		p.startsWith("clpp/") ||
+		p.startsWith("cluaupp/") ||
+		p.startsWith("cluau/") ||
+		p === "roblox.clh" ||
+		p.endsWith("/roblox.clh")
+	);
+}
+
+/** Resolve a module path relative to the importing file (and optional src root). */
+export function resolveModuleFile(
+	modulePath: string,
+	fromFile: string,
+	srcDir?: string,
+): string | null {
+	const raw = modulePath.replace(/[<>'"]/g, "").trim();
+	if (!raw || isAnglePlatformInclude(raw)) {
+		return null;
+	}
+	const bases: string[] = [path.dirname(fromFile)];
+	if (srcDir) {
+		bases.push(srcDir);
+	}
+	for (const base of bases) {
+		const candidate = path.resolve(base, raw);
+		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+			return candidate;
+		}
+		// Allow omitting extension when the stem matches a source file.
+		for (const ext of [".clh", ".clp", ".clpp"]) {
+			const withExt = candidate.endsWith(ext) ? candidate : candidate + ext;
+			if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) {
+				return withExt;
+			}
+		}
+	}
+	return null;
+}
+
+/** Absolute paths of language deps (one hop). */
+export function resolveLanguageDeps(source: string, fromFile: string, srcDir?: string): string[] {
+	const out: string[] = [];
+	const seen = new Set<string>();
+	for (const mod of collectLanguageModulePaths(source)) {
+		const resolved = resolveModuleFile(mod, fromFile, srcDir);
+		if (!resolved) continue;
+		const key = path.resolve(resolved);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(key);
+	}
+	return out;
+}
+
+/**
+ * Fingerprint source + one-hop language deps so import/include edits invalidate incremental cache.
+ */
+export function fingerprintSourceWithDeps(
+	source: string,
+	fromFile: string,
+	configKey: string,
+	srcDir: string | undefined,
+	hashText: (text: string) => string,
+): string {
+	const parts = [configKey, source];
+	for (const dep of resolveLanguageDeps(source, fromFile, srcDir)) {
+		try {
+			parts.push(`\n//dep:${dep.replace(/\\/g, "/")}\n`);
+			parts.push(fs.readFileSync(dep, "utf8"));
+		} catch {
+			parts.push(`\n//dep-missing:${dep.replace(/\\/g, "/")}\n`);
+		}
+	}
+	return hashText(parts.join(""));
+}
+
+/** Rewrite CL++ `script.Parent…Service…` walks to game-rooted requires. */
+export function rewriteGameRootedRequires(luau: string): string {
+	let next = String(luau);
+	const services = [
+		"ReplicatedStorage",
+		"ReplicatedFirst",
+		"ServerScriptService",
+		"ServerStorage",
+		"StarterPlayer",
+		"StarterGui",
+		"Workspace",
+	];
+	for (const svc of services) {
+		const re = new RegExp(`script(?:\\.Parent)+\\.${svc}\\.`, "g");
+		next = next.replace(re, `${svc}.`);
+	}
+	return next;
+}
+
+/** Ensure GetService lines exist for any game-rooted require used. */
+export function ensureGameServices(luau: string): string {
+	let next = String(luau);
+	const needed: string[] = [];
+	for (const svc of ["ReplicatedStorage", "ReplicatedFirst", "ServerScriptService", "ServerStorage", "StarterPlayer"]) {
+		if (new RegExp(`require\\(${svc}\\.`).test(next) && !new RegExp(`GetService\\(\\s*"${svc}"\\s*\\)`).test(next)) {
+			needed.push(svc);
+		}
+	}
+	if (needed.length === 0) {
+		return next;
+	}
+	const block = needed.map((svc) => `const ${svc} = game:GetService("${svc}")`).join("\n");
+	const match = next.match(/^(?:--[^\n]*\n)+/);
+	if (!match) {
+		return `${block}\n${next}`;
+	}
+	const insertAt = match[0].length;
+	const rest = next.slice(insertAt).replace(/^\n*/, "\n");
+	return `${next.slice(0, insertAt)}\n${block}\n${rest}`;
+}
+
+/** Selective `@native` from CompileArtifact.nativeHints (never blanket). */
+export function applyNativeHintsToLuau(luau: string, hints: string[] | undefined): string {
+	const set = new Set((hints || []).filter(Boolean));
+	if (set.size === 0) {
+		return luau;
+	}
+	const lines = luau.split(/\r?\n/);
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const m = line.match(/^(\s*)(local\s+function|function)\s+([A-Za-z_][\w.:]*)/);
+		if (m) {
+			const short = m[3].includes(":") ? m[3].split(":").pop()! : m[3].split(".").pop()!;
+			if ((set.has(m[3]) || set.has(short)) && (i === 0 || !lines[i - 1].includes("@native"))) {
+				out.push(`${m[1]}@native`);
+			}
+		}
+		out.push(line);
+	}
+	return out.join("\n");
+}
+
+export function planLayoutFromHints(layoutHints: string[] | undefined): { soa: string[]; buffer: string[] } {
+	const soa: string[] = [];
+	const buffer: string[] = [];
+	for (const h of layoutHints || []) {
+		if (h.startsWith("SoA:") || h.startsWith("SoACandidate:")) {
+			soa.push(h.replace(/^SoA(Candidate)?:/, ""));
+		} else if (
+			h.startsWith("BufferSpecialize:") ||
+			h.startsWith("BufferCandidate:") ||
+			h.startsWith("DenseNumeric:")
+		) {
+			buffer.push(h.split(":")[1] ?? h);
+		}
+	}
+	return { soa, buffer };
+}