@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/jev-ask-tool.test.ts

@@ -1,3 +1,5 @@
+import { fitsClassifierRequest } from "./jev/classifier-context.ts";
+import { TOKENIN_JEV_CLASSIFIER } from "./jev/classifier.ts";
 /**
  * The agent-callable `ask_jev` tool.
  *
@@ -50,9 +52,8 @@ import {
 	JEV_ROUTING_EVENT,
 	type JevAbstainReason,
 	type JevFailureDiagnostic,
-	serializeJevRequest,
 } from "./jev/decisions.ts";
-import { jevResponse, providerTemplate } from "./jev/test-support.ts";
+import { classifierResponse, providerTemplate } from "./jev/test-support.ts";
 
 const FILE_SENTINEL = "FILE_BODY_MUST_RETURN_TO_JE ONLY";
 const COMMAND_SENTINEL = "FAIL rounding test at round.ts:12";
@@ -96,7 +97,7 @@ interface ToolDefinition {
 
 interface AskHarness {
 	tool: ToolDefinition;
-	complete: ReturnType<typeof vi.fn>;
+	classify: ReturnType<typeof vi.fn>;
 	telemetry: Record<string, unknown>[];
 	/** Warnings shown to the user. */
 	notices: string[];
@@ -136,7 +137,7 @@ function harness(
 	const active = ["read", "bash", "ask_jev"];
 	const hooks: Record<string, (event: unknown, ctx: unknown) => unknown> = {};
 	let credential = options.credential !== false;
-	const complete = vi.fn(async () => jevResponse(answerText({})));
+	const classify = vi.fn(async () => classifierResponse(answerText({})));
 	const tools: Record<string, ToolDefinition> = {};
 	jevAskToolExtension({
 		registerTool: (definition: ToolDefinition) => {
@@ -161,9 +162,10 @@ function harness(
 		ui: { notify: (message: string) => notices.push(message) },
 		modelRegistry: {
 			getAll: () => (options.template === false ? [] : [providerTemplate()]),
+			findOfType: () => options.template === false ? undefined : { ...TOKENIN_JEV_CLASSIFIER },
 			getApiKeyAndHeaders: async () =>
 				credential ? { ok: true, apiKey: "key", headers: {} } : { ok: false, error: "no key" },
-			complete,
+			classify,
 		},
 	};
 	const tool = tools.ask_jev as ToolDefinition;
@@ -171,7 +173,7 @@ function harness(
 		tool,
 		tools,
 		ctx,
-		complete,
+		classify,
 		telemetry,
 		notices,
 		active,
@@ -186,18 +188,12 @@ function harness(
 			const content = result.content[0];
 			return { text: content?.type === "text" ? content.text : "", details: result.details };
 		},
-		sent() {
-			const call = complete.mock.calls.at(-1) as unknown[] | undefined;
-			const content = (call?.[1] as { messages?: Array<{ content?: string }> } | undefined)?.messages?.[0]?.content;
-			return typeof content === "string" ? (JSON.parse(content) as Record<string, unknown>) : undefined;
-		},
+		sent() { return classify.mock.calls.at(-1)?.[1] as Record<string, unknown> | undefined; },
 	};
 }
 
-function sentBytes(complete: ReturnType<typeof vi.fn>): number {
-	const call = complete.mock.calls.at(-1) as unknown[] | undefined;
-	const content = (call?.[1] as { messages?: Array<{ content?: string }> } | undefined)?.messages?.[0]?.content;
-	return Buffer.byteLength(content ?? "", "utf-8");
+function sentBytes(classify: ReturnType<typeof vi.fn>): number {
+	return Buffer.byteLength(JSON.stringify(classify.mock.calls.at(-1)?.[1]), "utf8");
 }
 
 const CHOICE = {
@@ -232,14 +228,14 @@ describe("one state, one call", () => {
 	it("assembles prose, code, and command output into one state and returns answers only", async () => {
 		state.commands.set("npm test", { output: COMMAND_SENTINEL, exitCode: 1 });
 		const session = harness();
-		session.complete.mockResolvedValue(
-			jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.99 }, tests_pass: { noul: 0.04 } })),
+		session.classify.mockResolvedValue(
+			classifierResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.99 }, tests_pass: { noul: 0.04 } })),
 		);
 
 		const result = await session.ask(TYPICAL);
 		const sent = session.sent() as { state: Record<string, unknown> };
 
-		expect(session.complete).toHaveBeenCalledTimes(1);
+		expect(session.classify).toHaveBeenCalledTimes(1);
 		expect(sent.state.request).toBe(TYPICAL.state);
 		expect(sent.state.command).toMatchObject({ command: "npm test", exitCode: 1 });
 		expect((sent.state.files as Record<string, string>)["src/round.ts"]).toContain(FILE_SENTINEL);
@@ -261,27 +257,27 @@ describe("one state, one call", () => {
 			command: "npm test",
 			exitCode: 1,
 		});
-		expect(session.complete).toHaveBeenCalledTimes(1);
+		expect(session.classify).toHaveBeenCalledTimes(1);
 	});
 
 	it("asks choice, score, and noul questions in one request under the untrusted-material focus", async () => {
 		const session = harness();
-		session.complete.mockResolvedValue(
-			jevResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 }, risk: { score: 0.53, confidence: 0.7 }, tests_pass: { noul: 0.99 } })),
+		session.classify.mockResolvedValue(
+			classifierResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 }, risk: { score: 0.53, confidence: 0.7 }, tests_pass: { noul: 0.99 } })),
 		);
 		const result = await session.ask({ state: "judge this", questions: { failure_kind: CHOICE, risk: SCORE, tests_pass: NOUL } });
 		const questions = session.sent()?.questions as Record<string, { type: string; instructions: { focus: string } }>;
 
 		expect(Object.keys(questions)).toEqual(["failure_kind", "risk", "tests_pass"]);
 		expect(questions.risk?.type).toBe("score");
