@alint-js/core 0.7.0 → 0.7.1

package/dist/index.mjs

@@ -14,6 +14,7 @@ import lockfile from "proper-lockfile";
 import { isNodeErrorCode } from "@alint-js/utils/node";
 import { errorMessageFrom } from "@moeru/std/error";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { setImmediate } from "node:timers/promises";
 import { streamText } from "@xsai/stream-text";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
@@ -270,7 +271,7 @@ function mergeStopGateConfig(resolved, item) {
 }
 //#endregion
 //#region package.json
-var version = "0.7.0";
+var version = "0.7.1";
 //#endregion
 //#region src/core/cache/types.ts
 const CACHE_MAGIC = "ALINT_CACHE";
@@ -2363,88 +2364,14 @@ function projectExecution(runtime) {
 //#endregion
 //#region src/core/source/planner.ts
 /**
-* Converts one rich extractor result into detached descriptors and admits its compact jobs.
-*
-* The returned outcome promise captures only cache ownership and hashes. This function does not
-* await rule execution, so its `SourceFile`, parser output, and rich targets become unreachable
-* when planning returns.
-*/
-async function planSource(input, options) {
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let file;
-	try {
-		file = await options.src.readFile(input.path);
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let targets;
-	try {
-		targets = await input.language.extract(file, {
-			cwd: options.cwd,
-			languageOptions: input.languageOptions,
-			src: options.src
-		});
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	const { contentHash } = file;
-	let cacheOwner;
-	let jobs;
-	let project;
-	try {
-		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
-		cacheOwner = options.cacheStore.beginOwner({
-			kind: "file",
-			path: file.path
-		}, { contentHash });
-		const baseFile = {
-			contentHash,
-			language: file.language,
-			path: file.path
-		};
-		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) {
-		cacheOwner.commit({ mode: "merge" });
-		return {
-			outcomes: Promise.resolve([]),
-			project
-		};
-	}
-	const batch = options.scheduler.schedule(jobs);
-	reportFilePlanningComplete(input, batch.jobsAdded, options);
-	return {
-		outcomes: batch.outcomes.then(async (settled) => {
-			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
-			await options.cacheStore.flush();
-			return settled;
-		}),
-		project
-	};
-}
-/**
-* Starts every input plan independently and preserves input-ordered results.
+* Starts every input read independently, then batches CPU-heavy extraction and job admission.
 */
 async function planSources(inputs, options) {
-	return Promise.all(inputs.map((input) => planSource(input, {
+	const waitForPlanning = createPlanningAdmission();
+	return Promise.all(inputs.map((input) => planSourceWithAdmission(input, {
 		...options,
 		ruleRuntimes: options.createRuleRuntimes(input)
-	})));
+	}, waitForPlanning)));
 }
 function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner) {
 	const resolveIdentity = createTargetIdentityResolver(targets.map((target) => ({
@@ -2499,6 +2426,28 @@ function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner)
 		};
 	});
 }
+function createPlanningAdmission() {
+	const batchSize = 32;
+	let admitted = 0;
+	let pendingYield;
+	return async () => {
+		let currentPendingYield = pendingYield;
+		while (currentPendingYield) {
+			await currentPendingYield;
+			currentPendingYield = pendingYield;
+		}
+		admitted += 1;
+		if (admitted < batchSize) return;
+		admitted = 0;
+		const currentYield = setImmediate();
+		pendingYield = currentYield;
+		try {
+			await currentYield;
+		} finally {
+			if (pendingYield === currentYield) pendingYield = void 0;
+		}
+	};
+}
 function createProjectSnapshot(input, language, path, contentHash, targets) {
 	return {
 		configHash: input.configHash,
@@ -2570,6 +2519,76 @@ function fileFailure(input, kind, message) {
 		message
 	};
 }
+async function planSourceWithAdmission(input, options, waitForPlanning) {
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let file;
+	try {
+		file = await options.src.readFile(input.path);
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	await waitForPlanning?.();
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let targets;
+	try {
+		targets = await input.language.extract(file, {
+			cwd: options.cwd,
+			languageOptions: input.languageOptions,
+			src: options.src
+		});
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	const { contentHash } = file;
+	let cacheOwner;
+	let jobs;
+	let project;
+	try {
+		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
+		cacheOwner = options.cacheStore.beginOwner({
+			kind: "file",
+			path: file.path
+		}, { contentHash });
+		const baseFile = {
+			contentHash,
+			language: file.language,
+			path: file.path
+		};
+		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) {
+		cacheOwner.commit({ mode: "merge" });
+		return {
+			outcomes: Promise.resolve([]),
+			project
+		};
+	}
+	const batch = options.scheduler.schedule(jobs);
+	reportFilePlanningComplete(input, batch.jobsAdded, options);
+	return {
+		outcomes: batch.outcomes.then(async (settled) => {
+			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
+			await options.cacheStore.flush();
+			return settled;
+		}),
+		project
+	};
+}
 function reportFilePlanningComplete(input, jobsAdded, options) {
 	try {
 		const progress = options.scheduler.completeFilePlanning();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Public rule and plugin SDK and run engine for alint",
   "license": "MIT",
   "repository": {
@@ -56,7 +56,7 @@
     "pathe": "^2.0.3",
     "proper-lockfile": "4.1.2",
     "valibot": "^1.4.2",
-    "@alint-js/utils": "0.7.0"
+    "@alint-js/utils": "0.7.1"
   },
   "devDependencies": {
     "@types/proper-lockfile": "4.1.4",