@orkestrel/probe 0.0.8 → 0.0.9

package/dist/src/server/index.d.cts

@@ -448,6 +448,15 @@ export declare function normalizeValue(workspace: string, value: unknown): unkno
  * 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()
@@ -458,11 +467,21 @@ export declare function normalizeValue(workspace: string, value: unknown): unkno
  */
 export declare class Overlay implements OverlayInterface {
     #private;
+    /**
+     * Creates an empty candidate set under a fresh identity.
+     *
+     * @param options - Construction options
+     */
+    constructor(options?: OverlayOptions);
     get revision(): string;
     get paths(): readonly string[];
     /**
      * 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
@@ -482,7 +501,9 @@ export declare class Overlay implements OverlayInterface {
      * 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
@@ -561,6 +582,22 @@ export declare interface OverlayInterface {
     clear(): void;
 }
 
+/**
+ * Carries the construction options `Overlay` accepts.
+ *
+ * @example
+ * ```ts
+ * const options: OverlayOptions = { sensitive: false }
+ * ```
+ */
+export declare interface OverlayOptions {
+    /**
+     * If `true`, a lookup key matches a recorded path exactly; if `false`, it matches with file-name
+     * case folded. Default: `true`
+     */
+    readonly sensitive?: boolean;
+}
+
 /**
  * Overwrites a file that already exists, through a descriptor that refuses a symbolic link at the
  * final component.

package/dist/src/server/index.d.ts

@@ -448,6 +448,15 @@ export declare function normalizeValue(workspace: string, value: unknown): unkno
  * 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()
@@ -458,11 +467,21 @@ export declare function normalizeValue(workspace: string, value: unknown): unkno
  */
 export declare class Overlay implements OverlayInterface {
     #private;
+    /**
+     * Creates an empty candidate set under a fresh identity.
+     *
+     * @param options - Construction options
+     */
+    constructor(options?: OverlayOptions);
     get revision(): string;
     get paths(): readonly string[];
     /**
      * 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
@@ -482,7 +501,9 @@ export declare class Overlay implements OverlayInterface {
      * 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
@@ -561,6 +582,22 @@ export declare interface OverlayInterface {
     clear(): void;
 }
 
+/**
+ * Carries the construction options `Overlay` accepts.
+ *
+ * @example
+ * ```ts
+ * const options: OverlayOptions = { sensitive: false }
+ * ```
+ */
+export declare interface OverlayOptions {
+    /**
+     * If `true`, a lookup key matches a recorded path exactly; if `false`, it matches with file-name
+     * case folded. Default: `true`
+     */
+    readonly sensitive?: boolean;
+}
+
 /**
  * Overwrites a file that already exists, through a descriptor that refuses a symbolic link at the
  * final component.

package/dist/src/server/index.js

@@ -731,6 +731,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()
@@ -741,22 +750,36 @@ function releaseListeners(emitter, capture) {
 */
 var Overlay = class {
 	#revision = 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.
@@ -765,7 +788,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.
@@ -774,14 +797,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;
 	}
 	/**
@@ -792,6 +817,9 @@ var Overlay = class {
 	clear() {
 		this.#candidates.clear();
 	}
+	#key(path) {
+		return this.#sensitive ? path : path.toLowerCase();
+	}
 };
 //#endregion
 //#region package.json
@@ -1769,7 +1797,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);