feat: export SchemaTypeGenerator - #176

diff --git a/src/groqFiles/__tests__/resources.test.ts b/src/groqFiles/__tests__/resources.test.ts
--- a/src/groqFiles/__tests__/resources.test.ts
+++ b/src/groqFiles/__tests__/resources.test.ts
@@ -142,6 +142,28 @@
     ])
   })
 
+  test('scores specificity by the matching path, not a longer sibling on the same resource', async () => {
+    const dir = await project({
+      'schema.json': await readFile(SCHEMA, 'utf8'),
+      'shop/schema.json': SHOP_SCHEMA,
+    })
+    const resolved = await resolveGroqFiles({
+      options: {
+        resources: [
+          {path: ['src', 'packages/very-long-name'], schema: './schema.json'},
+          {path: 'src/blog', schema: 'shop/schema.json'},
+        ],
+        schema: './schema.json',
+      },
+      root: dir,
+    })
+    const schemaPathFor = (file: string) => schemaFor(resolved, join(dir, file)).schemaPath
+
+    expect(schemaPathFor('src/blog/posts.groq')).toBe(join(dir, 'shop', 'schema.json'))
+    expect(schemaPathFor('src/other/page.groq')).toBe(join(dir, 'schema.json'))
+    expect(schemaPathFor('packages/very-long-name/x.groq')).toBe(join(dir, 'schema.json'))
+  })
+
   test('requires absolute paths when there is no root to resolve against', async () => {
     const dir = await project({'schema.json': await readFile(SCHEMA, 'utf8')})
     const none = await resolveGroqFiles({options: {}})

diff --git a/src/groqFiles/resources.ts b/src/groqFiles/resources.ts
--- a/src/groqFiles/resources.ts
+++ b/src/groqFiles/resources.ts
@@ -123,8 +123,11 @@
 export interface ResolvedGroqFileResource extends GroqFileSchema {
   /** Whether this resource types `file`, an absolute path. */
   claims: (file: string) => boolean
-  /** How specific the resource is: the longest matching `path` wins. */
-  specificity: number
+  /**
+   * How specific this resource is for `file`: the length of its longest `path` that claims the
+   * file. Used so a nested folder can override a parent when both resources match.
+   */
+  specificity: (file: string) => number
 }
 
 /** `GroqFilesOptions` with every path resolved and every schema read. */
@@ -194,12 +197,20 @@
     const paths = Array.isArray(resource.path) ? resource.path : [resource.path]
     const matchers = paths.flatMap((path) => {
       const located = locate(path)
-      return located === undefined ? [] : [matcher(root ?? parse(located).root, located)]
+      return located === undefined
+        ? []
+        : [{matches: matcher(root ?? parse(located).root, located), specificity: path.length}]
     })
     resources.push({
       ...schema,
-      claims: (file) => matchers.some((matches) => matches(file)),
-      specificity: Math.max(...paths.map((path) => path.length)),
+      claims: (file) => matchers.some(({matches}) => matches(file)),
+      specificity: (file) => {
+        let best = -1
+        for (const {matches, specificity} of matchers) {
+          if (matches(file) && specificity > best) best = specificity
+        }
+        return best
+      },
     })
   }
 
@@ -214,9 +225,10 @@
   let best: GroqFileSchema = resolved.fallback
   let specificity = -1
   for (const resource of resolved.resources) {
-    if (resource.specificity > specificity && resource.claims(file)) {
+    const resourceSpecificity = resource.specificity(file)
+    if (resourceSpecificity > specificity) {
       best = resource
-      specificity = resource.specificity
+      specificity = resourceSpecificity
     }
   }
   return best

diff --git a/src/groqFiles/__tests__/groqModule.test.ts b/src/groqFiles/__tests__/groqModule.test.ts
--- a/src/groqFiles/__tests__/groqModule.test.ts
+++ b/src/groqFiles/__tests__/groqModule.test.ts
@@ -208,3 +208,62 @@
     expect(code).not.toContain('type QueryResponse_2')
   })
 })
