@orkestrel/probe 0.0.8 → 0.0.10

package/dist/src/server/index.cjs

@@ -732,6 +732,15 @@ function releaseListeners(emitter, capture) {
 * is what makes a resident tool re-read a path this overlay holds, so two inspections that supply
 * different text for one path never share a cached answer.
 *
+* This overlay matches a lookup key the way the host its stage declares to its tool matches file
+* names. A host that resolves two spellings of one file name to one file leaves the tool holding
+* whichever spelling it met first — the disk one, where the file is on disk — and the tool asks
+* under that, so an overlay matching keys exactly answers nothing and the tool reads the committed
+* file instead. Mint the overlay with the sensitivity the stage declares, and one reading decides
+* both. The recorded spelling is what `paths` reports and what `covers` matches a directory
+* against, so a folded key never reaches the paths a tool is handed and containment stays an exact
+* comparison.
+*
 * @example
 * ```ts
 * const overlay = new Overlay()
@@ -742,22 +751,36 @@ function releaseListeners(emitter, capture) {
 */
 var Overlay = class {
 	#revision = (0, node_crypto.randomUUID)();
+	#sensitive;
 	#candidates = /* @__PURE__ */ new Map();
+	/**
+	* Creates an empty candidate set under a fresh identity.
+	*
+	* @param options - Construction options
+	*/
+	constructor(options = {}) {
+		this.#sensitive = options.sensitive ?? true;
+	}
 	get revision() {
 		return this.#revision;
 	}
 	get paths() {
-		return [...this.#candidates.keys()];
+		return [...this.#candidates.values()].map(([path]) => path);
 	}
 	/**
 	* Records one candidate's text against the absolute path it stands in for.
 	*
+	* @remarks
+	* Recording a candidate under a path this overlay's own matching reads as one already recorded
+	* replaces that candidate, the way one file holds one text.
+	*
 	* @param path - The absolute path the candidate replaces
 	* @param text - The candidate's full contents
 	* @returns Nothing
 	*/
 	set(path, text) {
-		this.#candidates.set(normalizePath(path), text);
+		const recorded = normalizePath(path);
+		this.#candidates.set(this.#key(recorded), [recorded, text]);
 	}
 	/**
 	* Reads the candidate text recorded for one absolute path.
@@ -766,7 +789,7 @@ var Overlay = class {
 	* @returns The recorded text, or `undefined` when this overlay holds no candidate there
 	*/
 	text(path) {
-		return this.#candidates.get(normalizePath(path));
+		return this.#candidates.get(this.#key(normalizePath(path)))?.[1];
 	}
 	/**
 	* Checks whether a candidate sits beneath one directory.
@@ -775,14 +798,16 @@ var Overlay = class {
 	* The answer is derived from the paths the overlay holds rather than stored, so it stops being
 	* true exactly when the inspection that declared those candidates clears them. Both sides pass
 	* through `normalizePath` first, because a tool that normalizes its own paths asks about a
-	* directory in a spelling the recorded path may not share.
+	* directory in a spelling the recorded path may not share. Case is never folded here: this is a
+	* containment comparison, and it reads the recorded spelling whatever an overlay minted for a
+	* case-folding host matches its lookup keys by.
 	*
 	* @param directory - The absolute directory path to check
 	* @returns True if a candidate path sits beneath the directory; false otherwise
 	*/
 	covers(directory) {
 		const base = `${normalizePath(directory).replace(/\/+$/, "")}/`;
-		for (const path of this.#candidates.keys()) if (path.startsWith(base)) return true;
+		for (const [path] of this.#candidates.values()) if (path.startsWith(base)) return true;
 		return false;
 	}
 	/**
@@ -793,10 +818,13 @@ var Overlay = class {
 	clear() {
 		this.#candidates.clear();
 	}
+	#key(path) {
+		return this.#sensitive ? path : path.toLowerCase();
+	}
 };
 //#endregion
 //#region package.json
-var version = "0.0.8";
+var version = "0.0.10";
 var peerDependencies = {
 	"oxlint": "^1.77.0",
 	"typescript": "^6.0.0",
@@ -1770,7 +1798,7 @@ var TypeStage = class {
 			this.#configure(this.#service(typescript, selection.project), selection.project);
 			await this.#unblock();
 		}
-		const overlay = new Overlay();
+		const overlay = new Overlay({ sensitive: this.#caseSensitive(typescript) });
 		this.#overlay = overlay;
 		try {
 			this.#record(subject.test, overlay);