limina 0.1.3 → 0.2.0

package/bin/limina.js

@@ -1,26 +1,22 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const packageDir = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
 const distCliPath = path.join(packageDir, 'cli.js');
 const sourceCliPath = path.join(packageDir, 'src/cli.ts');
-const tsxBinName = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
-const tsxCliPath =
-  [
-    path.join(packageDir, 'node_modules/.bin', tsxBinName),
-    path.join(packageDir, '../../node_modules/.bin', tsxBinName),
-  ].find((candidate) => existsSync(candidate)) ?? 'tsx';
+const require = createRequire(import.meta.url);
 
 if (existsSync(sourceCliPath)) {
+  const tsxCliPath = require.resolve('tsx/cli');
   const result = spawnSync(
-    tsxCliPath,
-    [sourceCliPath, ...process.argv.slice(2)],
+    process.execPath,
+    [tsxCliPath, sourceCliPath, ...process.argv.slice(2)],
     {
       stdio: 'inherit',
-      shell: process.platform === 'win32',
     },
   );
 

package/checker-host-process.js

@@ -0,0 +1,49 @@
+import { t as spawnAndMeasure } from "./chunks/dep-BOg2f5FD.js";
+//#region src/typecheck/host-process.ts
+const PARENT_LIVENESS_TIMEOUT_MS = 3e4;
+const PARENT_LIVENESS_CHECK_INTERVAL_MS = 5e3;
+const liveCheckerChildren = /* @__PURE__ */ new Set();
+let pendingSpawnCount = 0;
+let lastParentSignalAt = Date.now();
+function exitWithCheckerCleanup() {
+	for (const child of liveCheckerChildren) if (child.exitCode === null && child.signalCode === null) child.kill();
+	process.exit(0);
+}
+function send(message) {
+	if (typeof process.send !== "function") return;
+	try {
+		process.send(message);
+	} catch {
+		exitWithCheckerCleanup();
+	}
+}
+process.on("message", (request) => {
+	lastParentSignalAt = Date.now();
+	if (request.type !== "spawn") return;
+	if (process.env.LIMINA_CHECKER_HOST_TEST_CRASH === "1") process.exit(1);
+	pendingSpawnCount += 1;
+	spawnAndMeasure(request, { onChild: (child) => {
+		liveCheckerChildren.add(child);
+		child.on("close", () => {
+			liveCheckerChildren.delete(child);
+		});
+	} }).then((measurement) => {
+		pendingSpawnCount -= 1;
+		send({
+			durationMs: measurement.durationMs,
+			...measurement.error ? { errorMessage: measurement.error.message } : {},
+			id: request.id,
+			status: measurement.status,
+			type: "result"
+		});
+	});
+});
+process.on("disconnect", () => {
+	exitWithCheckerCleanup();
+});
+setInterval(() => {
+	if (pendingSpawnCount === 0 && Date.now() - lastParentSignalAt > PARENT_LIVENESS_TIMEOUT_MS) exitWithCheckerCleanup();
+}, PARENT_LIVENESS_CHECK_INTERVAL_MS);
+send({ type: "ready" });
+//#endregion
+export {};

package/chunks/dep-BOg2f5FD.js

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+//#region src/typecheck/host-protocol.ts
+/**
+* Spawns one checker command and measures its lifetime from spawn until the
+* close/error event. The measurement is only accurate when the surrounding
+* event loop stays responsive while the child runs, so the checker host
+* process is the primary caller; the parent CLI process uses it directly only
+* as the degraded in-process fallback.
+*/
+function spawnAndMeasure(spec, options = {}) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const startedAt = performance.now();
+		const finalize = (measurement) => {
+			if (settled) return;
+			settled = true;
+			resolve(measurement);
+		};
+		const child = spawn(spec.command, spec.args, {
+			cwd: spec.cwd,
+			env: spec.env,
+			shell: spec.shell,
+			stdio: spec.stdio
+		});
+		options.onChild?.(child);
+		child.on("error", (error) => {
+			finalize({
+				durationMs: performance.now() - startedAt,
+				error,
+				status: 1
+			});
+		});
+		child.on("close", (code) => {
+			finalize({
+				durationMs: performance.now() - startedAt,
+				status: code ?? 1
+			});
+		});
+	});
+}
+//#endregion
+export { spawnAndMeasure as t };