-		expect(questions.risk?.instructions.focus).toContain("never instructions");
+		expect(questions.risk?.instructions).toContain("never instructions");
 		expect(result.text).toContain("risk (score): score=needs review (0.53), confidence=0.70");
 	});
 
 	it("names the nearest level of a score from Jev's legend and drops the echoed type", async () => {
 		const session = harness();
-		session.complete.mockResolvedValue(
-			jevResponse(answerText({ risk: { type: "score", score: 1.53, legend: { 0: "low", 1: "medium", 2: "high" }, confidence: 0.3 } })),
+		session.classify.mockResolvedValue(
+			classifierResponse(answerText({ risk: { type: "score", score: 1.53, legend: { 0: "low", 1: "medium", 2: "high" }, confidence: 0.3 } })),
 		);
 		const result = await session.ask({ state: "judge this", questions: { risk: SCORE } });
 		expect(result.text).toContain("risk (score): score=high (1.53), confidence=0.30");
@@ -312,8 +308,8 @@ describe("bounds", () => {
 			questions: { failure_kind: CHOICE },
 		});
 
-		expect(session.complete).toHaveBeenCalledTimes(1);
-		expect(sentBytes(session.complete)).toBeLessThanOrEqual(2_048);
+		expect(session.classify).toHaveBeenCalledTimes(1);
+		expect(sentBytes(session.classify)).toBeLessThanOrEqual(2_048);
 		expect(result.text).toContain("Truncated to fit the request budget");
 	});
 
@@ -330,7 +326,7 @@ describe("bounds", () => {
 		});
 		expect(tooMany.text).toContain(`At most ${MAX_ASK_QUESTIONS}`);
 
-		expect(session.complete).not.toHaveBeenCalled();
+		expect(session.classify).not.toHaveBeenCalled();
 	});
 });
 