+
+describe('TypeGenerator.generateGroqModule with a schema type named Array or Record', () => {
+  const schema = [
+    {
+      attributes: {
+        _id: {type: 'objectAttribute', value: {type: 'string'}},
+        _type: {type: 'objectAttribute', value: {type: 'string', value: 'record'}},
+        title: {type: 'objectAttribute', value: {type: 'string'}},
+      },
+      name: 'record',
+      type: 'document' as const,
+    },
+    {
+      attributes: {
+        _id: {type: 'objectAttribute', value: {type: 'string'}},
+        _type: {type: 'objectAttribute', value: {type: 'string', value: 'array'}},
+        title: {type: 'objectAttribute', value: {type: 'string'}},
+      },
+      name: 'array',
+      type: 'document' as const,
+    },
+    {
+      attributes: {
+        _id: {type: 'objectAttribute', value: {type: 'string'}},
+        _type: {type: 'objectAttribute', value: {type: 'string', value: 'post'}},
+        arr: {type: 'objectAttribute', value: {name: 'array', type: 'inline'}},
+        title: {type: 'objectAttribute', value: {type: 'string'}},
+      },
+      name: 'post',
+      type: 'document' as const,
+    },
+  ]
+
+  test('does not emit unused Array/Record aliases that would shadow the builtins', () => {
+    const {code} = new TypeGenerator().generateGroqModule({
+      content: '*[_type == "post"]{title}',
+      filename: 'posts.groq',
+      schema,
+    })
+    expect(code).toContain('export type QueryResponse = Array<{')
+    expect(code).toContain('export type QueryParams = Record<string, never>;')
+    expect(code).not.toMatch(/^type Array\b/m)
+    expect(code).not.toMatch(/^type Record\b/m)
+  })
+
+  test('renames a referenced Array alias so the Array builtin stays generic', () => {
+    const {code} = new TypeGenerator().generateGroqModule({
+      content: '*[_type == "post"]{arr}',
+      filename: 'posts.groq',
+      schema,
+    })
+    expect(code).toContain('type Array_2 = {')
+    expect(code).toContain('arr: Array_2;')
+    expect(code).toContain('export type QueryResponse = Array<{')
+    expect(code).not.toMatch(/^type Array =/m)
+    expect(code).toContain('export type QueryParams = Record<string, never>;')
+    expect(code).not.toMatch(/^type Record\b/m)
+  })
+})

diff --git a/src/groqFiles/groqModule.ts b/src/groqFiles/groqModule.ts
--- a/src/groqFiles/groqModule.ts
+++ b/src/groqFiles/groqModule.ts
@@ -17,8 +17,14 @@
 export const GROQ_RESULT_BRAND = '__groqResult'
 export const GROQ_PARAMS_BRAND = '__groqParams'
 
+/**
+ * Lib generics the module writes itself (`Array<…>`, `Record<…>`). A schema alias with the same
+ * name would shadow them and break every list result and empty-params type.
+ */
+const BUILTIN_GENERICS = new Set(['Array', 'Record'])
+
 /** Names a module declares itself, which a schema type alias cannot take. */
-const MODULE_NAMES = new Set(['query', QUERY_PARAMS, QUERY_RESPONSE])
+const MODULE_NAMES = new Set(['query', QUERY_PARAMS, QUERY_RESPONSE, ...BUILTIN_GENERICS])
 
 /**
  * Why a `.groq` file could not be typed, or not entirely. Reported by the content mapper with
@@ -288,6 +294,17 @@
 }
 
 function visitIdentifiers(node: t.Node, visit: (identifier: t.Identifier) => void): void {
+  // `Array<T>` / `Record<K, V>` name the lib generics, not schema aliases — skip the type name so
+  // collectReferences does not pull those aliases in, and renamed does not rewrite the builtins.
+  if (
+    t.isTSTypeReference(node) &&
+    node.typeParameters &&
+    t.isIdentifier(node.typeName) &&
+    BUILTIN_GENERICS.has(node.typeName.name)
+  ) {
+    visitIdentifiers(node.typeParameters, visit)
+    return
+  }
   if (t.isIdentifier(node)) {
     visit(node)
     return