elysia 1.4.28 → 2.0.0-beta.0

package/dist/plugin/aot/source.mjs

@@ -0,0 +1,418 @@
+import { nullObject } from "../../utils.mjs";
+import { env } from "../../universal/env.mjs";
+import { Capture, Compiled, createAotFingerprint } from "../../compile/aot.mjs";
+import { JITProbe } from "../../compile/jit-probe.mjs";
+import { setCaptureHeaderShorthand } from "../../compile/handler/jit.mjs";
+import { Validator } from "../../validator/index.mjs";
+import { compileHandler } from "../../compile/handler/index.mjs";
+import { Source } from "../../compile/aot-emit.mjs";
+import { abortCapture, beginValidatorCapture, endHandlerCapture, endValidatorCapture, restoreCompiled, snapshotCompiled } from "../../compile/aot-capture.mjs";
+
+//#region src/plugin/aot/source.ts
+const autoGroupSize = (routes) => routes < 64 ? 1 : routes < 256 ? 2 : routes < 2048 ? 4 : routes < 8192 ? 16 : 64;
+async function compileToSource(app, options) {
+	return (await captureArtifacts(app, options)).source;
+}
+async function captureArtifacts(app, options) {
+	const previousAotBuild = env.ELYSIA_AOT_BUILD;
+	env.ELYSIA_AOT_BUILD = "1";
+	try {
+		if (!Capture.isCapturing()) throw new Error("[elysia-aot]: ELYSIA_AOT_BUILD=1 must be set to enable AOT capture mode");
+		beginValidatorCapture();
+		const modules = app.modules;
+		if (modules) await modules;
+		if (options?.target !== void 0) setCaptureHeaderShorthand(options.target === "bun");
+		app.compile();
+		const captured = endValidatorCapture();
+		const handlers = endHandlerCapture();
+		const fingerprint = app["~aotFingerprint"] ?? createAotFingerprint();
+		return {
+			source: emitModule(captured, handlers, fingerprint, options),
+			validators: captured,
+			handlers,
+			fingerprint
+		};
+	} finally {
+		setCaptureHeaderShorthand(void 0);
+		abortCapture();
+		if (previousAotBuild === void 0) delete env.ELYSIA_AOT_BUILD;
+		else env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+const materialiseHandlersForReplay = (captured) => {
+	const manifest = {};
+	for (const h of captured) (manifest[h.method] ??= {})[h.path] = {
+		a: h.alias ? h.alias.split(",") : [],
+		f: new Function(`return ${Source.handlerFactory(h.alias, h.code)}`)()
+	};
+	return manifest;
+};
+function replayStubbability(app, handlers) {
+	const previousCompiled = snapshotCompiled();
+	const previousAotBuild = env.ELYSIA_AOT_BUILD;
+	if (previousAotBuild !== void 0) delete env.ELYSIA_AOT_BUILD;
+	try {
+		Compiled.clear();
+		const fingerprint = createAotFingerprint();
+		Compiled.register({
+			bf: 1,
+			fingerprint,
+			handlers: materialiseHandlersForReplay(handlers)
+		});
+		Compiled.claim(app["~programId"], fingerprint);
+		Validator.clear();
+		const history = app["~routes"] ?? [];
+		JITProbe.begin();
+		for (const route of history) try {
+			if (route[0] === "WS") continue;
+			compileHandler(route, app);
+		} catch {
+			JITProbe.end();
+			return {
+				jit: false,
+				reasons: ["handler:new-function"]
+			};
+		}
+		return JITProbe.end();
+	} finally {
+		restoreCompiled(previousCompiled);
+		Validator.clear();
+		if (previousAotBuild !== void 0) env.ELYSIA_AOT_BUILD = previousAotBuild;
+	}
+}
+const checkIdRegex = /\bcheck_[0-9a-f]+\b/g;
+const normalizeCheckIdentifiers = (src) => {
+	const seen = /* @__PURE__ */ new Map();
+	return src.replace(checkIdRegex, (id) => {
+		let name = seen.get(id);
+		if (name === void 0) {
+			name = `_k${seen.size}`;
+			seen.set(id, name);
+		}
+		return name;
+	});
+};
+function createEntryEncoder() {
+	const branchRef = /* @__PURE__ */ new Map();
+	let branchDecls = "";
+	const branchTable = (u) => "[" + u.map((branch) => "[" + branch.map((b) => {
+		const src = normalizeCheckIdentifiers(Source.checkFactory(b.identifier, b.code));
+		let ref = branchRef.get(src);
+		if (ref === void 0) {
+			ref = `_b${branchRef.size}`;
+			branchRef.set(src, ref);
+			branchDecls += `const ${ref} = ${src}\n`;
+		}
+		return ref;
+	}).join(", ") + "]").join(", ") + "]";
+	const unionRef = /* @__PURE__ */ new Map();
+	let unionDecls = "";
+	let hasCoercePlan = false;
+	const unionTable = (u) => {
+		const str = branchTable(u);
+		let ref = unionRef.get(str);
+		if (ref === void 0) {
+			ref = `_u${unionRef.size}`;
+			unionRef.set(str, ref);
+			unionDecls += `const ${ref} = ${str}\n`;
+		}
+		return ref;
+	};
+	return {
+		unionTable,
+		setCoercePlan() {
+			hasCoercePlan = true;
+		},
+		get branchDecls() {
+			return branchDecls;
+		},
+		get unionDecls() {
+			return unionDecls;
+		},
+		get hasCoercePlan() {
+			return hasCoercePlan;
+		}
+	};
+}
+function entryParts(c, enc) {
+	const parts = [];
+	const flags = [];
+	if (c.checkValue) {
+		if (c.external) flags.push("e:1");
+		if (c.async) flags.push("a:1");
+		if (c.hasDefault) flags.push("d:1");
+		if (c.hasCodec) flags.push("k:1");
+		if (c.hasRef) flags.push("r:1");
+	}
+	if (c.checkValue && c.mirror) {
+		const m = c.mirror;
+		parts.push(`cm: ${Source.bothFactory(c.identifier, c.checkDefs, c.checkValue, m.source, m.hasExternals)}`, ...flags);
+		if (m.u) parts.push(`u: ${enc.unionTable(m.u)}`);
+	} else if (c.checkValue) parts.push(`c: ${Source.checkFactory(c.identifier, Source.checkCode(c.checkDefs, c.checkValue))}`, ...flags);
+	else if (c.mirror) {
+		const m = c.mirror;
+		let ms = `s: ${Source.mirrorFactory(m.source, m.hasExternals)}`;
+		if (m.u) ms += `, u: ${enc.unionTable(m.u)}`;
+		parts.push(`m: { ${ms} }`);
+	}
+	if (c.decodeMirror) {
+		const dm = c.decodeMirror;
+		let dms = `s: ${Source.mirrorFactory(dm.source, true)}`;
+		if (dm.u) dms += `, u: ${enc.unionTable(dm.u)}`;
+		parts.push(`dm: { ${dms} }`);
+	}
+	if (c.encodeMirror) {
+		const em = c.encodeMirror;
+		let ems = `s: ${Source.mirrorFactory(em.source, true)}`;
+		if (em.u) ems += `, u: ${enc.unionTable(em.u)}`;
+		parts.push(`em: { ${ems} }`);
+	}
+	if (c.precomputeSafe) {
+		parts.push("ps: 1");
+		if (c.precomputedDefault !== void 0) parts.push(`pd: ${JSON.stringify(c.precomputedDefault)}`);
+		if (c.precomputeNull) parts.push("pn: 1");
+		if (c.precomputedObjectDefault !== void 0) parts.push(`pod: ${JSON.stringify(c.precomputedObjectDefault)}`);
+		if (c.defaultCloner) parts.push(`dc: ${c.defaultCloner}`);
+		if (c.objectDefaultMerger) parts.push(`pm: ${c.objectDefaultMerger}`);
+	}
+	if (c.customErrors?.length) {
+		const ce = c.customErrors.map((e) => `{ p: ${JSON.stringify(e.path)}, c: ${Source.checkFactory(e.identifier, Source.checkCode(e.checkDefs, e.checkValue))}${e.external ? ", e: 1" : ""} }`).join(", ");
+		parts.push(`ce: [${ce}]`);
+	}
+	if (c.innerCodecs?.length) {
+		const ic = c.innerCodecs.map((e) => {
+			let s = `o: ${e.open}, c: ${Source.checkFactory(e.identifier, Source.checkCode(e.checkDefs, e.checkValue))}`;
+			if (e.external) s += ", e: 1";
+			let ds = `s: ${Source.mirrorFactory(e.decode.source, e.decode.hasExternals)}`;
+			if (e.decode.u) ds += `, u: ${enc.unionTable(e.decode.u)}`;
+			if (e.decode.hasExternals) ds += ", x: 1";
+			s += `, d: { ${ds} }`;
+			return `{ ${s} }`;
+		}).join(", ");
+		parts.push(`ic: [${ic}]`);
+	}
+	if (c.coercePlan) {
+		enc.setCoercePlan();
+		parts.push(`cp: ${JSON.stringify(c.coercePlan)}`);
+	}
+	return parts;
+}
+function emitModule(captured, handlers, fingerprint, options) {
+	const enc = createEntryEncoder();
+	const treeToSource = (tree, slotRef, sink) => {
+		const methods = [];
+		for (const method in tree) {
+			const paths = [];
+			for (const path in tree[method]) {
+				const slotObj = "{" + Object.entries(tree[method][path]).map(([slot, ref]) => `${JSON.stringify(slot)}:${ref}`).join(",") + "}";
+				let ref = slotRef.get(slotObj);
+				if (ref === void 0) {
+					ref = `_s${slotRef.size}`;
+					slotRef.set(slotObj, ref);
+					sink(`const ${ref} = ${slotObj}\n`);
+				}
+				paths.push(`${JSON.stringify(path)}:${ref}`);
+			}
+			methods.push(`${JSON.stringify(method)}:{${paths.join(",")}}`);
+		}
+		return `{${methods.join(",")}}`;
+	};
+	let validatorDecls = "";
+	let validatorExport = "";
+	const order = [];
+	const byRoute = /* @__PURE__ */ new Map();
+	for (const c of captured) {
+		const key = `${c.method}\0${c.path}`;
+		let arr = byRoute.get(key);
+		if (!arr) {
+			byRoute.set(key, arr = []);
+			order.push(key);
+		}
+		arr.push(c);
+	}
+	const autoSize = autoGroupSize(order.length);
+	const lazy = options?.lazy ?? Math.ceil(order.length / autoSize) > 128;
+	if (lazy) {
+		const groupSize = typeof lazy === "number" ? lazy : autoSize;
+		const groupCount = Math.ceil(order.length / groupSize);
+		const groupOf = nullObject();
+		const groupOfRoute = /* @__PURE__ */ new Map();
+		for (let i = 0; i < order.length; i++) {
+			const key = order[i];
+			const g = Math.floor(i / groupSize);
+			groupOfRoute.set(key, g);
+			const sep = key.indexOf("\0");
+			(groupOf[key.slice(0, sep)] ??= nullObject())[key.slice(sep + 1)] = g;
+		}
+		const entries = /* @__PURE__ */ new Map();
+		const routeSlots = /* @__PURE__ */ new Map();
+		for (const [key, cs] of byRoute) {
+			const g = groupOfRoute.get(key);
+			const slots = [];
+			for (const c of cs) {
+				const parts = entryParts(c, enc);
+				if (!parts.length) continue;
+				const entrySrc = normalizeCheckIdentifiers(`{ ${parts.join(", ")} }`);
+				let e = entries.get(entrySrc);
+				if (!e) {
+					e = {
+						ref: `_c${entries.size}`,
+						groups: /* @__PURE__ */ new Set()
+					};
+					entries.set(entrySrc, e);
+				}
+				e.groups.add(g);
+				slots.push([c.slot, entrySrc]);
+			}
+			routeSlots.set(key, slots);
+		}
+		for (const [src, e] of entries) if (e.groups.size > 1) validatorDecls += `const ${e.ref} = ${src}\n`;
+		let slotCounter = 0;
+		const groupRouteKeys = [];
+		const keySlotSrc = /* @__PURE__ */ new Map();
+		const slotStat = /* @__PURE__ */ new Map();
+		for (let g = 0; g < groupCount; g++) {
+			const keys = [];
+			const end = Math.min((g + 1) * groupSize, order.length);
+			for (let i = g * groupSize; i < end; i++) {
+				const key = order[i];
+				const slots = routeSlots.get(key);
+				if (!slots.length) continue;
+				keys.push(key);
+				let safe = true;
+				const slotSrc = "{" + slots.map(([slot, entrySrc]) => {
+					const e = entries.get(entrySrc);
+					if (e.groups.size === 1) safe = false;
+					return `${JSON.stringify(slot)}:${e.ref}`;
+				}).join(",") + "}";
+				keySlotSrc.set(key, slotSrc);
+				let stat = slotStat.get(slotSrc);
+				if (!stat) {
+					stat = {
+						groups: /* @__PURE__ */ new Set(),
+						safe
+					};
+					slotStat.set(slotSrc, stat);
+				}
+				stat.groups.add(g);
+				if (!safe) stat.safe = false;
+			}
+			groupRouteKeys.push(keys);
+		}
+		const hoistedSlotRef = /* @__PURE__ */ new Map();
+		for (const [src, stat] of slotStat) if (stat.groups.size > 1 && stat.safe) {
+			const ref = `_s${slotCounter++}`;
+			hoistedSlotRef.set(src, ref);
+			validatorDecls += `const ${ref} = ${src}\n`;
+		}
+		const thunks = [];
+		for (let g = 0; g < groupCount; g++) {
+			let localDecls = "";
+			const emitted = /* @__PURE__ */ new Set();
+			const localSlotRef = /* @__PURE__ */ new Map();
+			const byMethod = /* @__PURE__ */ new Map();
+			for (const key of groupRouteKeys[g]) {
+				const sep = key.indexOf("\0");
+				const method = key.slice(0, sep);
+				const path = key.slice(sep + 1);
+				for (const [, entrySrc] of routeSlots.get(key)) {
+					const e = entries.get(entrySrc);
+					if (e.groups.size === 1 && !emitted.has(entrySrc)) {
+						emitted.add(entrySrc);
+						localDecls += `const ${e.ref} = ${entrySrc}\n`;
+					}
+				}
+				const slotSrc = keySlotSrc.get(key);
+				let ref = hoistedSlotRef.get(slotSrc);
+				if (ref === void 0) {
+					ref = localSlotRef.get(slotSrc);
+					if (ref === void 0) {
+						ref = `_s${slotCounter++}`;
+						localSlotRef.set(slotSrc, ref);
+						localDecls += `const ${ref} = ${slotSrc}\n`;
+					}
+				}
+				let paths = byMethod.get(method);
+				if (!paths) byMethod.set(method, paths = []);
+				paths.push(`${JSON.stringify(path)}:${ref}`);
+			}
+			const sliceStr = "{" + [...byMethod.entries()].map(([method, paths]) => `${JSON.stringify(method)}:{${paths.join(",")}}`).join(",") + "}";
+			thunks.push(`() => {\n${localDecls}return ${sliceStr}\n}`);
+		}
+		validatorDecls += `const _groups = [${thunks.join(", ")}]\n`;
+		validatorDecls += `const _groupOf = ${JSON.stringify(groupOf)}\n`;
+		validatorExport = options?.register ? "" : "export const groups = _groups\nexport const groupOf = _groupOf\n";
+	} else {
+		const factoryRef = /* @__PURE__ */ new Map();
+		const tree = nullObject();
+		for (const c of captured) {
+			const parts = entryParts(c, enc);
+			if (!parts.length) continue;
+			const entrySrc = normalizeCheckIdentifiers(`{ ${parts.join(", ")} }`);
+			let ref = factoryRef.get(entrySrc);
+			if (ref === void 0) {
+				ref = `_c${factoryRef.size}`;
+				factoryRef.set(entrySrc, ref);
+				validatorDecls += `const ${ref} = ${entrySrc}\n`;
+			}
+			const byPath = tree[c.method] ??= nullObject();
+			(byPath[c.path] ??= nullObject())[c.slot] = ref;
+		}
+		const treeStr = treeToSource(tree, /* @__PURE__ */ new Map(), (d) => {
+			validatorDecls += d;
+		});
+		validatorExport = options?.register ? `const validators = ${treeStr}\n` : `export const validators = ${treeStr}\n`;
+	}
+	const aliasRef = /* @__PURE__ */ new Map();
+	const handlerRef = /* @__PURE__ */ new Map();
+	let handlerDecls = "";
+	const handlerTree = nullObject();
+	for (const h of handlers) {
+		const src = Source.handlerFactory(h.alias, h.code);
+		let wref = handlerRef.get(src);
+		if (wref === void 0) {
+			const n = handlerRef.size;
+			let aref = aliasRef.get(h.alias);
+			if (aref === void 0) {
+				aref = `_a${aliasRef.size}`;
+				aliasRef.set(h.alias, aref);
+				handlerDecls += `const ${aref} = ${JSON.stringify(h.alias ? h.alias.split(",") : [])}\n`;
+			}
+			wref = `_w${n}`;
+			handlerRef.set(src, wref);
+			handlerDecls += `const _h${n} = ${src}\nconst ${wref} = { a: ${aref}, f: _h${n} }\n`;
+		}
+		(handlerTree[h.method] ??= {})[h.path] = wref;
+	}
+	let handlerExport = options?.register ? "const handlers = {\n" : "export const handlers = {\n";
+	for (const method in handlerTree) {
+		handlerExport += `\t${JSON.stringify(method)}: {\n`;
+		for (const path in handlerTree[method]) handlerExport += `\t\t${JSON.stringify(path)}: ${handlerTree[method][path]},\n`;
+		handlerExport += "	},\n";
+	}
+	handlerExport += "}\n";
+	const fingerprintExport = options?.register ? `export const fingerprint = ${JSON.stringify(fingerprint)}\n` : "";
+	let body = "// Generated by Elysia build plugin. Do not edit.\n";
+	if (options?.register) body += `import { Compiled } from ${JSON.stringify(options.registerFrom ?? "elysia")}\n`;
+	if (options?.register && enc.hasCoercePlan) body += `import { buildCoercedFromPlan } from ${JSON.stringify("elysia/coerce-plan")}\n`;
+	if (options?.register && captured.length) body += `import { Reconstruct } from ${JSON.stringify(options.reconstructFrom ?? "elysia/reconstruct")}\n`;
+	const generated = enc.branchDecls + enc.unionDecls + validatorDecls + handlerDecls;
+	const needs = (symbol) => new RegExp(`\\b${symbol}\\b`).test(generated);
+	if (needs("CheckContext")) body += "import { CheckContext } from 'typebox/schema'\n";
+	if (needs("Guard")) body += "import { Guard } from 'typebox/guard'\n";
+	if (needs("Format")) body += "import { Format } from 'typebox/format'\n";
+	if (needs("Hashing")) body += "import { Hashing } from 'typebox/system'\n";
+	if (options?.register) {
+		body += "\n";
+		if (captured.length) body += "Compiled.reconstruct = Reconstruct\n";
+		body += fingerprintExport + "Compiled.register((() => {\n" + enc.branchDecls + (enc.branchDecls && "\n") + enc.unionDecls + (enc.unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport + "\nreturn { bf: 1, fingerprint, " + (lazy ? "lazyGroups: _groups, lazyGroupOf: _groupOf, " : "validators, ") + `handlers${enc.hasCoercePlan ? ", planRebuilder: buildCoercedFromPlan" : ""} }\n})())
+`;
+	} else {
+		body += "\n" + enc.branchDecls + (enc.branchDecls && "\n") + enc.unionDecls + (enc.unionDecls && "\n") + validatorDecls + handlerDecls + "\n" + validatorExport + "\n" + handlerExport + "\n";
+		if (!lazy) body += "\nexport default validators\n";
+	}
+	return body;
+}
+
+//#endregion
+export { autoGroupSize, captureArtifacts, compileToSource, replayStubbability };

package/dist/plugin/aot/treeshake.d.ts

@@ -0,0 +1,4 @@
+//#region src/plugin/aot/treeshake.d.ts
+declare function rewriteTypeImport(code: string): string;
+//#endregion
+export { rewriteTypeImport };

package/dist/plugin/aot/treeshake.js

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_compile_lexer = require('../../compile/lexer.js');
+
+//#region src/plugin/aot/treeshake.ts
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function nonCodeSpans(code) {
+	const spans = [];
+	const length = code.length;
+	let i = 0;
+	while (i < length) {
+		const c = code.charCodeAt(i);
+		if (c === 47 && code.charCodeAt(i + 1) === 47) {
+			const start = i;
+			const newline = code.indexOf("\n", i + 2);
+			i = newline === -1 ? length : newline;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 47 && code.charCodeAt(i + 1) === 42) {
+			const start = i;
+			const end = code.indexOf("*/", i + 2);
+			i = end === -1 ? length : end + 2;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 34 || c === 39) {
+			const start = i++;
+			while (i < length) {
+				const d = code.charCodeAt(i);
+				if (d === 92) i += 2;
+				else if (d === c || d === 10) break;
+				else i++;
+			}
+			i++;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 96) {
+			const start = i;
+			i = require_compile_lexer.skipString(code, i);
+			spans.push([start, i]);
+			continue;
+		}
+		i++;
+	}
+	return spans;
+}
+function rewriteTypeImport(code) {
+	const from = "elysia";
+	const typeFrom = "elysia/type";
+	if (!code.includes(from)) return code;
+	const importRe = new RegExp(`(^|\\n)([ \\t]*)import\\s+(?!type\\b)((?:[A-Za-z_$][\\w$]*\\s*,\\s*)?\\{[^}]*\\})\\s+from\\s*(['"])${escape(from)}\\4(\\s*(?:with|assert)\\s*\\{[^}]*\\})?`, "g");
+	const spans = nonCodeSpans(code);
+	const edits = [];
+	let m;
+	while (m = importRe.exec(code)) {
+		const [full, lead, indent, clause, , attributes] = m;
+		const keyword = m.index + lead.length + indent.length;
+		if (spans.some(([start, end]) => keyword >= start && keyword < end)) continue;
+		const braceStart = clause.indexOf("{");
+		if (braceStart === -1) continue;
+		const braceEnd = clause.indexOf("}", braceStart);
+		if (braceEnd === -1) continue;
+		const before = clause.slice(0, braceStart).trim();
+		const memberSource = clause.slice(braceStart + 1, braceEnd);
+		if (/['"`]|\/\/|\/\*/.test(memberSource)) continue;
+		const members = memberSource.split(",").map((x) => x.trim()).filter(Boolean);
+		let alias;
+		const kept = [];
+		for (const member of members) {
+			const t = member.match(/^t(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+			if (t && !alias) alias = t[1] ?? "t";
+			else kept.push(member);
+		}
+		if (!alias) continue;
+		const head = before.replace(/,\s*$/, "").trim();
+		const keptClause = head && kept.length ? `${head}, { ${kept.join(", ")} }` : head ? head : kept.length ? `{ ${kept.join(", ")} }` : "";
+		const attr = attributes ?? "";
+		const lines = [];
+		if (keptClause) lines.push(`import ${keptClause} from '${from}'${attr}`);
+		lines.push(`import * as ${alias} from '${typeFrom}'${attr}`);
+		edits.push({
+			start: m.index,
+			end: m.index + full.length,
+			text: lead + indent + lines.join("\n" + indent)
+		});
+	}
+	if (!edits.length) return code;
+	let out = code;
+	for (const e of edits.sort((a, b) => b.start - a.start)) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+	return out;
+}
+
+//#endregion
+exports.rewriteTypeImport = rewriteTypeImport;

package/dist/plugin/aot/treeshake.mjs

@@ -0,0 +1,94 @@
+import { skipString } from "../../compile/lexer.mjs";
+
+//#region src/plugin/aot/treeshake.ts
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function nonCodeSpans(code) {
+	const spans = [];
+	const length = code.length;
+	let i = 0;
+	while (i < length) {
+		const c = code.charCodeAt(i);
+		if (c === 47 && code.charCodeAt(i + 1) === 47) {
+			const start = i;
+			const newline = code.indexOf("\n", i + 2);
+			i = newline === -1 ? length : newline;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 47 && code.charCodeAt(i + 1) === 42) {
+			const start = i;
+			const end = code.indexOf("*/", i + 2);
+			i = end === -1 ? length : end + 2;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 34 || c === 39) {
+			const start = i++;
+			while (i < length) {
+				const d = code.charCodeAt(i);
+				if (d === 92) i += 2;
+				else if (d === c || d === 10) break;
+				else i++;
+			}
+			i++;
+			spans.push([start, i]);
+			continue;
+		}
+		if (c === 96) {
+			const start = i;
+			i = skipString(code, i);
+			spans.push([start, i]);
+			continue;
+		}
+		i++;
+	}
+	return spans;
+}
+function rewriteTypeImport(code) {
+	const from = "elysia";
+	const typeFrom = "elysia/type";
+	if (!code.includes(from)) return code;
+	const importRe = new RegExp(`(^|\\n)([ \\t]*)import\\s+(?!type\\b)((?:[A-Za-z_$][\\w$]*\\s*,\\s*)?\\{[^}]*\\})\\s+from\\s*(['"])${escape(from)}\\4(\\s*(?:with|assert)\\s*\\{[^}]*\\})?`, "g");
+	const spans = nonCodeSpans(code);
+	const edits = [];
+	let m;
+	while (m = importRe.exec(code)) {
+		const [full, lead, indent, clause, , attributes] = m;
+		const keyword = m.index + lead.length + indent.length;
+		if (spans.some(([start, end]) => keyword >= start && keyword < end)) continue;
+		const braceStart = clause.indexOf("{");
+		if (braceStart === -1) continue;
+		const braceEnd = clause.indexOf("}", braceStart);
+		if (braceEnd === -1) continue;
+		const before = clause.slice(0, braceStart).trim();
+		const memberSource = clause.slice(braceStart + 1, braceEnd);
+		if (/['"`]|\/\/|\/\*/.test(memberSource)) continue;
+		const members = memberSource.split(",").map((x) => x.trim()).filter(Boolean);
+		let alias;
+		const kept = [];
+		for (const member of members) {
+			const t = member.match(/^t(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+			if (t && !alias) alias = t[1] ?? "t";
+			else kept.push(member);
+		}
+		if (!alias) continue;
+		const head = before.replace(/,\s*$/, "").trim();
+		const keptClause = head && kept.length ? `${head}, { ${kept.join(", ")} }` : head ? head : kept.length ? `{ ${kept.join(", ")} }` : "";
+		const attr = attributes ?? "";
+		const lines = [];
+		if (keptClause) lines.push(`import ${keptClause} from '${from}'${attr}`);
+		lines.push(`import * as ${alias} from '${typeFrom}'${attr}`);
+		edits.push({
+			start: m.index,
+			end: m.index + full.length,
+			text: lead + indent + lines.join("\n" + indent)
+		});
+	}
+	if (!edits.length) return code;
+	let out = code;
+	for (const e of edits.sort((a, b) => b.start - a.start)) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+	return out;
+}
+
+//#endregion
+export { rewriteTypeImport };

package/dist/plugin/aot/unplugin.d.ts

@@ -0,0 +1,50 @@
+import { ElysiaAotOptions } from "./core.js";
+
+//#region src/plugin/aot/unplugin.d.ts
+interface ElysiaAotUnpluginOptions extends ElysiaAotOptions {
+  /**
+   * Build entrypoint. Resolved by the nearest `package.json`. Must be the
+   * module that exports the Elysia app the plugin compiles.
+   */
+  entry: string;
+}
+interface ElysiaAotUnpluginFactoryResult {
+  name: string;
+  enforce?: 'pre' | 'post';
+  buildStart?: () => Promise<void>;
+  buildEnd?: () => void;
+  resolveId?: (id: string) => string | undefined;
+  load?: (id: string) => string | undefined;
+  transformInclude?: (id: string) => boolean;
+  transform?: (code: string, id: string) => string | undefined | Promise<string | undefined>;
+  /** Vite-specific override (`apply: 'build'` keeps dev on runtime JIT). */
+  vite?: {
+    apply?: 'build' | 'serve';
+  };
+  /** rspack compiler hook: forces the manifest module side-effectful. */
+  rspack?: (compiler: unknown) => void;
+  /** webpack compiler hook: forces the manifest module side-effectful. */
+  webpack?: (compiler: unknown) => void;
+}
+/**
+ * Elysia AOT build plugin factory (universal)
+ *
+ * Run Elysia JIT compilation in build time instead of runtime
+ *
+ * ```ts
+ * import { createUnplugin } from 'unplugin'
+ * import { aotFactory } from 'elysia/plugin/aot/unplugin'
+ *
+ * const aot = createUnplugin(aotFactory)
+ *
+ * // webpack.config.js  → aot.webpack({ entry: 'src/index.ts' })
+ * // rollup.config.js   → aot.rollup({ entry: 'src/index.ts' })
+ * // farm.config.ts     → aot.farm({ entry: 'src/index.ts' })
+ * ```
+ *
+ * For rspack, prefer the native `elysia/plugin/aot/rspack` plugin
+ * (no `unplugin` needed); for Vite prefer `elysia/plugin/aot/vite`
+ */
+declare const aotFactory: (options: ElysiaAotUnpluginOptions) => ElysiaAotUnpluginFactoryResult;
+//#endregion
+export { ElysiaAotUnpluginFactoryResult, ElysiaAotUnpluginOptions, aotFactory, aotFactory as default };