fix(matcher): normalize . as path separator for micromatch

- Treat unescaped `.` as `/` so patterns behave like nested paths
- Keeps escaped `\.` as literal dot
- Fixes false positive where `"a.b.c.d"` matched `"*.d"`
- Ensures `"**/*.d"` works correctly for nested path cases

Author: mayank1513

lib/src/matcher.test.ts

@@ -1,52 +1,55 @@
 import { describe, it, expect } from "vitest";
 import { basicMatcher, loadMatcher } from "./matcher";
 
-describe("basicMatcher", () => {
-  it("matches exact strings", () => {
-    expect(basicMatcher.isMatch("foo.bar", ["foo.bar"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.bar", ["foo.baz"])).toBe(false);
-  });
+for (const matcherName of ["basicMatcher", "micromatch", "picomatch"] as const) {
+  describe(matcherName, async () => {
+    const matcher = matcherName === "basicMatcher" ? basicMatcher : await loadMatcher(matcherName);
+    it("matches exact strings", () => {
+      expect(matcher.isMatch("foo.bar", ["foo.bar"])).toBe(true);
+      expect(matcher.isMatch("foo.bar", ["foo.baz"])).toBe(false);
+    });
 
-  it("matches with single * segment", () => {
-    expect(basicMatcher.isMatch("foo.bar", ["foo.*"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.baz.qux", ["foo.*.qux"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.bar", ["*.baz"])).toBe(false);
-  });
+    it("matches with single * segment", () => {
+      expect(matcher.isMatch("foo.bar", ["foo.*"])).toBe(true);
+      expect(matcher.isMatch("foo.baz.qux", ["foo.*.qux"])).toBe(true);
+      expect(matcher.isMatch("foo.bar", ["*.baz"])).toBe(false);
+    });
 
-  it("matches with ** for nested paths", () => {
-    expect(basicMatcher.isMatch("a.b.c", ["a.**"])).toBe(true);
-    expect(basicMatcher.isMatch("a.b.c.d", ["a.**.d"])).toBe(true);
-    expect(basicMatcher.isMatch("a.b.c.d", ["**.d"])).toBe(true);
-    expect(basicMatcher.isMatch("a.b.c.d", ["*.d"])).toBe(false);
-    expect(basicMatcher.isMatch("a.b.c", ["**"])).toBe(true);
-  });
+    it("matches with ** for nested paths", () => {
+      expect(matcher.isMatch("a.b.c", ["a.**"])).toBe(true);
+      expect(matcher.isMatch("a.b.c.d", ["a.**.d"])).toBe(true);
+      expect(matcher.isMatch("a.b.c.d", ["**.d"])).toBe(true);
+      expect(matcher.isMatch("a.b.c.d", ["*.d"])).toBe(false);
+      expect(matcher.isMatch("a.b.c", ["**"])).toBe(true);
+    });
 
-  it("supports prefix-* and *-suffix in segments", () => {
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.hello*"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.*World"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.hel*ld"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.hel*xyz"])).toBe(false);
-  });
+    it("supports prefix-* and *-suffix in segments", () => {
+      expect(matcher.isMatch("foo.helloWorld", ["foo.hello*"])).toBe(true);
+      expect(matcher.isMatch("foo.helloWorld", ["foo.*World"])).toBe(true);
+      expect(matcher.isMatch("foo.helloWorld", ["foo.hel*ld"])).toBe(true);
+      expect(matcher.isMatch("foo.helloWorld", ["foo.hel*xyz"])).toBe(false);
+    });
 
-  it("returns true if any pattern matches", () => {
-    expect(basicMatcher.isMatch("foo.bar", ["no.match", "foo.*"])).toBe(true);
-  });
+    it("returns true if any pattern matches", () => {
+      expect(matcher.isMatch("foo.bar", ["no.match", "foo.*"])).toBe(true);
+    });
 
-  it("handles empty patterns", () => {
-    expect(basicMatcher.isMatch("foo.bar", [])).toBe(false);
-  });
+    it("handles empty patterns", () => {
+      expect(matcher.isMatch("foo.bar", [])).toBe(false);
+    });
 
-  it("respects escapes", () => {
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.hello*"])).toBe(true);
-    expect(basicMatcher.isMatch("foo.helloWorld", ["foo.hello\\*"])).toBe(false);
-    expect(basicMatcher.isMatch("foo.hello*", ["foo.hello\\*"])).toBe(true);
+    it("respects escapes", () => {
+      expect(matcher.isMatch("foo.helloWorld", ["foo.hello*"])).toBe(true);
+      expect(matcher.isMatch("foo.helloWorld", ["foo.hello\\*"])).toBe(false);
+      expect(matcher.isMatch("foo.hello*", ["foo.hello\\*"])).toBe(true);
 
-    expect(basicMatcher.isMatch("a.b.c", ["a.**"])).toBe(true);
-    expect(basicMatcher.isMatch("a.b.c", ["a.\\*\\*"])).toBe(false);
-    expect(basicMatcher.isMatch("a.**", ["a.\\*\\*"])).toBe(true);
-    expect(basicMatcher.isMatch("a.c.b", ["a.***"])).toBe(false);
+      expect(matcher.isMatch("a.b.c", ["a.**"])).toBe(true);
+      expect(matcher.isMatch("a.b.c", ["a.\\*\\*"])).toBe(false);
+      expect(matcher.isMatch("a.**", ["a.\\*\\*"])).toBe(true);
+      expect(matcher.isMatch("a.c.b", ["a.***"])).toBe(false);
+    });
   });
-});
+}
 
 describe("loadMatcher", () => {
   it("loads micromatch when available", async () => {

lib/src/matcher.ts

@@ -5,7 +5,7 @@
  * - `*`   → matches any single field segment
  * - `**`  → matches any number of nested field segments
  * - Prefix/suffix like `prefix-*`, `*-suffix`
- * - Backslash escaping (micromatch-style): `a\.b` → literal dot, `\*` → literal asterisk
+ * - Backslash escaping (micromatch-style): `a\/b` → literal slash, `\*` → literal asterisk
  *
  * Micromatch/Picomatch can be loaded at runtime as optional peers.
  */
@@ -26,7 +26,10 @@ export interface Matcher {
  * - Backslash escaping for `*` and `.`
  */
 export const basicMatcher: Matcher = {
-  isMatch: (str, patterns) => patterns.some(p => matchOne(str, p)),
+  isMatch: (str, patterns) => {
+    const internalStr = toInternal(str);
+    return patterns.some(p => matchOne(internalStr, toInternal(p)));
+  },
 };
 
 /**
@@ -50,7 +53,7 @@ export const loadMatcher = async (name: "micromatch" | "picomatch"): Promise<Mat
     return {
       isMatch: (str, pats) => {
         try {
-          return micromatch.isMatch(str, pats);
+          return micromatch.isMatch(toInternal(str), pats.map(toInternal));
         } catch (err) {
           /* v8 ignore next 4 - difficult to simulate this case with micromatch/picomatch in devDeps */
           throw new Error(`micromatch failed to run isMatch: ${(err as Error).message}`);
@@ -73,8 +76,8 @@ export const loadMatcher = async (name: "micromatch" | "picomatch"): Promise<Mat
     return {
       isMatch: (str, pats) => {
         try {
-          const fn = picomatch(pats);
-          return fn(str);
+          const fn = picomatch(pats.map(toInternal));
+          return fn(toInternal(str));
         } catch (err) {
           /* v8 ignore next 4 - difficult to simulate this case with micromatch/picomatch in devDeps */
           throw new Error(`picomatch failed to run isMatch: ${(err as Error).message}`);
@@ -88,6 +91,32 @@ export const loadMatcher = async (name: "micromatch" | "picomatch"): Promise<Mat
 
 /* ---------------- Internal helpers ---------------- */
 
+/**
+ * Convert a pattern/field path into internal form (`/` separated).
+ * - Unescaped `.` → `/`
+ * - Unescaped `/` → `/`
+ * - Escaped `\.` → `.`
+ * - Escaped `\/` → `/`
+ */
+const toInternal = (input: string): string => {
+  let out = "";
+  let escaped = false;
+  for (const ch of input) {
+    if (escaped) {
+      out += ch; // take literally
+      escaped = false;
+    } else if (ch === "\\") {
+      escaped = true;
+      out += "\\"; // preserve backslash for downstream escape handling
+    } else if (ch === ".") {
+      out += "/"; // dot becomes slash
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+};
+
 /**
  * Splits a glob pattern into dot-separated segments, honoring backslash escaping.
  * - Do not split on `\.` (literal dot remains within the same segment)
@@ -108,7 +137,7 @@ const splitPattern = (pattern: string): string[] => {
       escaped = false;
     } else if (ch === "\\") {
       escaped = true;
-    } else if (ch === ".") {
+    } else if (ch === "/") {
       segments.push(buf);
       buf = "";
     } else {
@@ -121,7 +150,7 @@ const splitPattern = (pattern: string): string[] => {
 };
 
 const matchOne = (str: string, pattern: string): boolean => {
-  const strSegments = str.split(".");
+  const strSegments = str.split("/");
   const patSegments = splitPattern(pattern);
   return matchSegments(strSegments, patSegments);
 };