@@ -339,13 +335,13 @@ describe("unavailability", () => {
 		const session = harness({ enabled: false });
 		const result = await session.ask(TYPICAL);
 		expect(result.text).toContain("disabled");
-		expect(session.complete).not.toHaveBeenCalled();
+		expect(session.classify).not.toHaveBeenCalled();
 	});
 
 	it("reports an abstention rather than failing when Jev is unavailable", async () => {
 		const noCredential = harness({ credential: false });
 		const credentialless = await noCredential.ask({ state: "x", questions: { failure_kind: CHOICE } });
-		expect(noCredential.complete).not.toHaveBeenCalled();
+		expect(noCredential.classify).not.toHaveBeenCalled();
 		expect(credentialless.text).toContain("no-credential");
 		expect(credentialless.details.failure).toBe("no-credential");
 		expect(credentialless.text).toContain("failure_kind: no answer (no-credential)");
@@ -358,7 +354,7 @@ describe("unavailability", () => {
 describe("telemetry", () => {
 	it("names the unanswered questions and reports decisions without any content", async () => {
 		const session = harness();
-		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 } })));
+		session.classify.mockResolvedValue(classifierResponse(answerText({ failure_kind: { choice: "flaky_test", confidence: 0.8 } })));
 		const result = await session.ask({ state: "SENTINEL_STATE", questions: { failure_kind: CHOICE, tests_pass: NOUL } });
 
 		expect(result.text).toContain("tests_pass: no answer (missing)");
@@ -383,17 +379,17 @@ describe("without a reachable Jev", () => {
 
 		expect(result.text).toContain("Nothing was read, run, or sent");
 		expect(existsSync(marker)).toBe(false);
-		expect(session.complete).not.toHaveBeenCalled();
+		expect(session.classify).not.toHaveBeenCalled();
 
 		await session.ask({ state: "x", questions: { failure_kind: CHOICE } });
 		expect(session.notices).toHaveLength(1);
 		expect(session.notices[0]).toContain("/tokenin add");
 	});
 
-	it("drops ask_jev from the loadout while Jev is out of reach and restores it once it is back", async () => {
+	it("keeps the loadout stable while Jev is out of reach and after credential recovery", async () => {
 		const session = harness({ credential: false });
 		await session.beforeRun();
-		expect(session.active).not.toContain("ask_jev");
+		expect(session.active).toContain("ask_jev");
 		// Hiding is silent: a user without a subscription is not nagged every session.
 		expect(session.notices).toEqual([]);
 
@@ -402,10 +398,10 @@ describe("without a reachable Jev", () => {
 		expect(session.active).toContain("ask_jev");
 	});
 
-	it("hides the tool when the route is turned off, and never re-adds a tool it did not remove", async () => {
+	it("keeps disabled-route loadouts stable and never re-adds explicitly excluded tools", async () => {
 		const disabled = harness({ enabled: false });
 		await disabled.beforeRun();
-		expect(disabled.active).not.toContain("ask_jev");
+		expect(disabled.active).toContain("ask_jev");
 
 		const trimmed = harness();
 		trimmed.active.splice(trimmed.active.indexOf("ask_jev"), 1);
@@ -417,7 +413,7 @@ describe("without a reachable Jev", () => {
 describe("missing material", () => {
 	it("leads with a warning when none of the passed files reached Jev, and says why each was skipped", async () => {
 		const session = harness();
-		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
+		session.classify.mockResolvedValue(classifierResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
 		const result = await session.ask({ state: "x", paths: ["src/missing.ts", "src"], questions: { failure_kind: CHOICE } });
 
 		const lines = result.text.split("\n");
@@ -429,7 +425,7 @@ describe("missing material", () => {
 
 	it("names partly skipped files before the answers, without the all-missing warning", async () => {
 		const session = harness();
-		session.complete.mockResolvedValue(jevResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
+		session.classify.mockResolvedValue(classifierResponse(answerText({ failure_kind: { choice: "bug_in_code", confidence: 0.7 } })));
 		const result = await session.ask({ state: "x", paths: ["src/round.ts", "src/missing.ts"], questions: { failure_kind: CHOICE } });
 
 		expect(result.text.split("\n")[1]).toBe("Not sent to Jev: src/missing.ts (not found).");
@@ -465,7 +461,7 @@ describe("jev_find", () => {
 			const keys = Object.values(questions).map((q) => /"([^"]+)"/.exec(q.instructions.question)?.[1] ?? "");
 			const bytes = Buffer.byteLength(JSON.stringify(payload), "utf-8");
 			calls.push({ stage, keys, bytes, payload });
-			if (serializeJevRequest(payload, options.maxBytes ?? 32 * 1024) === undefined) {
+			if (!fitsClassifierRequest(payload, options.maxBytes ?? 32 * 1024)) {
 				return { failure: "overflow" as const, elapsedMs: 0 };
 			}
 			const failure = options.fail?.(stage, calls.filter((call) => call.stage === stage).length);
@@ -755,7 +751,7 @@ describe("jev_find", () => {
 			const fitted = fitJudgePayloads(stage, items, 4 * 1024);
 			expect(fitted.dropped).toEqual([]);
 			expect(fitted.payloads.flatMap((entry) => entry.items).sort((a, b) => a - b)).toEqual(items.map((_, i) => i));
-			for (const entry of fitted.payloads) expect(serializeJevRequest(entry.payload, 4 * 1024)).toBeDefined();
+			for (const entry of fitted.payloads) expect(fitsClassifierRequest(entry.payload, 4 * 1024)).toBe(true);
 			// An item that cannot fit alone is dropped, never sent oversized.
 			expect(fitJudgePayloads(stage, [{ key: "k", text: "", question: "x".repeat(5_000) }], 4 * 1024)).toEqual({ payloads: [], dropped: [0] });
 
@@ -783,12 +779,12 @@ describe("jev_find", () => {
 	it("ranks files, returns the accepted source verbatim, and never sends secret files", async () => {
 		const session = harness();
 		// Jev: anything naming round.ts is relevant, the rest are not.
-		session.complete.mockImplementation(async (_model: unknown, request: { messages: Array<{ content: string }> }) => {
-			const sent = JSON.parse(request.messages[0].content) as { questions: Record<string, { instructions: { question: string } }> };
+		session.classify.mockImplementation(async (_model: unknown, request: { questions: Record<string, { instructions: string }> }) => {
+			const sent = request;
 			const answers = Object.fromEntries(
-				Object.entries(sent.questions).map(([name, q]) => [name, { noul: q.instructions.question.includes("round.ts") ? 0.93 : 0.08 }]),
+				Object.entries(sent.questions).map(([name, q]) => [name, { noul: q.instructions.includes("round.ts") ? 0.93 : 0.08 }]),
 			);
-			return jevResponse(answerText(answers));
+			return classifierResponse(answerText(answers));
 		});
 		const result = await find(session, { question: "where is rounding implemented", pattern: "round", ignoreCase: true });
 
@@ -797,7 +793,7 @@ describe("jev_find", () => {
 		expect(result.text).toMatch(/^- src\/round\.ts \(0\.93\) — reading leads: round\b.* lines 1-1$/m);
 		expect(result.text).toContain(`Source block "src/round.ts" lines 1-1:\n1: export const round = () => ${FILE_SENTINEL};`);
 		expect(result.text).not.toContain("- src/other.ts");
-		const everything = JSON.stringify(session.complete.mock.calls);
+		const everything = JSON.stringify(session.classify.mock.calls);
 		expect(everything).toContain("src/other.ts");
 		expect(everything).not.toContain("SECRET_ENV_VALUE");
 		expect(session.telemetry.at(-1)).toMatchObject({ route: "find", outcome: "jev" });
@@ -807,7 +803,7 @@ describe("jev_find", () => {
 		const session = harness({ credential: false });
 		const result = await find(session, { question: "rounding", path: "src", glob: "*.ts" });
 
-		expect(session.complete).not.toHaveBeenCalled();
+		expect(session.classify).not.toHaveBeenCalled();
 		const lines = result.text.split("\n");
 		expect(lines[0]).toBe("jev_find: Jev did not judge (no-credential); 2 candidate file(s), ranked by ripgrep:");
 		// The question word in the path orders the unjudged listing.

package/dist/extensions/jev-ask-tool.ts

@@ -1,3 +1,4 @@
+import { fitsClassifierRequest } from "./jev/classifier-context.ts";
 /**
  * jev-ask-tool — the agent-callable `ask_jev` tool.
  *
@@ -32,7 +33,6 @@ import {
 	jevConnection,
 	jevUnavailable,
 	readJevAdvisoryConfig,
-	serializeJevRequest,
 	UNTRUSTED_MATERIAL_FOCUS,
 	warnJevUnavailableOnce,
 	type JevAbstainReason,
@@ -588,7 +588,7 @@ export function fitJudgePayloads(
 					return { ...items[index], text: text.clipped && limit > 0 ? `${text.text}${TRUNCATION_MARKER}` : text.text };
 				}),
 			);
-			if (serializeJevRequest(payload, maxBytes) !== undefined) {
+			if (fitsClassifierRequest(payload, maxBytes)) {
 				payloads.push({ payload, items: indexes });
 				return;
 			}
@@ -673,7 +673,7 @@ interface JudgeOutcome {
 }
 
 /** Ask one noul per item, batched and fitted, within the stage's request caps. */
-async function judgeNouls(
+export async function judgeNouls(
 	requests: FindRequests,
 	stage: JudgeStage,
 	items: readonly JudgeItem[],
@@ -1329,11 +1329,7 @@ export default function jevAskToolExtension(pi: ExtensionAPI): void {
 			"Use ask_jev whenever a judgment would otherwise be a guess — what kind of failure this is, how risky a diff is, what a request is really asking for. It returns typed answers with confidences for a fraction of a cent, so it validates assumptions before they cost a wrong edit.",
 			"Prefer ask_jev over reading files when you only need a verdict about them (which of these files handles X, does this code already do Y, is this test output a code bug or a flaky test): pass them as `paths` or the command as `command`, and only the answer enters your context. Read a file yourself when you need its exact text, such as before editing it.",
 		],
-		discovery: {
-			summary: "Ask Jev one block of typed choice/score/noul questions over prose, code, and one command's output",
-			aliases: ["jev", "triage", "classify", "judge", "score"],
-			category: "Decisions",
-		},
+		exposure: "direct",
 		parameters: AskJevParams,
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx: ExtensionContext) {
@@ -1434,7 +1430,7 @@ export default function jevAskToolExtension(pi: ExtensionAPI): void {
 				...(Object.keys(files).length > 0 ? { files } : {}),
 				...(command ? { command } : {}),
 			});
-			if (serializeJevRequest(payload, route.payloadBytes) === undefined) {
+			if (!fitsClassifierRequest(payload, route.payloadBytes)) {
 				return text("ask_jev could not fit this request in its budget; pass fewer paths or a shorter command.");
 			}
 
@@ -1493,6 +1489,9 @@ export default function jevAskToolExtension(pi: ExtensionAPI): void {
 					model: config.model,
 					elapsedMs: result.elapsedMs,
 					...(result.failure ? { failure: result.failure } : {}),
+					...(result.usage ? { usage: result.usage } : {}),
+					...(result.reportedCost !== undefined ? { reportedCost: result.reportedCost } : {}),
+					...(result.unpricedUsage ? { unpricedUsage: result.unpricedUsage } : {}),
 				},
 			};
 		},
@@ -1516,11 +1515,7 @@ export default function jevAskToolExtension(pi: ExtensionAPI): void {
 			"Use grep or read instead for an exact string, a known symbol's definition, or a known filename.",
 			"When delegating repository discovery to a subagent, tell it to start with jev_find.",
 		],
-		discovery: {
-			summary: "Semantic code finder: Jev-judged relevant files and their verbatim source excerpts",
-			aliases: ["jevgrep", "jg", "find", "search", "locate"],
-			category: "Decisions",
-		},
+		exposure: "direct",
 		parameters: JevFindParams,
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx: ExtensionContext) {
@@ -1583,29 +1578,6 @@ export default function jevAskToolExtension(pi: ExtensionAPI): void {
 		},
 	});
 
-	// Offer the tools only while Jev can answer: a tool that always fails costs the agent a turn
-	// every time it reaches for it. Checked before every run, so `/tokenin add` brings them back
-	// without a reload. Silent on purpose: the one warning comes from whichever Jev path first
-	// needs the missing credential, not from every session of a user without a subscription.
-	// Only a removal made here is ever undone, so a loadout the user trimmed stays trimmed.
-	const jevTools = [ASK_JEV_TOOL, JEV_FIND_TOOL];
-	const hidden = new Set<string>();
-	pi.on("before_agent_start", async (_event, ctx) => {
-		const config = readJevAdvisoryConfig(getSettingsPath());
-		const route = config.routes.ask;
-		const offline = !route.enabled || (await jevUnavailable(ctx, jevConnection(config, route))) !== undefined;
-		const active = pi.getActiveTools();
-		if (offline) {
-			const dropping = jevTools.filter((name) => active.includes(name));
-			if (dropping.length > 0) {
-				pi.setActiveTools(active.filter((name) => !dropping.includes(name)));
-				for (const name of dropping) hidden.add(name);
-			}
-		} else if (hidden.size > 0) {
-			const restoring = [...hidden].filter((name) => !active.includes(name));
-			if (restoring.length > 0) pi.setActiveTools([...active, ...restoring]);
-			hidden.clear();
-		}
-		return undefined;
-	});
+	// Keep registered tools/loadouts stable when the service or credential is unavailable.
+	// execute() already returns a bounded actionable error; removing tools clears pending loadouts.
 }

package/dist/extensions/jev-find-source.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { chunkUnits, loadTypeScript, splitSourceUnits } from "./jev-find-source.ts";
+
+describe("TS7 source parser", () => {
+	it("keeps UTF-16 names and CRLF line positions", async () => {
+		const parser = await loadTypeScript();
+		expect(parser).toBeDefined();
+		const text = '// 😀 header\r\nexport const café = "😀";\r\n\r\nexport function retry() { return café; }\r\n';
+		expect(splitSourceUnits("sample.ts", text, parser)).toEqual([
+			{ name: "café", start: 1, end: 2 },
+			{ name: "retry", start: 4, end: 4 },
+		]);
+	});
+
+	it("parses TSX from the supplied text without needing a physical file", async () => {
+		const parser = await loadTypeScript();
+		const text = "export function View() { return <div>ready</div>; }\n";
+		expect(splitSourceUnits("not-on-disk.tsx", text, parser)).toEqual([{ name: "View", start: 1, end: 1 }]);
+	});
+
+	it("retains deterministic chunks if the optional native parser fails", () => {
+		const text = "const x = 1;\n\nconst y = 2;\n";
+		expect(splitSourceUnits("sample.ts", text, { sourceUnits() { throw new Error("parser unavailable"); } })).toEqual(chunkUnits(text));
+		expect(splitSourceUnits("sample.ts", text, undefined)).toEqual(chunkUnits(text));
+	});
+});

package/dist/extensions/jev-find-source.ts

@@ -9,10 +9,12 @@
  * Line numbers are 1-based and always the file's own: excerpts are cut from the file, never
  * reconstructed.
  */
-import { extname } from "node:path";
-import type * as TypeScript from "typescript";
+import { extname, resolve } from "node:path";
+import type * as TypeScript from "typescript/unstable/ast";
 
-type TypeScriptApi = typeof TypeScript;
+interface TypeScriptApi {
+	sourceUnits(path: string, text: string): SourceUnit[];
+}
 
 /** ponytail: 40-line chunks for non-script files; raise once Jev is measured on longer units. */
 export const FIND_CHUNK_LINES = 40;
@@ -32,15 +34,45 @@ export interface SourceUnit {
 let typeScript: Promise<TypeScriptApi | undefined> | undefined;
 
 /**
- * The TypeScript compiler, or undefined when it is not installed: it is a devDependency, so a
- * published install parses nothing and every file is chunked instead.
+ * TS7 parses through its native snapshot API, not the version-only root export.
+ * Each parse uses an isolated in-memory project: no repo config/imports are read,
+ * no files are written, and the snapshot/client are closed before returning.
+ * TypeScript is optional (a devDependency); published installs still use chunks.
  */
 export function loadTypeScript(): Promise<TypeScriptApi | undefined> {
-	typeScript ??= import("typescript").then(
-		(module: unknown) => {
-			const api = ((module as { default?: TypeScriptApi }).default ?? module) as TypeScriptApi;
-			return typeof api.createSourceFile === "function" ? api : undefined;
-		},
+	typeScript ??= Promise.all([import("typescript/unstable/sync"), import("typescript/unstable/ast")]).then(
+		([{ API }, ast]) => ({
+			sourceUnits(path: string, text: string): SourceUnit[] {
+				const normalize = (value: string) => value.replaceAll("\\", "/");
+				const baseDir = normalize(resolve(process.cwd(), ".selesai-jev-parser"));
+				const fileName = `${baseDir}/source${extname(path)}`;
+				const config = `${baseDir}/tsconfig.json`;
+				const files = new Map([
+					[fileName, text],
+					[config, JSON.stringify({ files: [fileName], compilerOptions: { noLib: true, noResolve: true, allowJs: true, jsx: "preserve" } })],
+				]);
+				const api = new API({
+					fs: {
+						fileExists: (name) => files.has(normalize(name)),
+						readFile: (name) => files.get(normalize(name)) ?? null,
+						directoryExists: (name) => baseDir === normalize(name) || baseDir.startsWith(`${normalize(name)}/`),
+						getAccessibleEntries: () => ({ files: [], directories: [] }),
+						realpath: normalize,
+					},
+				});
+				try {
+					const snapshot = api.updateSnapshot({ openProjects: [config] });
+					try {
+						const source = snapshot.getProject(config)?.program.getSourceFile(fileName);
+						return source ? scriptUnits(ast, text, source) : [];
+					} finally {
+						snapshot.dispose();
+					}
+				} finally {
+					api.close();
+				}
+			},
+		}),
 		() => undefined,
 	);
 	return typeScript;
@@ -65,7 +97,7 @@ export function splitSourceUnits(path: string, text: string, ts: TypeScriptApi |
 	const kind = SCRIPT_KINDS[extname(path).toLowerCase()];
 	if (ts && kind) {
 		try {
-			const units = scriptUnits(ts, path, text, ts.ScriptKind[kind]);
+			const units = ts.sourceUnits(path, text);
 			if (units.length > 0) return units;
 		} catch {
 			// A parser crash on odd input falls back to chunks; the file is still readable.
@@ -79,15 +111,16 @@ function firstLine(text: string): string {
 	return line.trim().slice(0, UNIT_NAME_CHARS);
 }
 
-function scriptUnits(ts: TypeScriptApi, path: string, text: string, kind: TypeScript.ScriptKind): SourceUnit[] {
-	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kind);
+function scriptUnits(ts: typeof TypeScript, text: string, source: TypeScript.SourceFile): SourceUnit[] {
+	const tokenStart = (node: TypeScript.Node) => ts.getTokenPosOfNode(node, source);
+	const nodeText = (node: TypeScript.Node) => text.slice(tokenStart(node), node.end);
 	const lineOf = (pos: number) => source.getLineAndCharacterOfPosition(pos).line + 1;
 	/**
 	 * A node's first line, counting the comments directly above it: a comment separated by a blank
 	 * line (a section banner) or sitting on the previous node's last line (`a(); // note`) is not its own.
 	 */
 	const startOf = (node: TypeScript.Node, floor: number): number => {
-		let start = lineOf(node.getStart(source));
+		let start = lineOf(tokenStart(node));
 		const comments = ts.getLeadingCommentRanges(text, node.pos) ?? [];
 		for (let i = comments.length - 1; i >= 0; i -= 1) {
 			const comment = comments[i];
@@ -98,14 +131,20 @@ function scriptUnits(ts: TypeScriptApi, path: string, text: string, kind: TypeSc
 		return start;
 	};
 	const nameOf = (node: TypeScript.Node): string => {
-		const named = (node as { name?: TypeScript.Node }).name;
-		if (named) return named.getText(source);
+		if (
+			ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node) ||
+			ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node) ||
+			ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node) ||
+			ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)
+		) {
+			if (node.name) return nodeText(node.name);
+		}
 		if (ts.isVariableStatement(node)) {
-			return node.declarationList.declarations.map((declaration) => declaration.name.getText(source)).join(", ");
+			return node.declarationList.declarations.map((declaration) => nodeText(declaration.name)).join(", ");
 		}
 		if (ts.isConstructorDeclaration(node)) return "constructor";
 		if (ts.isExportAssignment(node)) return "export default";
-		return firstLine(node.getText(source));
+		return firstLine(nodeText(node));
 	};
 
 	const units: SourceUnit[] = [];
@@ -125,7 +164,7 @@ function scriptUnits(ts: TypeScriptApi, path: string, text: string, kind: TypeSc
 		const members = container?.members;
 		if (container && members && members.length > 0 && end - start + 1 > FIND_CHUNK_LINES) {
 			const owner = nameOf(container);
-			const header = lineOf((container.name ?? container).getStart(source));
+			const header = lineOf(tokenStart(container.name ?? container));
 			let memberFloor = header;
 			for (const member of members) {
 				const memberStart = startOf(member, memberFloor);