diff --git a/apps/electron/package.json b/apps/electron/package.json
index cf3edec..e96e2ac 100644
--- a/apps/electron/package.json
+++ b/apps/electron/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@gts-viewer/electron",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "GTS Viewer Electron Application",
   "main": "dist/main/main.js",
   "scripts": {
diff --git a/apps/server/package.json b/apps/server/package.json
index 844398f..40d7f05 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@gts/server",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/apps/vscode-extension/CHANGELOG.md b/apps/vscode-extension/CHANGELOG.md
index cbe09f9..426a965 100644
--- a/apps/vscode-extension/CHANGELOG.md
+++ b/apps/vscode-extension/CHANGELOG.md
@@ -2,7 +2,26 @@
 
 All notable changes to the GTS Viewer extension will be documented in this file.
 
-## [Unreleased]
+## [0.3.1] - 2026-10-26
+
+### Added
+- Explorer actions and context menus in the GTS file tree and viewer tree
+- Per-folder Rescan button in the GTS file tree (progress shown on the folder row), plus scan and validation progress at the top of the tree
+- Transitive `any-valid` validation: an instance referencing an invalid entity is reported as invalid
+
+### Changed
+- Validation rebased on `gts-ts` v0.11.0 (GTS spec 0.17): `x-gts-ref` is replaced by `x-gts-type-ref`, `x-gts-instance-ref` and `x-gts-pattern-ref`; schema regexes must follow the GTS safe regex profile; `re2.wasm` is no longer shipped
+- Much faster, non-blocking scans and validation of large workspaces (100K+ files)
+- One problem severity and standard problem decorations for all GTS problems
+
+### Fixed
+- Diagnostics anchored to the offending node instead of `$id`; fewer false positives (`gts://` in URL fields, GTS-id-shaped scalar values, `x-gts-pattern-ref` operands and `x-gts-traits` values)
+- Instances of invalid types, duplicate and malformed GTS ids are reported everywhere
+- Rescan starts immediately and fully rebuilds the GTS store; files open from the tree without delay during scans
+- Deleted files are dropped from discovery; not-yet-validated files show "validation pending" instead of green
+- Stack overflow on workspaces with 100K+ files
+- Workspace validation stalling on large workspaces when other extensions react to diagnostics changes
+
 
 ## [0.3.0] - 2026-09-18
 
diff --git a/apps/vscode-extension/README.md b/apps/vscode-extension/README.md
index 7aa5c69..26179b8 100644
--- a/apps/vscode-extension/README.md
+++ b/apps/vscode-extension/README.md
@@ -18,8 +18,7 @@ GTS supports **type derivation** through chaining: a derived type extends a base
 
 **1. Base type** -- defines the common fields every user has:
 
-```jsonc
-// file: gts.x.core.idp.user.v1~.schema.json
+```json
 {
   "$id": "gts://gts.x.core.idp.user.v1~",
   "$schema": "http://json-schema.org/draft-07/schema#",
@@ -29,7 +28,7 @@ GTS supports **type derivation** through chaining: a derived type extends a base
   "required": ["id", "type", "email", "display_name", "status"],
   "properties": {
     "id":           { "type": "string", "format": "uuid" },
-    "type":         { "type": "string", "x-gts-ref": "/$id" },
+    "type":         { "type": "string", "x-gts-type-ref": "/$id" },
     "email":        { "type": "string", "format": "email" },
     "display_name": { "type": "string" },
     "properties":   { "type": "object" }
@@ -39,8 +38,7 @@ GTS supports **type derivation** through chaining: a derived type extends a base
 
 **2. Derived type** -- extends the base with admin-specific fields. The chained `$id` shows that `platform_admin` inherits from `user`:
 
-```jsonc
-// file: gts.x.core.idp.user.v1~x.core.idp.platform_admin.v1~.schema.json
+```json
 {
   "$id": "gts://gts.x.core.idp.user.v1~x.core.idp.platform_admin.v1~",
   "$schema": "http://json-schema.org/draft-07/schema#",
@@ -67,8 +65,7 @@ GTS supports **type derivation** through chaining: a derived type extends a base
 
 **3. Instance** -- a concrete platform administrator that conforms to the derived type:
 
-```jsonc
-// file: gts.x.core.idp.user.v1~x.core.idp.platform_admin.v1~.examples.jsonc
+```json
 {
   "id": "f0e1d2c3-b4a5-6789-0123-456789abcdef",
   "type": "gts.x.core.idp.user.v1~x.core.idp.platform_admin.v1~",
diff --git a/apps/vscode-extension/build.mjs b/apps/vscode-extension/build.mjs
index 56475d5..c7b4ae5 100644
--- a/apps/vscode-extension/build.mjs
+++ b/apps/vscode-extension/build.mjs
@@ -1,29 +1,5 @@
 import * as esbuild from 'esbuild'
-import { promises as fs } from 'fs'
-import path from 'path'
-import { createRequire } from 'module'
 
-const require = createRequire(import.meta.url)
-
-/**
- * gts-ts compiles schema patterns with re2-wasm, which loads its `re2.wasm`
- * binary from the directory of the running script. Bundled, that is `dist/`,
- * so the binary must sit next to `dist/extension.js` or the extension throws
- * on load. Resolved through gts-ts so it's the exact copy gts-ts depends on.
- *
- * @type {esbuild.Plugin}
- */
-const copyRe2WasmPlugin = {
-  name: 'copy-re2-wasm',
-  setup(build) {
-    build.onEnd(async result => {
-      if (result.errors.length > 0) return
-      const gtsTsDir = path.dirname(require.resolve('@globaltypesystem/gts-ts/package.json', { paths: ['../../packages/shared'] }))
-      const re2Dir = path.dirname(require.resolve('re2-wasm/package.json', { paths: [gtsTsDir] }))
-      await fs.copyFile(path.join(re2Dir, 'build', 'wasm', 're2.wasm'), path.join('dist', 're2.wasm'))
-    })
-  },
-}
 
 const production = process.argv.includes('--production')
 const watch = process.argv.includes('--watch')
@@ -64,7 +40,6 @@ async function main() {
     mainFields: ['module', 'main'],
     plugins: [
       esbuildProblemMatcherPlugin,
-      copyRe2WasmPlugin,
     ],
   })
 
diff --git a/apps/vscode-extension/package.json b/apps/vscode-extension/package.json
index aa193d4..53ba889 100644
--- a/apps/vscode-extension/package.json
+++ b/apps/vscode-extension/package.json
@@ -2,7 +2,7 @@
   "name": "gts-kit",
   "displayName": "Global Type System (GTS) Kit",
   "description": "Global Type System (GTS) support for VS Code — browse, validate,visualize, and manage GTS schemas and instances",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": true,
   "publisher": "GlobalTypeSystem",
   "license": "Apache-2.0",
@@ -59,6 +59,12 @@
         "category": "GTS",
         "icon": "$(refresh)"
       },
+      {
+        "command": "gts-kit.rescanFolder",
+        "title": "Rescan Folder",
+        "category": "GTS",
+        "icon": "$(refresh)"
+      },
       {
         "command": "gts-kit.openToSide",
         "title": "Open to the Side"
@@ -137,7 +143,23 @@
           "when": "resourceExtname =~ /\\.(json|jsonc|gts)$/"
         }
       ],
+      "commandPalette": [
+        {
+          "command": "gts-kit.rescanFolder",
+          "when": "false"
+        }
+      ],
       "view/item/context": [
+        {
+          "command": "gts-kit.rescanFolder",
+          "group": "inline",
+          "when": "view == gts-kit.fileExplorer && viewItem == gtsFolder"
+        },
+        {
+          "command": "gts-kit.rescanFolder",
+          "group": "navigation@10",
+          "when": "view == gts-kit.fileExplorer && viewItem == gtsFolder"
+        },
         {
           "command": "gts-kit.openToSide",
           "group": "navigation@10",
diff --git a/apps/vscode-extension/src/extension.ts b/apps/vscode-extension/src/extension.ts
index 9f193f4..063fbab 100644
--- a/apps/vscode-extension/src/extension.ts
+++ b/apps/vscode-extension/src/extension.ts
@@ -4,13 +4,14 @@ import * as fs from 'fs'
 import { parseGtsFileContent, DEFAULT_GTS_CONFIG } from '@gts/shared'
 import type { EntityValidationDto, ObjValidationDto, InvalidFileValidationDto, ValidationRelayPayload } from '@gts/shared'
 import { setLastScanFiles } from './scanStore'
-import { rebuildRegistry, indexFile as indexFileInRegistry, removeFile as removeFileFromRegistry, getRegistry } from './registryStore'
+import { rebuildRegistry, indexFile as indexFileInRegistry, indexFiles, removeFile as removeFileFromRegistry, getRegistry, getPathsWithMalformedIds, type RegistryFileInput } from './registryStore'
 import { getWorkspaceIgnore, resetWorkspaceIgnore, isGitIgnored, type FolderIgnore } from './gitignore'
 import { WorkspaceLayoutStorage } from './storage'
-import { initValidation, resetValidationDiagnostics, validateOpenDocument, validateWorkspaceInBackground, revalidateDependents, onValidationCompleted } from './validation'
+import { initValidation, resetValidationDiagnostics, validateOpenDocument, validateWorkspaceInBackground, revalidateDependents, revalidateFiles, onValidationCompleted, forgetValidationState, whenWorkspaceValidationIdle } from './validation'
 import { isGtsCandidateFile, isIndexableGtsDocument } from './helpers'
 import { GtsLinkProvider } from './linkProvider'
-import { registerGtsExplorer, type GtsExplorer } from './gtsExplorer'
+import { registerGtsExplorer, type GtsExplorer, type GtsTreeElement, type FolderProgress } from './gtsExplorer'
+import { TimeSlicer, CancelledError, filterSliced, yieldToEventLoop } from './timeSlice'
 import type { LayoutSaveRequest, LayoutTarget, LayoutSnapshot } from '@gts/layout-storage'
 
 // Glob used for all GTS workspace scans and the on-disk file watcher.
@@ -97,7 +98,10 @@ async function findGtsFiles(ignores: Map<string, FolderIgnore>, baseExclude: str
     if (capPerFolder !== undefined && found.length >= capPerFolder) {
       console.warn(`[GTS] Phase 1 hit its ${capPerFolder}-file cap in "${folder.name}"; the rest is indexed by phase 2`)
     }
-    uris.push(...found)
+    // Not `uris.push(...found)`: spreading passes every element as a call
+    // argument, which overflows the stack ("Maximum call stack size exceeded")
+    // once a folder holds more than ~120K files.
+    for (const uri of found) uris.push(uri)
   }
   return uris
 }
@@ -110,33 +114,38 @@ async function findGtsFiles(ignores: Map<string, FolderIgnore>, baseExclude: str
 // once and let the most-recently-scanned/edited path win (so an open file, which
 // is scanned first, stays canonical and gets its in-editor diagnostics).
 const realPathIndex = new Map<string, string>()
+// Reverse of realPathIndex (indexed path -> real path), so forgetting a path is
+// a lookup instead of a scan of every indexed file.
+const realPathOfIndexedPath = new Map<string, string>()
+
+function setCanonicalPath(real: string, fsPath: string): void {
+  const previous = realPathIndex.get(real)
+  if (previous !== undefined) realPathOfIndexedPath.delete(previous)
+  realPathIndex.set(real, fsPath)
+  realPathOfIndexedPath.set(fsPath, real)
+}
+
+function clearCanonicalPaths(): void {
+  realPathIndex.clear()
+  realPathOfIndexedPath.clear()
+}
 
 /** Resolve a path to its canonical real path; fall back to the input on error. */
 function resolveRealPath(fsPath: string): string {
   try { return fs.realpathSync.native(fsPath) } catch { return fsPath }
 }
 
-/** Drop any canonical-path entries that point at `fsPath` (on delete/rename). */
-function forgetIndexedPath(fsPath: string): void {
-  for (const [real, p] of realPathIndex) {
-    if (p === fsPath) realPathIndex.delete(real)
-  }
+/** Async resolveRealPath, for bulk scans (the sync one blocked the extension host for seconds). */
+async function resolveRealPathAsync(fsPath: string): Promise<string> {
+  try { return await fs.promises.realpath(fsPath) } catch { return fsPath }
 }
 
-/**
- * Keep only one URI per physical file, recording the canonical path chosen.
- * First-seen wins, so callers should pass higher-priority paths (open files)
- * first. Duplicates reached through other symlinks are dropped.
- */
-function dedupeUrisByRealPath(uris: vscode.Uri[]): vscode.Uri[] {
-  const out: vscode.Uri[] = []
-  for (const uri of uris) {
-    const real = resolveRealPath(uri.fsPath)
-    if (realPathIndex.has(real)) continue
-    realPathIndex.set(real, uri.fsPath)
-    out.push(uri)
-  }
-  return out
+/** Drop the canonical-path entry that points at `fsPath` (on delete/rename). */
+function forgetIndexedPath(fsPath: string): void {
+  const real = realPathOfIndexedPath.get(fsPath)
+  if (real === undefined) return
+  realPathOfIndexedPath.delete(fsPath)
+  if (realPathIndex.get(real) === fsPath) realPathIndex.delete(real)
 }
 
 /**
@@ -152,7 +161,7 @@ function claimCanonicalPath(fsPath: string): void {
     removeFileFromRegistry(existing)
     forgetIndexedPath(existing)
   }
-  realPathIndex.set(real, fsPath)
+  setCanonicalPath(real, fsPath)
 }
 
 let viewerPanel: vscode.WebviewPanel | null = null
@@ -172,6 +181,57 @@ function enqueueScan(operation: () => Promise<void>): Promise<void> {
   return run
 }
 
+// Bumped by every full scan request. Queued and running scans (full or folder)
+// check it at each time slice and stop once a newer full scan was requested,
+// so a Rescan click takes over right away instead of waiting behind them.
+let scanGeneration = 0
+
+/**
+ * Run a scan step in the scan queue. With a `status`, the GTS files view
+ * shows its progress bar and the status from the moment this is called, even
+ * while the step still waits in the queue (folder rescans report progress on
+ * their own row instead). The step is abandoned (at its next time slice) when
+ * a newer full scan supersedes `generation`.
+ */
+async function runScan(status: string | undefined, generation: number, step: (slicer: TimeSlicer) => Promise<void>): Promise<void> {
+  const isCurrent = () => generation === scanGeneration
+  const run = () => enqueueScan(async () => {
+    if (!isCurrent()) return
+    if (status) gtsExplorer?.setScanStatus(status)
+    // Let the progress bar and status reach the UI before the heavy lifting.
+    await yieldToEventLoop()
+    pathsTouchedDuringScan = new Set()
+    try {
+      await step(new TimeSlicer(() => !isCurrent()))
+    } catch (error) {
+      if (!(error instanceof CancelledError)) throw error
+      console.log('[GTS] Scan superseded by a newer one')
+    } finally {
+      pathsTouchedDuringScan = null
+      if (status && isCurrent()) gtsExplorer?.setScanStatus(undefined)
+    }
+  })
+  if (!status) return run()
+  gtsExplorer?.setScanStatus(status)
+  await vscode.window.withProgress({ location: { viewId: 'gts-kit.fileExplorer' } }, run)
+}
+
+/** Calls `report(done)` at most every 200ms (and always for the last file). */
+function throttledProgress(total: number, report: (done: number) => void): (done: number) => void {
+  let last = 0
+  return done => {
+    const now = Date.now()
+    if (done < total && now - last < 200) return
+    last = now
+    report(done)
+  }
+}
+
+/** Reports "<label> N / M" as the view's status. */
+function fileProgress(label: string, total: number): (done: number) => void {
+  return throttledProgress(total, done => gtsExplorer?.setScanStatus(`${label} ${done.toLocaleString()} / ${total.toLocaleString()}`))
+}
+
 // Paths changed by live events (editor edits, on-disk changes, renames, closes)
 // while a full scan is in flight. The scan's snapshot may predate those events,
 // so instead of discarding the whole scan and starting over (which never
@@ -197,6 +257,7 @@ function indexFileText(fsPath: string, text: string): void {
 function dropFileFromRegistry(fsPath: string): void {
   removeFileFromRegistry(fsPath)
   forgetIndexedPath(fsPath)
+  forgetValidationState(fsPath)
 }
 
 /**
@@ -262,7 +323,11 @@ function getNonce(): string {
  */
 async function scanAndPost(refreshFilePath?: string | null, fullRescan: boolean = false): Promise<void> {
   if (fullRescan) await performInitialScan(true)
-  // Queued behind any scan in flight, so the viewer never gets a partial registry.
+  // Wait for any scan in flight and for the validation pass it started (scans
+  // don't hold the queue while validating), then post from inside the queue,
+  // so the viewer never gets a partial registry or unvalidated entities.
+  await enqueueScan(async () => {})
+  await whenWorkspaceValidationIdle()
   await enqueueScan(() => postRegistryToViewer(refreshFilePath))
 }
 
@@ -498,6 +563,15 @@ export async function activate(context: vscode.ExtensionContext) {
         console.error('[GTS] Full refresh failed:', error)
         vscode.window.showErrorMessage(`Failed to refresh GTS files: ${error?.message || String(error)}`)
       }
+    }),
+    vscode.commands.registerCommand('gts-kit.rescanFolder', async (element?: GtsTreeElement) => {
+      if (element?.kind !== 'folder') return
+      try {
+        await rescanFolder(element.fsPath)
+      } catch (error: any) {
+        console.error('[GTS] Folder rescan failed:', error)
+        vscode.window.showErrorMessage(`Failed to rescan GTS folder: ${error?.message || String(error)}`)
+      }
     })
   )
 
@@ -572,41 +646,64 @@ function collectOpenGtsPaths(): string[] {
 }
 
 /**
- * Read the given files, keeping only those that can contain a GTS id.
+ * Read the given files, keeping only those that can contain a GTS id, one per
+ * physical file.
  *
  * The `gts.` substring pre-filter avoids parsing the (potentially huge) majority
  * of JSON files that have nothing to do with GTS. For files open in the editor we
  * use the live buffer so unsaved edits are reflected.
+ *
+ * Symlinked duplicates collapse to the first path given (callers pass
+ * higher-priority paths, e.g. open files, first), which is recorded as the
+ * canonical path; paths of physical files already indexed are skipped. Real
+ * paths are resolved asynchronously alongside the reads: resolving them
+ * synchronously up front blocked the extension host for seconds on large
+ * workspaces.
  */
 async function readGtsCandidateFiles(
-  uris: vscode.Uri[]
-): Promise<Array<{ path: string; name: string; content: any }>> {
+  uris: vscode.Uri[],
+  slicer: TimeSlicer,
+  onProgress?: (done: number) => void
+): Promise<RegistryFileInput[]> {
   // Only real files: a git:/ quick-diff document shares the fsPath but holds HEAD content.
   const openDocs = new Map(vscode.workspace.textDocuments.filter(d => d.uri.scheme === 'file').map(d => [d.uri.fsPath, d]))
+  let done = 0
   const results = await mapWithConcurrency(uris, FILE_READ_CONCURRENCY, async uri => {
+    await slicer.tick()
+    const fsPath = uri.fsPath
     try {
-      const openDoc = openDocs.get(uri.fsPath)
-      const text = openDoc ? openDoc.getText() : Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf8')
+      const real = await resolveRealPathAsync(fsPath)
+      const openDoc = openDocs.get(fsPath)
+      // Scanned URIs are local (file:) paths, so read them with Node directly.
+      const text = openDoc ? openDoc.getText() : await fs.promises.readFile(fsPath, 'utf8')
       // Quick pre-filter: a file with no GTS-like substring cannot hold a GTS id.
       // Check for both "gts." (canonical form) and "gts://" (URI form) so that
       // malformed identifiers like "gts://gtx.foo.bar.v1~" are still surfaced.
       if (!mayContainGts(text)) return null
-      const name = path.basename(uri.fsPath)
+      const name = path.basename(fsPath)
       let content: any
       try { content = parseGtsFileContent(name, text) } catch { content = text }
-      return { path: uri.fsPath, name, content }
+      return { real, file: { path: fsPath, name, content } }
     } catch {
       return null // Unreadable file — skip.
+    } finally {
+      onProgress?.(++done)
     }
   })
   // Results keep input order, so indexing order (and thus which definition of a
   // duplicated id wins) is the same as with sequential reads.
-  return results.filter((f): f is { path: string; name: string; content: any } => f !== null)
+  const files: RegistryFileInput[] = []
+  for (const result of results) {
+    if (!result || realPathIndex.has(result.real)) continue
+    setCanonicalPath(result.real, result.file.path)
+    files.push(result.file)
+  }
+  return files
 }
 
 // Files read concurrently during a scan. Sequential reads left most of the scan
 // waiting on I/O one file at a time.
-const FILE_READ_CONCURRENCY = 32
+const FILE_READ_CONCURRENCY = 64
 
 /** Map over `items` with at most `limit` operations in flight; results keep input order. */
 async function mapWithConcurrency<T, R>(items: readonly T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]> {
@@ -643,7 +740,7 @@ async function resetGtsStore(): Promise<void> {
   if (externalChangeTimer) clearTimeout(externalChangeTimer)
   externalChangeTimer = null
   preEditIdsByPath.clear()
-  realPathIndex.clear()
+  clearCanonicalPaths()
   resetWorkspaceIgnore()
   setLastScanFiles([])
   await rebuildRegistry([], DEFAULT_GTS_CONFIG)
@@ -659,25 +756,18 @@ async function refreshGtsFileExplorer(): Promise<void> {
 
 /**
  * Queue a full two-phase workspace scan (optionally from an emptied store, so
- * nothing from before can survive). Shows progress on the GTS files view.
+ * nothing from before can survive). Supersedes any scan queued or running.
+ * Shows progress on the GTS files view.
  */
 async function performInitialScan(reset: boolean = false): Promise<void> {
-  await vscode.window.withProgress(
-    { location: { viewId: 'gts-kit.fileExplorer' }, title: 'Scanning GTS files' },
-    () => enqueueScan(async () => {
-      // Reset inside the queue so it can't interleave with a scan in flight.
-      if (reset) await resetGtsStore()
-      pathsTouchedDuringScan = new Set()
-      try {
-        await performInitialScanPass()
-      } finally {
-        pathsTouchedDuringScan = null
-      }
-    })
-  )
+  await runScan(reset ? 'Rescanning…' : 'Scanning…', ++scanGeneration, async slicer => {
+    // Reset inside the queue so it can't interleave with a scan in flight.
+    if (reset) await resetGtsStore()
+    await performInitialScanPass(slicer)
+  })
 }
 
-async function performInitialScanPass(): Promise<void> {
+async function performInitialScanPass(slicer: TimeSlicer): Promise<void> {
   const startTime = Date.now()
   try {
     // Load .gitignore rules first so both phases permanently exclude ignored
@@ -687,7 +777,7 @@ async function performInitialScanPass(): Promise<void> {
     const openPaths = collectOpenGtsPaths()
 
     // A full scan re-establishes the canonical set of physical files.
-    realPathIndex.clear()
+    clearCanonicalPaths()
 
     // --- Phase 1: fast pass -------------------------------------------------
     // Enumerate with FAST_EXCLUDE_GLOB (+ gitignore) so build-output/dependency
@@ -695,7 +785,9 @@ async function performInitialScanPass(): Promise<void> {
     // Also skip known framework files by name. Currently-open files are always
     // included and go first so the file you are looking at colors ASAP (an open
     // file is an explicit user action, so it is coloured even if gitignored).
+    gtsExplorer?.setScanStatus('Listing files…')
     const fastUris = await findGtsFiles(ignores, FAST_EXCLUDE_GLOB, PHASE1_FILE_CAP)
+    slicer.throwIfCancelled()
     const phase1Candidates: vscode.Uri[] = []
     const phase1Paths = new Set<string>()
     for (const p of openPaths) {
@@ -703,60 +795,143 @@ async function performInitialScanPass(): Promise<void> {
       phase1Paths.add(p)
     }
     for (const uri of fastUris) {
-      if (phase1Paths.has(uri.fsPath)) continue
-      if (isDeferredToPhase2(uri.fsPath)) continue
-      if (isExcludedFile(uri, ignores)) continue
-      phase1Candidates.push(uri)
-      phase1Paths.add(uri.fsPath)
+      if (!phase1Paths.has(uri.fsPath) && !isDeferredToPhase2(uri.fsPath) && !isExcludedFile(uri, ignores)) {
+        phase1Candidates.push(uri)
+        phase1Paths.add(uri.fsPath)
+      }
+      await slicer.tick()
     }
 
-    // Collapse symlinked duplicates to one physical file each (open files first,
+    // Symlinked duplicates collapse to one physical file each (open files first,
     // so they stay canonical).
-    const phase1Deduped = dedupeUrisByRealPath(phase1Candidates)
-    console.log(`[GTS] Phase 1: ${phase1Deduped.length} candidate files (of ${fastUris.length} enumerated, ${phase1Candidates.length} before real-path dedup)`)
-    const files1 = await readGtsCandidateFiles(phase1Deduped)
-    const registry = await rebuildRegistry(files1, DEFAULT_GTS_CONFIG)
+    console.log(`[GTS] Phase 1: ${phase1Candidates.length} candidate files (of ${fastUris.length} enumerated)`)
+    const files1 = await readGtsCandidateFiles(phase1Candidates, slicer, fileProgress('Scanning', phase1Candidates.length))
+    gtsExplorer?.setScanStatus('Indexing…')
+    const registry = await rebuildRegistry(files1, DEFAULT_GTS_CONFIG, slicer)
     // Keep recording: phase 2 below may also race with live changes.
     await resyncPathsTouchedDuringScan(true)
     setLastScanFiles(files1)
     console.log(`[GTS] Phase 1 registry: ${registry.jsonSchemas.size} schemas, ${registry.jsonObjs.size} objects (${files1.length} GTS files)`)
     gtsExplorer?.refresh()
 
-    // Paint decorations + validate now that phase-1 registry is available.
-    // Validate the whole workspace (not just the folders of currently-open docs)
-    // so all findings/badge counts are present immediately after a window reload.
+    // Paint decorations and validate the open documents now that the phase-1
+    // registry is available. The workspace-wide pass waits for phase 2:
+    // indexing more files invalidates every memoized validation result, so a
+    // pass started now would be thrown away (on a large workspace, minutes of
+    // work done twice).
     await gtsLinkProvider?.refresh()
-    await validateWorkspaceInBackground()
     revalidateOpenDocs()
 
     // --- Phase 2: background pass -------------------------------------------
     // Enumerate the full set (only .git / our cache + gitignore excluded) and
-    // process whatever phase 1 didn't: non-ignored deferred dirs and framework
-    // files. Runs after the UI is already coloured, so its cost is not visible.
+    // process whatever phase 1 didn't: non-ignored deferred dirs, framework
+    // files and everything past phase 1's enumeration cap.
+    gtsExplorer?.setScanStatus('Listing remaining files…')
     const allUris = await findGtsFiles(ignores, ALWAYS_EXCLUDE_GLOB)
-    // Skip anything already indexed in phase 1 and any symlinked duplicate of a
-    // physical file we've already taken (the realPathIndex still holds phase 1).
-    const phase2Prefiltered = allUris.filter(uri => !phase1Paths.has(uri.fsPath) && !isExcludedFile(uri, ignores))
-    const phase2Uris = dedupeUrisByRealPath(phase2Prefiltered)
-    const files2 = phase2Uris.length > 0 ? await readGtsCandidateFiles(phase2Uris) : []
-    for (const f of files2) indexFileInRegistry(f.path, f.name, f.content)
-    if (files2.length > 0) setLastScanFiles([...files1, ...files2])
-    console.log(`[GTS] Phase 2: merged ${files2.length} GTS files (of ${phase2Uris.length} deferred)`)
+    slicer.throwIfCancelled()
+    // Skip anything already indexed in phase 1; symlinked duplicates of a
+    // physical file we've already taken are dropped while reading (the
+    // realPathIndex still holds phase 1).
+    const phase2Candidates = await filterSliced(allUris, uri => !phase1Paths.has(uri.fsPath) && !isExcludedFile(uri, ignores), slicer)
+    const files2 = phase2Candidates.length > 0
+      ? await readGtsCandidateFiles(phase2Candidates, slicer, fileProgress('Scanning remaining', phase2Candidates.length))
+      : []
+    gtsExplorer?.setScanStatus('Indexing…')
+    await indexFiles(files2, slicer)
+    if (files2.length > 0) setLastScanFiles(files1.concat(files2))
+    console.log(`[GTS] Phase 2: merged ${files2.length} GTS files (of ${phase2Candidates.length} deferred)`)
     const resynced = await resyncPathsTouchedDuringScan(false)
     if (files2.length > 0 || resynced > 0) {
       gtsExplorer?.refresh()
       await gtsLinkProvider?.refresh()
-      await validateWorkspaceInBackground()
       revalidateOpenDocs()
     }
+    // The workspace pass runs in the background (with its own progress) rather
+    // than holding the scan queue: a rescan or folder rescan requested meanwhile
+    // starts right away and the pass restarts on the new registry.
+    void validateWorkspaceInBackground()
     const finalRegistry = getRegistry()
     console.log(`[GTS] Scan complete in ${Date.now() - startTime}ms: ${finalRegistry?.jsonFiles.size ?? 0} GTS files, ${finalRegistry?.invalidFiles.size ?? 0} unparsable`)
   } catch (error) {
-    console.error('[GTS] Initial scan error:', error)
+    if (!(error instanceof CancelledError)) console.error('[GTS] Initial scan error:', error)
     throw error
   }
 }
 
+/**
+ * Rescan one folder of the GTS tree and everything below it: re-read every
+ * candidate file under it, drop indexed files that are gone (or no longer
+ * hold GTS content), then revalidate the folder's files and whatever depends
+ * on the ones that changed. Unchanged files don't count as changes, so
+ * rescanning a folder where nothing changed keeps every validation result.
+ *
+ * Progress shows on the folder's row (in place of its Rescan button), per
+ * phase: "scanning N%" (files of the folder read), then "validating N%" (the
+ * folder's files plus whatever depends on the changed ones).
+ */
+async function rescanFolder(folderPath: string): Promise<void> {
+  const setProgress = (progress: FolderProgress | undefined) => gtsExplorer?.setFolderProgress(folderPath, progress)
+  // Shown until the scan queue gets to it (another scan may be running).
+  setProgress('queued')
+  try {
+    let rescanned: FolderRescan | undefined
+    await runScan(undefined, scanGeneration, async slicer => {
+      setProgress({ phase: 'scanning', percent: 0 })
+      rescanned = await rescanFolderPass(folderPath, slicer, percent => setProgress({ phase: 'scanning', percent }))
+    })
+    if (!rescanned) return // superseded by a full rescan
+    // Like the full scan's validation, this runs outside the scan queue.
+    setProgress({ phase: 'validating', percent: 0 })
+    await revalidateFiles(rescanned.found, rescanned.changed, (done, total) => setProgress({ phase: 'validating', percent: 100 * done / total }))
+  } finally {
+    setProgress(undefined)
+  }
+  if (viewerPanel) void scanAndPost()
+}
+
+interface FolderRescan {
+  /** GTS files now indexed under the folder. */
+  found: Set<string>
+  /** Files whose indexed state changed (or that were dropped) -> ids they defined before. */
+  changed: Map<string, string[]>
+}
+
+/** The scan-queue part of rescanFolder: re-read and re-index the folder's files. */
+async function rescanFolderPass(folderPath: string, slicer: TimeSlicer, setProgress: (percent: number) => void): Promise<FolderRescan> {
+  const startTime = Date.now()
+  const folderUri = vscode.Uri.file(folderPath)
+  const ignores = await getWorkspaceIgnore()
+  // Exclude globs are matched relative to the containing workspace folder.
+  const workspaceFolder = vscode.workspace.getWorkspaceFolder(folderUri)
+  const ignoreGlobs = workspaceFolder ? ignores.get(workspaceFolder.uri.fsPath)?.excludeGlobs || [] : []
+  const uris = await vscode.workspace.findFiles(new vscode.RelativePattern(folderUri, GTS_SCAN_GLOB), combineExcludeGlobs(ALWAYS_EXCLUDE_GLOB, ignoreGlobs))
+  slicer.throwIfCancelled()
+  const candidates = await filterSliced(uris, uri => !isExcludedFile(uri, ignores), slicer)
+
+  // The folder's files compete for canonical paths afresh; symlinked aliases
+  // outside the folder keep theirs.
+  const previouslyIndexed = indexedPathsUnder(folderPath)
+  const registry = getRegistry()
+  const previousIds = new Map(previouslyIndexed.map(p => [p, registry?.getEntityIdsForFile(p) || []]))
+  for (const p of previouslyIndexed) forgetIndexedPath(p)
+
+  const files = await readGtsCandidateFiles(candidates, slicer, throttledProgress(candidates.length, done => setProgress(100 * done / candidates.length)))
+  const found = new Set(files.map(f => f.path))
+  const changed = new Map<string, string[]>()
+  for (const p of previouslyIndexed) {
+    if (found.has(p)) continue
+    dropFileFromRegistry(p)
+    changed.set(p, previousIds.get(p) || [])
+  }
+  for (const p of await indexFiles(files, slicer)) changed.set(p, previousIds.get(p) || [])
+  await resyncPathsTouchedDuringScan(false)
+  console.log(`[GTS] Rescanned ${folderPath} in ${Date.now() - startTime}ms: ${files.length} GTS files, ${changed.size} changed`)
+
+  gtsExplorer?.refresh()
+  if (changed.size > 0) await gtsLinkProvider?.refresh()
+  return { found, changed }
+}
+
 export async function deactivate() {
   console.log('[GTS] Extension deactivating...')
 
@@ -871,16 +1046,20 @@ async function onDiskFileChanged(uri: vscode.Uri): Promise<void> {
   scheduleExternalChangeSettle()
 }
 
-/** Indexed file paths (GTS files and unparsable ones) strictly under `dirPath`. */
+/**
+ * Indexed file paths strictly under `dirPath`: GTS files, unparsable ones and
+ * files whose only GTS content is malformed ids (all of them are listed in the
+ * GTS tree).
+ */
 function indexedPathsUnder(dirPath: string): string[] {
   const registry = getRegistry()
   if (!registry) return []
   const prefix = dirPath.endsWith(path.sep) ? dirPath : dirPath + path.sep
-  const out: string[] = []
-  for (const p of [...registry.jsonFiles.keys(), ...registry.invalidFiles.keys()]) {
-    if (p.startsWith(prefix)) out.push(p)
+  const out = new Set<string>()
+  for (const paths of [registry.jsonFiles.keys(), registry.invalidFiles.keys(), getPathsWithMalformedIds()]) {
+    for (const p of paths) if (p.startsWith(prefix)) out.add(p)
   }
-  return out
+  return [...out]
 }
 
 /**
diff --git a/apps/vscode-extension/src/gtsExplorer.ts b/apps/vscode-extension/src/gtsExplorer.ts
index b8e7f15..7fdac4e 100644
--- a/apps/vscode-extension/src/gtsExplorer.ts
+++ b/apps/vscode-extension/src/gtsExplorer.ts
@@ -1,7 +1,7 @@
 import * as vscode from 'vscode'
 import * as path from 'path'
 import { getRegistry, getMalformedIds, getPathsWithMalformedIds } from './registryStore'
-import { countPublishedProblems } from './validation'
+import { countPublishedProblems, isValidationKnown, onValidationStateChanged, onWorkspaceValidationProgress } from './validation'
 
 /**
  * Left-sidebar file browser for GTS: shows every discovered file that holds at
@@ -24,55 +24,103 @@ interface GtsFileNode {
 interface GtsFolderNode {
   kind: 'folder'
   label: string
+  /** The folder's absolute path ('' for the invisible root). */
+  fsPath: string
   children: Map<string, GtsFileNode | GtsFolderNode>
+  /** Children in display order, computed on first request. */
+  sorted?: GtsTreeElement[]
 }
 
-type GtsTreeElement = GtsFileNode | GtsFolderNode
+/** The first row while a scan or validation runs, showing its status. */
+interface GtsStatusNode {
+  kind: 'status'
+  text: string
+}
 
-/**
- * Tree path segments for a file: relative to its workspace folder, under a
- * top-level node named after that folder when the workspace has several roots.
- * Files outside every folder keep their absolute path.
- */
-function treePathParts(fsPath: string, multiRoot: boolean): string[] {
-  const folder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(fsPath))
-  if (!folder) return fsPath.split(path.sep).filter(Boolean)
-  const rel = path.relative(folder.uri.fsPath, fsPath).split(path.sep).filter(Boolean)
-  return multiRoot ? [folder.name, ...rel] : rel
+export type GtsTreeElement = GtsFileNode | GtsFolderNode | GtsStatusNode
+
+/** A folder rescan's progress: waiting behind other scans, or a phase's percentage. */
+export type FolderProgress = 'queued' | { phase: 'scanning' | 'validating'; percent: number }
+
+// Repainting a folder row makes VS Code fetch the folder's whole (expanded)
+// subtree again, and shows a second spinner in place of its twistie while
+// that is slow, so a row's percentage is repainted at most this often (a
+// phase change always repaints).
+const FOLDER_PROGRESS_REPAINT_MS = 1000
+
+function folderProgressText(progress: FolderProgress): string {
+  if (progress === 'queued') return 'waiting…'
+  return `${progress.phase} ${Math.max(0, Math.min(100, Math.floor(progress.percent)))}%`
 }
 
-/** Build a nested folder/file tree (per workspace folder) from a flat list of absolute paths. */
-function buildFileTree(filePaths: string[]): GtsFolderNode {
-  const root: GtsFolderNode = { kind: 'folder', label: '', children: new Map() }
-  const multiRoot = (vscode.workspace.workspaceFolders?.length ?? 0) > 1
+/** `dir` + `name` with exactly one separator between them ('' for no parent). */
+function joinFsPath(dir: string, name: string): string {
+  if (!dir) return name
+  return dir.endsWith(path.sep) ? dir + name : dir + path.sep + name
+}
+
+/** Child folder `label` of `parent`, created if missing. */
+function getChildFolder(parent: GtsFolderNode, label: string, fsPath: string): GtsFolderNode {
+  const existing = parent.children.get(label)
+  if (existing?.kind === 'folder') return existing
+  const folder: GtsFolderNode = { kind: 'folder', label, fsPath, children: new Map() }
+  parent.children.set(label, folder)
+  return folder
+}
+
+/**
+ * Build a nested folder/file tree from a flat list of absolute paths. Paths
+ * are shown relative to their workspace folder, under a top-level node named
+ * after that folder when the workspace has several roots. Files outside every
+ * folder keep their absolute path.
+ */
+function buildFileTree(filePaths: Iterable<string>, folders: Map<string, GtsFolderNode>): GtsFolderNode {
+  const root: GtsFolderNode = { kind: 'folder', label: '', fsPath: '', children: new Map() }
+  const childFolder = (parent: GtsFolderNode, label: string, fsPath: string) => {
+    const folder = getChildFolder(parent, label, fsPath)
+    folders.set(fsPath, folder)
+    return folder
+  }
+  // Innermost first, so a file in nested workspace folders goes to the nested
+  // one (as with getWorkspaceFolder, which was too slow to call per file).
+  const workspaceFolders = (vscode.workspace.workspaceFolders || [])
+    .map(f => ({ name: f.name, fsPath: f.uri.fsPath, prefix: joinFsPath(f.uri.fsPath, '') }))
+    .sort((a, b) => b.fsPath.length - a.fsPath.length)
+  const multiRoot = workspaceFolders.length > 1
   for (const fsPath of filePaths) {
-    const parts = treePathParts(fsPath, multiRoot)
+    const workspaceFolder = workspaceFolders.find(f => fsPath.startsWith(f.prefix))
     let current = root
-    parts.forEach((part, idx) => {
-      const isLast = idx === parts.length - 1
-      if (isLast) {
-        current.children.set(part, { kind: 'file', label: part, fsPath })
-        return
-      }
-      const existing = current.children.get(part)
-      if (existing && existing.kind === 'folder') {
-        current = existing
-      } else {
-        const folder: GtsFolderNode = { kind: 'folder', label: part, children: new Map() }
-        current.children.set(part, folder)
-        current = folder
-      }
-    })
+    let dir: string
+    let parts: string[]
+    if (workspaceFolder) {
+      if (multiRoot) current = childFolder(root, workspaceFolder.name, workspaceFolder.fsPath)
+      dir = workspaceFolder.fsPath
+      parts = fsPath.slice(workspaceFolder.prefix.length).split(path.sep).filter(Boolean)
+    } else {
+      dir = fsPath.startsWith(path.sep) ? path.sep : ''
+      parts = fsPath.split(path.sep).filter(Boolean)
+    }
+    for (let i = 0; i < parts.length - 1; i++) {
+      dir = joinFsPath(dir, parts[i])
+      current = childFolder(current, parts[i], dir)
+    }
+    const name = parts[parts.length - 1]
+    if (name) current.children.set(name, { kind: 'file', label: name, fsPath })
   }
   return root
 }
 
+// One shared collator: `localeCompare` with options builds a collator per
+// call, which made sorting a folder of 100K files take seconds.
+const labelCollator = new Intl.Collator(undefined, { sensitivity: 'base' })
+
 /** Folders first, then files, both alphabetically (case-insensitive). */
 function sortedChildren(folder: GtsFolderNode): GtsTreeElement[] {
-  return Array.from(folder.children.values()).sort((a, b) => {
+  folder.sorted ??= Array.from(folder.children.values()).sort((a, b) => {
     if (a.kind !== b.kind) return a.kind === 'folder' ? -1 : 1
-    return a.label.localeCompare(b.label, undefined, { sensitivity: 'base' })
+    return labelCollator.compare(a.label, b.label)
   })
+  return folder.sorted
 }
 
 /**
@@ -80,14 +128,14 @@ function sortedChildren(folder: GtsFolderNode): GtsTreeElement[] {
  * failed to parse, and files whose only GTS content is malformed ids (those
  * hold no valid entity, so the registry itself doesn't list them).
  */
-function getDiscoveredFilePaths(): string[] {
+function getDiscoveredFilePaths(): Set<string> {
+  const paths = new Set<string>()
   const registry = getRegistry()
-  if (!registry) return []
-  return Array.from(new Set<string>([
-    ...registry.jsonFiles.keys(),
-    ...registry.invalidFiles.keys(),
-    ...getPathsWithMalformedIds()
-  ]))
+  if (!registry) return paths
+  for (const p of registry.jsonFiles.keys()) paths.add(p)
+  for (const p of registry.invalidFiles.keys()) paths.add(p)
+  for (const p of getPathsWithMalformedIds()) paths.add(p)
+  return paths
 }
 
 function isDiscoveredGtsFile(fsPath: string): boolean {
@@ -116,9 +164,9 @@ export function hasGtsErrors(uri: vscode.Uri): boolean {
 function collectFilePaths(element: GtsTreeElement, out: string[]): void {
   if (element.kind === 'file') {
     out.push(element.fsPath)
-    return
+  } else if (element.kind === 'folder') {
+    for (const child of element.children.values()) collectFilePaths(child, out)
   }
-  for (const child of element.children.values()) collectFilePaths(child, out)
 }
 
 export class GtsFileTreeProvider
@@ -132,11 +180,67 @@ export class GtsFileTreeProvider
   private readonly _onDidChangeTreeData = new vscode.EventEmitter<GtsTreeElement | undefined | void>()
   readonly onDidChangeTreeData = this._onDidChangeTreeData.event
 
-  private root: GtsFolderNode = { kind: 'folder', label: '', children: new Map() }
+  private root: GtsFolderNode = { kind: 'folder', label: '', fsPath: '', children: new Map() }
   // The set of discovered file paths currently reflected in the tree. Used to
   // avoid rebuilding (and thus visually flickering) the whole tree when only
   // file *contents* changed but the file list is the same.
   private knownPaths = new Set<string>()
+  // Folder nodes of the current tree by path, to repaint a single folder row.
+  private folders = new Map<string, GtsFolderNode>()
+  // Progress text shown on the rows of folders being rescanned, and when each
+  // row was last repainted.
+  private readonly folderProgress = new Map<string, string>()
+  private readonly folderRepaints = new Map<string, { at: number; timer?: NodeJS.Timeout }>()
+  private status: GtsStatusNode | undefined
+
+  /**
+   * Show `text` (dimmed) as the first row, e.g. scan or validation progress,
+   * or remove the row with `undefined`. VS Code's view message can't be
+   * styled, and the title description isn't shown for a view that is alone in
+   * its container.
+   */
+  setStatus(text: string | undefined): void {
+    if (!text) {
+      if (!this.status) return
+      this.status = undefined
+      this._onDidChangeTreeData.fire()
+    } else if (!this.status) {
+      this.status = { kind: 'status', text }
+      this._onDidChangeTreeData.fire()
+    } else if (this.status.text !== text) {
+      // Only this (leaf) row is repainted.
+      this.status.text = text
+      this._onDidChangeTreeData.fire(this.status)
+    }
+  }
+
+  /**
+   * Show `progress` on the row of the folder at `fsPath` while it is being
+   * rescanned (in place of its Rescan button), or clear it with `undefined`.
+   */
+  setFolderProgress(fsPath: string, progress: FolderProgress | undefined): void {
+    const previous = this.folderProgress.get(fsPath)
+    const text = progress === undefined ? undefined : folderProgressText(progress)
+    if (text === previous) return
+    if (text === undefined) this.folderProgress.delete(fsPath)
+    else this.folderProgress.set(fsPath, text)
+
+    const repaint = this.folderRepaints.get(fsPath) ?? { at: 0 }
+    this.folderRepaints.set(fsPath, repaint)
+    if (repaint.timer) clearTimeout(repaint.timer)
+    repaint.timer = undefined
+    const samePhase = previous !== undefined && text !== undefined && previous.split(' ')[0] === text.split(' ')[0]
+    const wait = samePhase ? repaint.at + FOLDER_PROGRESS_REPAINT_MS - Date.now() : 0
+    const fire = () => {
+      repaint.timer = undefined
+      repaint.at = Date.now()
+      if (text === undefined) this.folderRepaints.delete(fsPath)
+      const folder = this.folders.get(fsPath)
+      if (folder) this._onDidChangeTreeData.fire(folder)
+    }
+    if (wait > 0) repaint.timer = setTimeout(fire, wait)
+    else fire()
+  }
 
   /**
    * Reconcile the tree with the current registry state. Only rebuilds (and fires
@@ -151,8 +255,7 @@ export class GtsFileTreeProvider
   }
 
   refresh(): vscode.Uri[] {
-    const paths = getDiscoveredFilePaths()
-    const nextSet = new Set(paths)
+    const nextSet = getDiscoveredFilePaths()
 
     const changed: vscode.Uri[] = []
     for (const p of nextSet) if (!this.knownPaths.has(p)) changed.push(vscode.Uri.file(p))
@@ -160,37 +263,68 @@ export class GtsFileTreeProvider
     if (changed.length === 0) return []
 
     this.knownPaths = nextSet
-    this.root = buildFileTree(paths)
+    this.folders = new Map()
+    this.root = buildFileTree(nextSet, this.folders)
     this._onDidChangeTreeData.fire()
     return changed
   }
 
   getTreeItem(element: GtsTreeElement): vscode.TreeItem {
+    if (element.kind === 'status') {
+      // The text goes in the description, which VS Code renders dimmed.
+      const item = new vscode.TreeItem('', vscode.TreeItemCollapsibleState.None)
+      item.description = element.text
+      item.tooltip = element.text
+      item.iconPath = new vscode.ThemeIcon('loading~spin', new vscode.ThemeColor('descriptionForeground'))
+      item.contextValue = 'gtsStatus'
+      return item
+    }
     if (element.kind === 'file') {
       const item = new vscode.TreeItem(element.label, vscode.TreeItemCollapsibleState.None)
       item.resourceUri = vscode.Uri.file(element.fsPath)
       item.contextValue = 'gtsFile'
+      // The built-in `vscode.open` is converted to a workbench command when the
+      // item is sent to the UI, so a click opens the file directly instead of
+      // round-tripping through this extension host, which may be busy scanning
+      // or validating a large workspace.
       item.command = {
-        command: 'gts-kit.openFileFromTree',
+        command: 'vscode.open',
         title: 'Open GTS File',
-        arguments: [element.fsPath]
+        arguments: [item.resourceUri, { preview: false }]
       }
-      item.tooltip = hasGtsErrors(item.resourceUri)
-        ? 'Has GTS validation errors'
-        : 'No GTS validation errors'
+      // The tooltip is filled in on hover (resolveTreeItem), so it reflects the
+      // file's validation state at that moment rather than when the row was built.
       return item
     }
 
     const item = new vscode.TreeItem(element.label, vscode.TreeItemCollapsibleState.Expanded)
-    item.iconPath = vscode.ThemeIcon.Folder
-    item.contextValue = 'gtsFolder'
+    item.tooltip = element.fsPath
+    const progress = this.folderProgress.get(element.fsPath)
+    if (progress === undefined) {
+      item.iconPath = vscode.ThemeIcon.Folder
+      item.contextValue = 'gtsFolder'
+    } else {
+      // A different context value hides the Rescan button while it runs.
+      item.iconPath = new vscode.ThemeIcon('loading~spin')
+      item.contextValue = 'gtsFolderRescanning'
+      item.description = progress
+    }
+    return item
+  }
+
+  resolveTreeItem(item: vscode.TreeItem, element: GtsTreeElement): vscode.TreeItem {
+    if (element.kind === 'file') {
+      const uri = vscode.Uri.file(element.fsPath)
+      item.tooltip = !isValidationKnown(element.fsPath)
+        ? 'GTS validation pending'
+        : hasGtsErrors(uri) ? 'Has GTS validation errors' : 'No GTS validation errors'
+    }
     return item
   }
 
   getChildren(element?: GtsTreeElement): GtsTreeElement[] {
-    const folder = element ? (element.kind === 'folder' ? element : undefined) : this.root
-    if (!folder) return []
-    return sortedChildren(folder)
+    if (!element) return this.status ? [this.status, ...sortedChildren(this.root)] : sortedChildren(this.root)
+    return element.kind === 'folder' ? sortedChildren(element) : []
   }
 
   /**
@@ -215,30 +349,42 @@ export class GtsFileTreeProvider
  * Colors every valid GTS file green (in the sidebar tree, the OS-style Explorer
  * and editor tabs). Files with GTS problems get no decoration of their own:
  * VS Code's Problems decoration colors them with its standard error color and
- * count, so every GTS problem looks the same everywhere.
+ * count, so every GTS problem looks the same everywhere. Files that haven't
+ * been validated yet stay uncolored: no diagnostics doesn't mean valid yet.
  */
 export class GtsFileDecorationProvider implements vscode.FileDecorationProvider {
   private readonly _onDidChangeFileDecorations = new vscode.EventEmitter<vscode.Uri | vscode.Uri[] | undefined>()
   readonly onDidChangeFileDecorations = this._onDidChangeFileDecorations.event
 
   refresh(uris?: vscode.Uri[]): void {
-    this._onDidChangeFileDecorations.fire(uris)
+    // VS Code eagerly re-fetches the decoration of every URI listed in a change
+    // event, one provider call per file, while a flush (`undefined`) only
+    // re-fetches what is on screen. Past a few thousand files (a scan, a
+    // validation batch) the flush is far cheaper, at the cost of a repaint.
+    this._onDidChangeFileDecorations.fire(uris && uris.length <= MAX_DECORATION_CHANGE_URIS ? uris : undefined)
   }
 
   provideFileDecoration(uri: vscode.Uri): vscode.FileDecoration | undefined {
     if (!isDiscoveredGtsFile(uri.fsPath)) return undefined
+    if (!isValidationKnown(uri.fsPath)) return undefined
 
     if (hasGtsErrors(uri)) return undefined
     return new vscode.FileDecoration(undefined, 'GTS: file is valid', new vscode.ThemeColor('charts.green'))
   }
 }
 
+const MAX_DECORATION_CHANGE_URIS = 2000
+
 export interface GtsExplorer {
   treeProvider: GtsFileTreeProvider
   decorationProvider: GtsFileDecorationProvider
   reset(): void
-  /** Call after the registry's set of discovered files may have changed (rescan, index/remove file). */
+  /** Call after the registry's set of discovered files may have changed (rescan, index/remove file). Debounced. */
   refresh(): void
+  /** Status of the running scan, shown dimmed as the tree's first row (undefined: none). */
+  setScanStatus(status: string | undefined): void
+  /** Progress of a folder rescan, shown on the folder's row (undefined: done). */
+  setFolderProgress(fsPath: string, progress: FolderProgress | undefined): void
 }
 
 /** Update the small rounded problem-count badge shown next to the view title. */
@@ -282,14 +428,6 @@ export function registerGtsExplorer(context: vscode.ExtensionContext): GtsExplor
     registerNativeFileCommand('gts-kit.openTimeline', 'files.openTimeline'),
     registerNativeFileCommand('gts-kit.copyPath', 'copyFilePath'),
     registerNativeFileCommand('gts-kit.copyRelativePath', 'copyRelativeFilePath'),
-    vscode.commands.registerCommand('gts-kit.openFileFromTree', async (fsPath: string) => {
-      try {
-        const uri = vscode.Uri.file(fsPath)
-        await vscode.window.showTextDocument(uri, { preview: false })
-      } catch (error: any) {
-        vscode.window.showErrorMessage(`Failed to open GTS file: ${error?.message || String(error)}`)
-      }
-    }),
     // Diagnostics (and therefore per-file error state and the problem-count
     // badge) change independently of the file list. This event fires for every
     // diagnostics change of every extension (e.g. the TypeScript server on each
@@ -302,9 +440,42 @@ export function registerGtsExplorer(context: vscode.ExtensionContext): GtsExplor
       decorationProvider.refresh(relevant)
       scheduleTreeUpdate()
     }),
-    new vscode.Disposable(() => { if (updateTimer) clearTimeout(updateTimer) })
+    // A file whose validation just became known turns green without any
+    // diagnostics change, so it has to be repainted explicitly.
+    onValidationStateChanged(uris => {
+      decorationProvider.refresh(uris)
+    }),
+    // Workspace validation runs after a scan (minutes on a very large
+    // workspace): show its progress like the scan's.
+    onWorkspaceValidationProgress(progress => {
+      if (!progress) {
+        validationStatus = undefined
+        endValidationProgress?.()
+        endValidationProgress = null
+      } else {
+        validationStatus = `Validating ${progress.done.toLocaleString()} / ${progress.total.toLocaleString()}`
+        if (!endValidationProgress) {
+          const ended = new Promise<void>(resolve => { endValidationProgress = resolve })
+          void vscode.window.withProgress({ location: { viewId: 'gts-kit.fileExplorer' } }, () => ended)
+        }
+      }
+      updateMessage()
+    }),
+    new vscode.Disposable(() => {
+      if (updateTimer) clearTimeout(updateTimer)
+      endValidationProgress?.()
+    })
   )
 
+  // What is running (a scan, else validation) is shown as a dimmed first row
+  // of the tree (see GtsFileTreeProvider.setStatus).
+  let scanStatus: string | undefined
+  let validationStatus: string | undefined
+  let endValidationProgress: (() => void) | null = null
+  function updateMessage(): void {
+    treeProvider.setStatus(scanStatus ?? validationStatus)
+  }
+
   // Coalesces tree reconciliation + badge recount across bursts of changes.
   let updateTimer: NodeJS.Timeout | null = null
   function scheduleTreeUpdate(): void {
@@ -332,11 +503,17 @@ export function registerGtsExplorer(context: vscode.ExtensionContext): GtsExplor
     refresh() {
       // Only the added/removed files need a decoration repaint; error-state
       // changes on existing files are repainted by the onDidChangeDiagnostics
-      // handler above. A global decoration refresh here would flicker every file.
-      // Called on every keystroke in a GTS file, so the badge recount is debounced.
-      const changed = treeProvider.refresh()
-      if (changed.length > 0) decorationProvider.refresh(changed)
+      // handler above. Called on every keystroke in a GTS file and for every
+      // file of an on-disk burst (git checkout), and each reconciliation walks
+      // every discovered file, so it is debounced.
       scheduleTreeUpdate()
+    },
+    setScanStatus(status) {
+      scanStatus = status
+      updateMessage()
+    },
+    setFolderProgress(fsPath, progress) {
+      treeProvider.setFolderProgress(fsPath, progress)
     }
   }
 }
diff --git a/apps/vscode-extension/src/linkProvider.ts b/apps/vscode-extension/src/linkProvider.ts
index fd09145..8292aaf 100644
--- a/apps/vscode-extension/src/linkProvider.ts
+++ b/apps/vscode-extension/src/linkProvider.ts
@@ -336,7 +336,7 @@ export class GtsLinkProvider implements vscode.DocumentLinkProvider<vscode.Docum
         continue
       }
 
-      // Wildcard patterns (e.g. "gts.*" in x-gts-ref) are valid GTS references
+      // Wildcard patterns (e.g. "gts.*" in x-gts-pattern-ref) are valid GTS references
       // but don't resolve to specific entities — show as schema decoration
       if (ref.isPattern) {
         const gtsStartOffset = ref.contentOffset + ref.uriPrefixLength
@@ -352,7 +352,7 @@ export class GtsLinkProvider implements vscode.DocumentLinkProvider<vscode.Docum
       // validation results: a *schema* segment whose entity failed gts-ts
       // validation (e.g. an invalid derived schema in the chain) is `isValid:
       // false` → red. Instance-level, field-specific errors (abstract type,
-      // x-gts-ref, ...) are handled by `hasFieldError` below, not by flagging the
+      // reference keywords, ...) are handled by `hasFieldError` below, not by flagging the
       // whole instance entity, so an instance's own id is not reddened merely
       // because some other field of it failed. No GTS rules are re-derived here.
       const registry = this.registry
diff --git a/apps/vscode-extension/src/registryStore.ts b/apps/vscode-extension/src/registryStore.ts
index 301eb5f..31d368c 100644
--- a/apps/vscode-extension/src/registryStore.ts
+++ b/apps/vscode-extension/src/registryStore.ts
@@ -1,6 +1,7 @@
 import { JsonRegistry, DEFAULT_GTS_CONFIG } from '@gts/shared'
 import type { GtsConfig } from '@gts/shared'
 import { findMalformedGtsIds, type MalformedGtsId } from './gtsIdFormat'
+import { TimeSlicer } from './timeSlice'
 
 /**
  * Long-lived, shared GTS registry for the extension host.
@@ -31,9 +32,13 @@ const malformedIdsByPath = new Map<string, MalformedGtsId[]>()
 
 const GTS_VIEWER_DIR_RE = /(^|[\\/])\.gts-viewer[\\/]/
 
-function updateMalformedIds(path: string, content: any): void {
+function findMalformedIdsIn(path: string, content: any): MalformedGtsId[] {
   // Unparsable files (raw string content) are reported as parse errors instead.
-  const issues = typeof content === 'string' || GTS_VIEWER_DIR_RE.test(path) ? [] : findMalformedGtsIds(content)
+  return typeof content === 'string' || GTS_VIEWER_DIR_RE.test(path) ? [] : findMalformedGtsIds(content)
+}
+
+function updateMalformedIds(path: string, content: any): void {
+  const issues = findMalformedIdsIn(path, content)
   if (issues.length > 0) malformedIdsByPath.set(path, issues)
   else malformedIdsByPath.delete(path)
 }
@@ -57,35 +62,57 @@ export function getRegistryRevision(): number {
   return revision
 }
 
-/** Rebuild the shared registry from a full set of scanned files (index-only). */
+/**
+ * Rebuild the shared registry from a full set of scanned files (index-only).
+ * Indexing 100K+ files takes seconds, so it yields between time slices (via
+ * `slicer`, which also aborts a cancelled scan by throwing); the shared
+ * registry is only replaced once the new one is complete.
+ */
 export async function rebuildRegistry(
   files: RegistryFileInput[],
-  cfg: GtsConfig = DEFAULT_GTS_CONFIG
+  cfg: GtsConfig = DEFAULT_GTS_CONFIG,
+  slicer: TimeSlicer = new TimeSlicer()
 ): Promise<JsonRegistry> {
-  activeConfig = cfg
   const next = new JsonRegistry()
-  await next.ingestFiles(files, cfg, { skipValidation: true })
+  const malformed = new Map<string, MalformedGtsId[]>()
+  for (const file of files) {
+    next.indexFile(file.path, file.name, file.content, cfg)
+    const issues = findMalformedIdsIn(file.path, file.content)
+    if (issues.length > 0) malformed.set(file.path, issues)
+    await slicer.tick()
+  }
+  activeConfig = cfg
   malformedIdsByPath.clear()
-  for (const file of files) updateMalformedIds(file.path, file.content)
+  for (const [path, issues] of malformed) malformedIdsByPath.set(path, issues)
   registry = next
   revision++
   return next
 }
 
-/** Incrementally upsert a single file's entities into the shared registry. */
-export function indexFile(path: string, name: string, content: any): void {
-  if (!registry) return
-  registry.indexFile(path, name, content, activeConfig)
+/** Incrementally upsert a single file's entities into the shared registry. Returns whether anything changed. */
+export function indexFile(path: string, name: string, content: any): boolean {
+  if (!registry) return false
+  const changed = registry.indexFile(path, name, content, activeConfig)
   updateMalformedIds(path, content)
-  revision++
+  if (changed) revision++
+  return changed
+}
+
+/** `indexFile` for many files, yielding between time slices. Returns the paths whose indexed state changed. */
+export async function indexFiles(files: RegistryFileInput[], slicer: TimeSlicer = new TimeSlicer()): Promise<string[]> {
+  const changed: string[] = []
+  for (const file of files) {
+    if (indexFile(file.path, file.name, file.content)) changed.push(file.path)
+    await slicer.tick()
+  }
+  return changed
 }
 
 /** Remove a single file's entities from the shared registry. */
 export function removeFile(path: string): void {
   if (!registry) return
-  registry.invalidateFile(path)
-  malformedIdsByPath.delete(path)
-  revision++
+  const changed = registry.invalidateFile(path)
+  if (malformedIdsByPath.delete(path) || changed) revision++
 }
 
 /** The GTS config the registry was built with. */
diff --git a/apps/vscode-extension/src/timeSlice.ts b/apps/vscode-extension/src/timeSlice.ts
new file mode 100644
index 0000000..198d063
--- /dev/null
+++ b/apps/vscode-extension/src/timeSlice.ts
@@ -0,0 +1,94 @@
+/**
+ * Cooperative time slicing for long loops on the extension host.
+ *
+ * Everything an extension does shares one thread with every other extension
+ * and with the host's own message handling, so a loop over 100K+ files that
+ * never yields freezes commands, tree clicks, hovers and progress updates for
+ * as long as it runs. Long loops call `slicer.tick()` per item; it yields back
+ * to the event loop once the current slice has used up its budget.
+ */
+
+const DEFAULT_SLICE_MS = 20
+
+export function yieldToEventLoop(): Promise<void> {
+  return new Promise(resolve => setImmediate(resolve))
+}
+
+/** Thrown by a cancelled scan step; callers abandon the work silently. */
+export class CancelledError extends Error {
+  constructor() {
+    super('cancelled')
+  }
+}
+
+export class TimeSlicer {
+  private sliceStart = Date.now()
+  /** Total time other work (other extensions, host messages) ran while this slicer yielded. */
+  awayMs = 0
+
+  constructor(
+    private readonly isCancelled: () => boolean = () => false,
+    private readonly sliceMs = DEFAULT_SLICE_MS
+  ) {}
+
+  /** Yield if the slice is used up; throws CancelledError once cancelled. */
+  async tick(): Promise<void> {
+    const yieldStart = Date.now()
+    if (yieldStart - this.sliceStart < this.sliceMs) return
+    await yieldToEventLoop()
+    this.sliceStart = Date.now()
+    this.awayMs += this.sliceStart - yieldStart
+    this.throwIfCancelled()
+  }
+
+  /** For use right after a long await that isn't sliced (e.g. a file search). */
+  throwIfCancelled(): void {
+    if (this.isCancelled()) throw new CancelledError()
+  }
+}
+
+const MIN_PUBLISH_INTERVAL_MS = 1000
+const MAX_PUBLISH_INTERVAL_MS = 60000
+// Other work triggered by a publish may take up to 1/(1+N) of the time.
+const PUBLISH_COST_FACTOR = 4
+
+/**
+ * When to publish the next batch of results (e.g. diagnostics) from a long
+ * sliced loop. Each publish makes other extensions react on this same thread
+ * (Windsurf re-reads every diagnostic in the workspace on each diagnostics
+ * change: seconds once there are tens of thousands), which publishing every
+ * second turned into a validation pass that practically never finished. The
+ * interval adapts to that cost, measured as the time spent away from the loop
+ * between publishes, keeping it to a fraction of the loop's own time.
+ */
+export class PublishSchedule {
+  private last = Date.now()
+  private interval = MIN_PUBLISH_INTERVAL_MS
+  private awayAtLast: number
+
+  constructor(private readonly slicer: TimeSlicer) {
+    this.awayAtLast = slicer.awayMs
+  }
+
+  get due(): boolean {
+    return Date.now() - this.last >= this.interval
+  }
+
+  /** Call right after publishing. */
+  published(): void {
+    const away = this.slicer.awayMs - this.awayAtLast
+    this.interval = Math.min(MAX_PUBLISH_INTERVAL_MS, Math.max(MIN_PUBLISH_INTERVAL_MS, away * PUBLISH_COST_FACTOR))
+    this.last = Date.now()
+    this.awayAtLast = this.slicer.awayMs
+  }
+}
+
+/** `items.filter(predicate)`, yielding between slices. */
+export async function filterSliced<T>(items: readonly T[], predicate: (item: T) => boolean, slicer: TimeSlicer): Promise<T[]> {
+  const out: T[] = []
+  for (const item of items) {
+    if (predicate(item)) out.push(item)
+    await slicer.tick()
+  }
+  return out
+}
diff --git a/apps/vscode-extension/src/validation.ts b/apps/vscode-extension/src/validation.ts
index 8ab771e..b6b60af 100644
--- a/apps/vscode-extension/src/validation.ts
+++ b/apps/vscode-extension/src/validation.ts
@@ -5,9 +5,10 @@ import * as jsonc from 'jsonc-parser'
 import { ValidationError, DEFAULT_GTS_CONFIG, parseGtsFileContent, isYamlFileName } from '@gts/shared'
 import type { JsonRegistry, JsonSchema, JsonObj } from '@gts/shared'
 import { getLastScanFiles } from './scanStore'
-import { getRegistry, rebuildRegistry, indexFile, removeFile, getMalformedIds, getPathsWithMalformedIds } from './registryStore'
+import { getRegistry, getRegistryRevision, rebuildRegistry, indexFile, removeFile, getMalformedIds, getPathsWithMalformedIds } from './registryStore'
 import { malformedGtsIdMessage } from './gtsIdFormat'
 import { isGtsCandidateFile, isIndexableGtsDocument } from './helpers'
+import { TimeSlicer, CancelledError, PublishSchedule } from './timeSlice'
 
 let diagnosticCollection: vscode.DiagnosticCollection
 let workspaceDiagnosticCollection: vscode.DiagnosticCollection
@@ -17,6 +18,13 @@ const documentValidationGenerations = new Map<string, number>()
 const validationCompletedListeners = new Set<(uri: vscode.Uri) => void>()
 let workspaceValidationGeneration = 0
 
+// Files whose GTS problems have been published at least once. Until then, a
+// file without diagnostics is "not validated yet", not "valid": on a large
+// workspace the first pass takes a while, and treating the absence of markers
+// as valid colored every not-yet-processed invalid file green.
+const validatedPaths = new Set<string>()
+const validationStateListeners = new Set<(uris: vscode.Uri[]) => void>()
+
 export function getDocumentValidationErrors(uri: vscode.Uri): ValidationError[] {
   return documentValidationErrors.get(uri.toString()) || []
 }
@@ -26,6 +34,39 @@ export function onValidationCompleted(listener: (uri: vscode.Uri) => void): vsco
   return new vscode.Disposable(() => validationCompletedListeners.delete(listener))
 }
 
+/** True once the file's validation result has been published (its diagnostics are authoritative). */
+export function isValidationKnown(fsPath: string): boolean {
+  return validatedPaths.has(fsPath)
+}
+
+/** Fires with the files whose validation result just became known. */
+export function onValidationStateChanged(listener: (uris: vscode.Uri[]) => void): vscode.Disposable {
+  validationStateListeners.add(listener)
+  return new vscode.Disposable(() => validationStateListeners.delete(listener))
+}
+
+/** The file left the index; if it comes back it is unvalidated again. */
+export function forgetValidationState(fsPath: string): void {
+  validatedPaths.delete(fsPath)
+}
+
+function markValidated(fsPaths: Iterable<string>): void {
+  const added: vscode.Uri[] = []
+  for (const fsPath of fsPaths) {
+    if (validatedPaths.has(fsPath)) continue
+    validatedPaths.add(fsPath)
+    added.push(vscode.Uri.file(fsPath))
+  }
+  if (added.length === 0) return
+  for (const listener of validationStateListeners) {
+    try {
+      listener(added)
+    } catch (err) {
+      console.error('[GTS Validation] Error in validation state listener:', err)
+    }
+  }
+}
+
 /**
  * A document's text plus its syntax tree, parsed lazily at most once and shared
  * by every error-position lookup of one validation (previously each error
@@ -133,7 +174,7 @@ function findErrorPosition(parsed: ParsedDocument, instancePath: string, error:
 
   // 3. For any error carrying an instance path, underline the offending node.
   // The choice of what to underline is STRUCTURAL, not keyword-specific: a
-  // scalar value (format/uuid/pattern/x-gts-abstract/x-gts-ref/type/enum on a
+  // scalar value (format/uuid/pattern/x-gts-abstract/x-gts-*-ref/type/enum on a
   // leaf, or the schema's own $id) is underlined directly; when the path
   // resolves to an object/array subschema (e.g. an OP#12 derivation error at
   // `/allOf/1/properties/level`, whose value is itself a schema) the property
@@ -149,9 +190,9 @@ function findErrorPosition(parsed: ParsedDocument, instancePath: string, error:
     }
   }
 
-  // 4. For gts:// prefix violations, x-gts-ref mismatches, malformed ids and
+  // 4. For gts:// prefix violations, reference keyword mismatches, malformed ids and
   // duplicate ids without a resolvable path, highlight the offending string value.
-  const valueKeywords = ['gts-uri-prefix', 'x-gts-ref', 'gts-id-format', 'gts-duplicate-id']
+  const valueKeywords = ['gts-uri-prefix', 'x-gts-type-ref', 'x-gts-instance-ref', 'x-gts-pattern-ref', 'gts-id-format', 'gts-duplicate-id']
   if (valueKeywords.includes(error.keyword) && error.params && 'value' in error.params) {
     const value = String((error.params as any).value)
     // Quoted (JSON, or a quoted YAML scalar) first, then bare YAML scalar.
@@ -585,6 +626,7 @@ export async function validateOpenDocument(document: vscode.TextDocument) {
       documentValidationErrors.delete(document.uri.toString())
       diagnosticCollection.delete(document.uri)
     }
+    markValidated([filePath])
 
     for (const listener of validationCompletedListeners) {
       try {
@@ -606,16 +648,48 @@ export async function validateOpenDocument(document: vscode.TextDocument) {
 // steady stream of edits/file events can no longer starve it.
 let workspaceValidationRunning = false
 let workspaceValidationWaiters: Array<() => void> = []
+let workspaceValidationIdleWaiters: Array<() => void> = []
+
+/** Files validated so far by the running workspace pass, out of `total`. */
+export interface WorkspaceValidationProgress {
+  done: number
+  total: number
+}
+
+const workspaceValidationProgressListeners = new Set<(progress: WorkspaceValidationProgress | undefined) => void>()
+
+/**
+ * Fires while workspace validation runs (at most every
+ * WORKSPACE_PROGRESS_INTERVAL_MS), and with `undefined` once it is idle.
+ */
+export function onWorkspaceValidationProgress(listener: (progress: WorkspaceValidationProgress | undefined) => void): vscode.Disposable {
+  workspaceValidationProgressListeners.add(listener)
+  return new vscode.Disposable(() => workspaceValidationProgressListeners.delete(listener))
+}
+
+function emitWorkspaceValidationProgress(progress: WorkspaceValidationProgress | undefined): void {
+  for (const listener of workspaceValidationProgressListeners) {
+    try {
+      listener(progress)
+    } catch (err) {
+      console.error('[GTS Validation] Error in validation progress listener:', err)
+    }
+  }
+}
+
+const WORKSPACE_PROGRESS_INTERVAL_MS = 250
+
+/** Resolves once no workspace validation pass is running or pending. */
+export function whenWorkspaceValidationIdle(): Promise<void> {
+  if (!workspaceValidationRunning) return Promise.resolve()
+  return new Promise(resolve => workspaceValidationIdleWaiters.push(resolve))
+}
 
 // Max time a pass validates before yielding back to the extension host's event
 // loop. Entity validation never yields on its own (it's all microtasks), so
 // without this a large workspace freezes hovers/tree/typing for seconds.
 const WORKSPACE_VALIDATION_SLICE_MS = 25
 
-function yieldToEventLoop(): Promise<void> {
-  return new Promise(resolve => setImmediate(resolve))
-}
-
 /**
  * Validate all indexed entities and publish coarse diagnostics for files that are
  * not currently open in an editor. This makes unopened invalid files visible in
@@ -651,6 +725,10 @@ async function drainWorkspaceValidation(): Promise<void> {
     }
   } finally {
     workspaceValidationRunning = false
+    emitWorkspaceValidationProgress(undefined)
+    const idleWaiters = workspaceValidationIdleWaiters
+    workspaceValidationIdleWaiters = []
+    for (const resolve of idleWaiters) resolve()
   }
 }
 
@@ -665,8 +743,8 @@ type RegistryEntity = JsonSchema | JsonObj
  */
 function entitiesByFile(registry: JsonRegistry): RegistryEntity[] {
   const entities: RegistryEntity[] = []
-  for (const list of registry.jsonFileSchemas.values()) entities.push(...list)
-  for (const list of registry.jsonFileObjs.values()) entities.push(...list)
+  for (const list of registry.jsonFileSchemas.values()) for (const entity of list) entities.push(entity)
+  for (const list of registry.jsonFileObjs.values()) for (const entity of list) entities.push(entity)
   return entities
 }
 
@@ -678,6 +756,16 @@ function isIndexedInItsFile(registry: JsonRegistry, entity: RegistryEntity): boo
     (registry.jsonFileObjs.get(filePath) || []).includes(entity as JsonObj)
 }
 
+/** True if both are the same coarse diagnostics (or both absent/empty). */
+function sameDiagnostics(a: readonly vscode.Diagnostic[] | undefined, b: readonly vscode.Diagnostic[] | undefined): boolean {
+  const left = a ?? []
+  const right = b ?? []
+  if (left.length !== right.length) return false
+  return left.every((d, i) =>
+    d.message === right[i].message && d.code === right[i].code && d.severity === right[i].severity &&
+    d.source === right[i].source && d.range.isEqual(right[i].range))
+}
+
 /** Coarse (line 0) diagnostic for a file that isn't open in an editor. */
 function coarseDiagnostic(problem: ValidationError): vscode.Diagnostic {
   const diagnostic = new vscode.Diagnostic(new vscode.Range(0, 0, 0, 1), problem.message, vscode.DiagnosticSeverity.Error)
@@ -791,69 +879,144 @@ function collectValidationErrors(registry: JsonRegistry, filePath: string, index
   ]
 }
 
+/** Paths of the GTS files currently open in an editor (they get precise diagnostics from validateOpenDocument). */
+function openGtsPaths(): Set<string> {
+  const openPaths = new Set<string>()
+  for (const doc of vscode.workspace.textDocuments) {
+    if (isGtsCandidateFile(doc)) openPaths.add(doc.uri.fsPath)
+  }
+  return openPaths
+}
+
+/** Every file the workspace pass reports on. */
+function workspaceFilePaths(registry: JsonRegistry): Set<string> {
+  const paths = new Set<string>()
+  for (const p of registry.jsonFileSchemas.keys()) paths.add(p)
+  for (const p of registry.jsonFileObjs.keys()) paths.add(p)
+  for (const p of registry.invalidFiles.keys()) paths.add(p)
+  for (const p of getPathsWithMalformedIds()) paths.add(p)
+  return paths
+}
+
 /** One full validation pass. Returns false if it was superseded and must rerun. */
 async function runWorkspaceValidationPass(): Promise<boolean> {
   const registry = getRegistry()
   if (!registry || !workspaceDiagnosticCollection) return true
+  const collection = workspaceDiagnosticCollection
   const validationGeneration = workspaceValidationGeneration
   const isSuperseded = () =>
     getRegistry() !== registry || workspaceValidationGeneration !== validationGeneration
   const startTime = Date.now()
+  const slicer = new TimeSlicer(isSuperseded, WORKSPACE_VALIDATION_SLICE_MS)
+  try {
+    return await validateWorkspace(registry, collection, slicer, startTime)
+  } catch (error) {
+    if (error instanceof CancelledError) return false
+    throw error
+  }
+}
+
+async function validateWorkspace(registry: JsonRegistry, collection: vscode.DiagnosticCollection, slicer: TimeSlicer, startTime: number): Promise<boolean> {
+  // Built on demand by the first validation, the gts-ts store would block the
+  // extension host for seconds on a large workspace; build it in slices first.
+  await registry.prepareGtsStore(() => slicer.tick())
+
+  // Files are validated one at a time and published in batches as the pass
+  // goes. Everything is indexed before validation starts, so the duplicate-id
+  // index is complete from the beginning; it is rebuilt when the registry
+  // changes mid-pass, and the final publish below recomputes every file anyway.
+  let index = buildDefinitionIndex(registry)
+  let indexRevision = getRegistryRevision()
+  let finished: string[] = []
+  const schedule = new PublishSchedule(slicer)
+  const publishFinished = () => {
+    if (getRegistryRevision() !== indexRevision) {
+      index = buildDefinitionIndex(registry)
+      indexRevision = getRegistryRevision()
+    }
+    const openPaths = openGtsPaths()
+    const closed = finished.filter(filePath => !openPaths.has(filePath))
+    const entries: Array<[vscode.Uri, vscode.Diagnostic[] | undefined]> = []
+    for (const filePath of closed) {
+      const uri = vscode.Uri.file(filePath)
+      const problems = collectValidationErrors(registry, filePath, index)
+      const diagnostics = problems.length > 0 ? problems.map(coarseDiagnostic) : undefined
+      if (!sameDiagnostics(collection.get(uri), diagnostics)) entries.push([uri, diagnostics])
+    }
+    if (entries.length > 0) collection.set(entries)
+    markValidated(closed)
+    finished = []
+    schedule.published()
+  }
 
   // Re-indexing a file replaces its entity objects, so rather than aborting when
   // the registry changes mid-pass, keep sweeping until every *current* entity has
   // been validated. Edits that land during the pass are picked up by the next
   // sweep; replaced entities are skipped.
   const validated = new Set<object>()
-  let sliceStart = Date.now()
+  const initialPaths = workspaceFilePaths(registry)
+  let pendingPaths: Iterable<string> = initialPaths
+  const progress: WorkspaceValidationProgress = { done: 0, total: initialPaths.size }
+  let lastProgress = Date.now()
+  emitWorkspaceValidationProgress({ ...progress })
   for (;;) {
-    const pending = entitiesByFile(registry).filter(entity => !validated.has(entity))
-    if (pending.length === 0) break
-    for (const entity of pending) {
-      validated.add(entity)
-      if (!isIndexedInItsFile(registry, entity)) continue
-      await registry.validateEntity(entity)
-      if (Date.now() - sliceStart >= WORKSPACE_VALIDATION_SLICE_MS) {
-        await yieldToEventLoop()
-        if (isSuperseded()) return false
-        sliceStart = Date.now()
+    let swept = 0
+    for (const filePath of pendingPaths) {
+      swept++
+      for (const entity of fileEntities(registry, filePath)) {
+        if (validated.has(entity)) continue
+        validated.add(entity)
+        if (!isIndexedInItsFile(registry, entity)) continue
+        await registry.validateEntity(entity)
+        await slicer.tick()
+      }
+      finished.push(filePath)
+      progress.done = Math.min(progress.done + 1, progress.total)
+      if (Date.now() - lastProgress >= WORKSPACE_PROGRESS_INTERVAL_MS) {
+        emitWorkspaceValidationProgress({ ...progress })
+        lastProgress = Date.now()
+      }
+      if (schedule.due) {
+        slicer.throwIfCancelled()
+        publishFinished()
       }
     }
+    if (swept === 0) break
+    pendingPaths = [...workspaceFilePaths(registry)].filter(filePath =>
+      fileEntities(registry, filePath).some(entity => !validated.has(entity)))
   }
-  if (isSuperseded()) return false
+  slicer.throwIfCancelled()
 
   // Collect from the registry's current state (open documents get precise
   // diagnostics from validateOpenDocument instead).
-  const openPaths = new Set<string>()
-  for (const doc of vscode.workspace.textDocuments) {
-    if (isGtsCandidateFile(doc)) openPaths.add(doc.uri.fsPath)
-  }
-
-  const index = buildDefinitionIndex(registry)
-  const filePaths = new Set([
-    ...registry.jsonFileSchemas.keys(),
-    ...registry.jsonFileObjs.keys(),
-    ...registry.invalidFiles.keys(),
-    ...getPathsWithMalformedIds()
-  ])
+  const openPaths = openGtsPaths()
+  index = buildDefinitionIndex(registry)
+  const filePaths = workspaceFilePaths(registry)
+  const closedPaths: string[] = []
   const diagnosticsByPath = new Map<string, vscode.Diagnostic[]>()
   for (const filePath of filePaths) {
     if (openPaths.has(filePath)) continue
+    closedPaths.push(filePath)
     const problems = collectValidationErrors(registry, filePath, index)
     if (problems.length > 0) diagnosticsByPath.set(filePath, problems.map(coarseDiagnostic))
+    await slicer.tick()
   }
 
   // Replace the collection's full contents. `set(entries)` only touches the
   // listed files, so files that became valid must be cleared explicitly or they
-  // keep stale red markers.
+  // keep stale red markers. Files whose markers the batches above already
+  // published unchanged are skipped: re-sending every file's markers made the
+  // whole UI stall at the end of a pass over a large workspace.
   const entries: Array<[vscode.Uri, vscode.Diagnostic[] | undefined]> = []
-  workspaceDiagnosticCollection.forEach(uri => {
+  collection.forEach(uri => {
     if (!diagnosticsByPath.has(uri.fsPath)) entries.push([uri, undefined])
   })
   for (const [filePath, diagnostics] of diagnosticsByPath.entries()) {
-    entries.push([vscode.Uri.file(filePath), diagnostics])
+    const uri = vscode.Uri.file(filePath)
+    if (!sameDiagnostics(collection.get(uri), diagnostics)) entries.push([uri, diagnostics])
   }
-  workspaceDiagnosticCollection.set(entries)
+  if (entries.length > 0) collection.set(entries)
+  markValidated(closedPaths)
   console.log(`[GTS Validation] Workspace pass: ${validated.size} entities, ${diagnosticsByPath.size} file(s) with problems (${Date.now() - startTime}ms)`)
   return true
 }
@@ -866,14 +1029,21 @@ async function runWorkspaceValidationPass(): Promise<boolean> {
 async function validateClosedFile(filePath: string, index?: DefinitionIndex): Promise<void> {
   const registry = getRegistry()
   if (!registry || !workspaceDiagnosticCollection) return
+  const uri = vscode.Uri.file(filePath)
+  const diagnostics = await closedFileDiagnostics(registry, filePath, index ?? buildDefinitionIndex(registry))
+  // Unchanged markers aren't re-sent: every diagnostics change makes other
+  // extensions re-process diagnostics.
+  if (!sameDiagnostics(workspaceDiagnosticCollection.get(uri), diagnostics)) workspaceDiagnosticCollection.set(uri, diagnostics)
+  markValidated([filePath])
+}
 
+/** Validate a closed file's entities and return its coarse diagnostics (undefined: none). */
+async function closedFileDiagnostics(registry: JsonRegistry, filePath: string, index: DefinitionIndex): Promise<vscode.Diagnostic[] | undefined> {
   // Entity validation itself is shared registry logic; here we only turn the
   // resulting problems into coarse (line-0) workspace diagnostics.
   await registry.validateFile(filePath)
-  const diagnostics = collectValidationErrors(registry, filePath, index ?? buildDefinitionIndex(registry)).map(coarseDiagnostic)
-
-  const uri = vscode.Uri.file(filePath)
-  workspaceDiagnosticCollection.set(uri, diagnostics.length > 0 ? diagnostics : undefined)
+  const diagnostics = collectValidationErrors(registry, filePath, index).map(coarseDiagnostic)
+  return diagnostics.length > 0 ? diagnostics : undefined
 }
 
 /**
@@ -922,20 +1092,105 @@ export async function revalidateDependents(changedPath: string, previousIds?: It
   }
   if (dependentPaths.size === 0) return
 
+  const openByPath = openGtsDocumentsByPath()
+  const slicer = new TimeSlicer()
+  for (const dependentPath of dependentPaths) {
+    const openDoc = openByPath.get(dependentPath)
+    if (openDoc) {
+      await validateOpenDocument(openDoc)
+    } else {
+      await validateClosedFile(dependentPath, index)
+    }
+    await slicer.tick()
+  }
+}
+
+function openGtsDocumentsByPath(): Map<string, vscode.TextDocument> {
   const openByPath = new Map<string, vscode.TextDocument>()
   for (const doc of vscode.workspace.textDocuments) {
     if (doc.uri.scheme === 'file' && isGtsCandidateFile(doc)) {
       openByPath.set(doc.uri.fsPath, doc)
     }
   }
+  return openByPath
+}
 
-  for (const dependentPath of dependentPaths) {
-    const openDoc = openByPath.get(dependentPath)
-    if (openDoc) {
-      await validateOpenDocument(openDoc)
-    } else {
-      await validateClosedFile(dependentPath, index)
+/**
+ * Revalidate `paths` together with everything affected by the files in
+ * `changed` (path -> ids it defined before the change): files depending on
+ * them and other definers of their ids. Used after a folder rescan. When that
+ * adds up to most of the workspace, a workspace pass (with its own progress)
+ * is started instead and this returns right away; otherwise `onProgress` gets
+ * files done / total.
+ */
+export async function revalidateFiles(
+  paths: Iterable<string>,
+  changed: ReadonlyMap<string, readonly string[]>,
+  onProgress?: (done: number, total: number) => void
+): Promise<void> {
+  const registry = getRegistry()
+  const collection = workspaceDiagnosticCollection
+  if (!registry || !collection) return
+  // A full rescan replacing the registry runs its own workspace pass.
+  const slicer = new TimeSlicer(() => getRegistry() !== registry)
+  try {
+    const index = buildDefinitionIndex(registry)
+    const targets = new Set(paths)
+    for (const [changedPath, oldIds] of changed) {
+      targets.add(changedPath)
+      for (const p of registry.getDependentFilePaths(changedPath, oldIds)) targets.add(p)
+      for (const id of new Set([...oldIds, ...registry.getEntityIdsForFile(changedPath)])) {
+        for (const p of index.get(id) || []) targets.add(p)
+      }
+      await slicer.tick()
+    }
+    const indexed = workspaceFilePaths(registry)
+    if (targets.size > indexed.size / 2) {
+      // Not awaited: the pass reports its own progress (at the top of the
+      // tree) and can take minutes, which left a rescanned folder's row
+      // looking stuck.
+      void validateWorkspaceInBackground()
+      return
     }
+
+    // Closed files' markers are published in batches, like the workspace pass's.
+    const openByPath = openGtsDocumentsByPath()
+    const schedule = new PublishSchedule(slicer)
+    let pending: Array<[vscode.Uri, vscode.Diagnostic[] | undefined]> = []
+    let pendingValidated: string[] = []
+    const publish = () => {
+      slicer.throwIfCancelled()
+      if (pending.length > 0) collection.set(pending)
+      markValidated(pendingValidated)
+      pending = []
+      pendingValidated = []
+      schedule.published()
+    }
+    let done = 0
+    let lastProgress = 0
+    for (const filePath of targets) {
+      const openDoc = openByPath.get(filePath)
+      const uri = vscode.Uri.file(filePath)
+      if (openDoc) {
+        await validateOpenDocument(openDoc)
+      } else if (indexed.has(filePath)) {
+        const diagnostics = await closedFileDiagnostics(registry, filePath, index)
+        if (!sameDiagnostics(collection.get(uri), diagnostics)) pending.push([uri, diagnostics])
+        pendingValidated.push(filePath)
+      } else if (collection.has(uri)) {
+        pending.push([uri, undefined])
+      }
+      done++
+      if (Date.now() - lastProgress >= WORKSPACE_PROGRESS_INTERVAL_MS) {
+        onProgress?.(done, targets.size)
+        lastProgress = Date.now()
+      }
+      if (schedule.due) publish()
+      await slicer.tick()
+    }
+    publish()
+  } catch (error) {
+    if (!(error instanceof CancelledError)) throw error
   }
 }
 
@@ -954,6 +1209,7 @@ export function countPublishedProblems(): number {
 export function resetValidationDiagnostics(): void {
   documentValidationErrors.clear()
   documentValidationGenerations.clear()
+  validatedPaths.clear()
   workspaceValidationGeneration++
   diagnosticCollection?.clear()
   workspaceDiagnosticCollection?.clear()
diff --git a/apps/web/src/components/EntitiesListMenu.tsx b/apps/web/src/components/EntitiesListMenu.tsx
index 1ffd688..4806d83 100644
--- a/apps/web/src/components/EntitiesListMenu.tsx
+++ b/apps/web/src/components/EntitiesListMenu.tsx
@@ -74,11 +74,12 @@ export function EntityList({ jsonObjs, schemas, invalidFiles, selectedEntity: se
 
   // Build the visible linear list in render order for keyboard navigation
   const visibleEntities: Array<Entity | JsonFile> = useMemo(() => {
-    const list: Array<Entity | JsonFile> = []
-    if (openJsonList) list.push(...filteredJsonObjs)
-    if (openSchemaList) list.push(...filteredSchemas)
-    if (openInvalidList) list.push(...filteredInvalidFiles)
-    return list
+    // concat, not push(...): spreading 100K+ items as call arguments overflows the stack.
+    return ([] as Array<Entity | JsonFile>).concat(
+      openJsonList ? filteredJsonObjs : [],
+      openSchemaList ? filteredSchemas : [],
+      openInvalidList ? filteredInvalidFiles : []
+    )
   }, [filteredJsonObjs, filteredSchemas, filteredInvalidFiles, openJsonList, openSchemaList, openInvalidList])
 
   // Notify parent of filtered entities for keyboard navigation (only when content actually changes)
diff --git a/apps/web/src/components/FileList.tsx b/apps/web/src/components/FileList.tsx
index 6314d4b..6a0afca 100644
--- a/apps/web/src/components/FileList.tsx
+++ b/apps/web/src/components/FileList.tsx
@@ -38,13 +38,11 @@ export function EntityList({ jsonObjs, schemas, selectedEntity: selectedEntity,
   const filteredSchemas = schemas.filter(s => match(s.file?.name || s.id, s.id))
 
   // Build the visible linear list in render order for keyboard navigation
-  const visibleEntities: Entity[] = []
-  if (openJsonList) {
-    visibleEntities.push(...filteredJsonObjs)
-  }
-  if (openSchemaList) {
-    visibleEntities.push(...filteredSchemas)
-  }
+  // concat, not push(...): spreading 100K+ items as call arguments overflows the stack.
+  const visibleEntities: Entity[] = ([] as Entity[]).concat(
+    openJsonList ? filteredJsonObjs : [],
+    openSchemaList ? filteredSchemas : []
+  )
 
   // Notify parent of filtered entities for keyboard navigation
   useEffect(() => {
diff --git a/apps/web/src/lib/schemaParser.ts b/apps/web/src/lib/schemaParser.ts
index 79e04d5..c121789 100644
--- a/apps/web/src/lib/schemaParser.ts
+++ b/apps/web/src/lib/schemaParser.ts
@@ -93,7 +93,7 @@ export function parseJsonToProperties(data: any, name = 'root'): PropertyInfo[]
           }
         }
 
-        // For plain nested objects, use recursive parsing without any x-gts-type special handling
+        // For plain nested objects, use recursive parsing without any reference-keyword special handling
         return {
           name: key,
           type: 'object',
@@ -157,9 +157,10 @@ export function parseSchemaToProperties(schema: any): PropertyInfo[] {
         description = description ? `${description}\n${patDescription}` : patDescription
       }
 
-      if (prop['x-gts-type']) {
-        const gtsTypeDescription = `GTS Type: ${prop['x-gts-type']}`
-        description = description ? `${description}\n${gtsTypeDescription}` : gtsTypeDescription
+      for (const [keyword, label] of [['x-gts-type-ref', 'GTS Type'], ['x-gts-instance-ref', 'GTS Instance'], ['x-gts-pattern-ref', 'GTS Pattern']] as const) {
+        if (!prop[keyword]) continue
+        const refDescription = `${label}: ${prop[keyword]}`
+        description = description ? `${description}\n${refDescription}` : refDescription
         isGtsType = true
       }
 
diff --git a/docs/GTS_TS_MIGRATION.md b/docs/GTS_TS_MIGRATION.md
index 1772af6..4982339 100644
--- a/docs/GTS_TS_MIGRATION.md
+++ b/docs/GTS_TS_MIGRATION.md
@@ -4,7 +4,7 @@
 
 gts-ts now owns parsing, entity extraction, schema meta-validation, instance
 validation, derivation, traits, modifiers, formats, `$ref` resolution, and
-`x-gts-ref` validation. gts-kit consumes the structured results and only maps
+reference-keyword (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) validation. gts-kit consumes the structured results and only maps
 JSON Pointer paths to editor ranges.
 
 `packages/shared` depends on the official `@globaltypesystem/gts-ts` NPM
@@ -38,7 +38,7 @@ interface ValidationResult {
 
 The legacy joined `error` string remains unchanged for compatibility. Structured
 issues are returned for JSON Schema assertions, schema meta-validation,
-derivation constraints, traits, abstract instances, and `x-gts-ref` failures.
+derivation constraints, traits, abstract instances, and reference-keyword (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) failures.
 
 ### Full schema validation
 
@@ -49,7 +49,7 @@ derivation constraints, traits, abstract instances, and `x-gts-ref` failures.
 - derivation compatibility;
 - trait validation;
 - GTS `$ref` resolution;
-- `x-gts-ref` declaration, existence, and transitive validity checks.
+- reference-keyword (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) declaration, existence, and transitive validity checks.
 
 The additive `validateSchemaAsync` and `validateInstanceAsync` methods provide
 Promise-based entry points without changing synchronous APIs.
@@ -81,10 +81,10 @@ JSONC comments and trailing commas are supported. YAML selection is based on the
 
 - a local Ajv instance or schema loader;
 - local format registration and temporal-format composition;
-- local `x-gts-ref` stripping/combinator normalization;
+- local reference-keyword (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) stripping/combinator normalization;
 - local Ajv error formatting;
 - local abstract-instance checks;
-- local `x-gts-ref` instance validation;
+- local reference-keyword (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) instance validation;
 - derivation error-string parsing and schema-property path reconstruction.
 
 Direct `ajv` and `ajv-formats` dependencies were removed from all gts-kit
diff --git a/examples/events/schemas/gts.x.core.events.topic.v1~.schema.json b/examples/events/schemas/gts.x.core.events.topic.v1~.schema.json
index 52ce887..beefd7b 100644
--- a/examples/events/schemas/gts.x.core.events.topic.v1~.schema.json
+++ b/examples/events/schemas/gts.x.core.events.topic.v1~.schema.json
@@ -13,14 +13,15 @@
     "id": {
       "description": "Identifier for the topic/stream in GTS notation.",
       "type": "string",
-      "x-gts-type": "/$id"
+      "x-gts-instance-ref": "/$id"
     },
     "name": { "type": "string", "minLength": 1 },
     "description": { "type": "string" },
     "retention": {
       "description": "How long events are retained. ISO-8601 duration recommended (e.g., P30D).",
       "type": "string",
-      "pattern": "^P(?!$)(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+S)?)?$"
+      "minLength": 2,
+      "pattern": "^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+S)?)?$"
     },
     "ordering": {
       "description": "Ordering model for the stream.",
@@ -49,7 +50,8 @@
         "window": {
           "description": "Only for time-window strategy: ISO-8601 duration.",
           "type": "string",
-          "pattern": "^P(?!$)(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+S)?)?$"
+          "minLength": 2,
+          "pattern": "^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+S)?)?$"
         },
         "keyPaths": {
           "description": "One or more JSON Pointers used to build the dedup key.",
diff --git a/examples/events/schemas/gts.x.core.events.type.v1~.schema.json b/examples/events/schemas/gts.x.core.events.type.v1~.schema.json
index c558aee..19bac26 100644
--- a/examples/events/schemas/gts.x.core.events.type.v1~.schema.json
+++ b/examples/events/schemas/gts.x.core.events.type.v1~.schema.json
@@ -15,14 +15,14 @@
     "topicRef": {
       "description": "ID of the topic where events of this type are stored.",
       "type": "string",
-      "x-gts-type":"gts.x.core.events.topic.v1~"
+      "x-gts-instance-ref": "gts.x.core.events.topic.v1~"
     }
   },
   "properties": {
     "type": {
       "description": "Identifier of the event type in GTS format.",
       "type": "string",
-      "x-gts-type": "./$id"
+      "x-gts-type-ref": "/$id"
     },
     "$schema": {
       "description": "Link to the event type schema.",
@@ -82,7 +82,7 @@
     "subjectType": {
       "description": "GTS type of the subject of the event.",
       "type": "string",
-      "x-gts-type": "*",
+      "x-gts-type-ref": "gts.*",
       "$comment": "The value is mandatory if subject is present"
     }
   },
diff --git a/examples/events/schemas/gts.x.core.events.type.v1~x.commerce.orders.order_placed.v1~.schema.json b/examples/events/schemas/gts.x.core.events.type.v1~x.commerce.orders.order_placed.v1~.schema.json
index ff27c72..f1f509a 100644
--- a/examples/events/schemas/gts.x.core.events.type.v1~x.commerce.orders.order_placed.v1~.schema.json
+++ b/examples/events/schemas/gts.x.core.events.type.v1~x.commerce.orders.order_placed.v1~.schema.json
@@ -25,7 +25,7 @@
         },
         "subjectType": {
           "type": "string",
-          "x-gts-type": "gts.x.commerce.orders.order.v1.0~"
+          "x-gts-type-ref": "gts.x.commerce.orders.order.v1.0~"
         }
       }
     }
diff --git a/examples/events/schemas/gts.x.core.events.type.v1~x.core.idp.contact_created.v1~.schema.json b/examples/events/schemas/gts.x.core.events.type.v1~x.core.idp.contact_created.v1~.schema.json
index 0881a04..3611663 100644
--- a/examples/events/schemas/gts.x.core.events.type.v1~x.core.idp.contact_created.v1~.schema.json
+++ b/examples/events/schemas/gts.x.core.events.type.v1~x.core.idp.contact_created.v1~.schema.json
@@ -27,7 +27,7 @@
         },
         "subjectType": {
           "type": "string",
-          "x-gts-type": "gts.x.core.idp.contact.v1.0~"
+          "x-gts-type-ref": "gts.x.core.idp.contact.v1.0~"
         }
       },
       "x-event-type-settings": {
diff --git a/package-lock.json b/package-lock.json
index 1761749..5e55db2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "gts-monorepo",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "gts-monorepo",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "workspaces": [
         "apps/*",
         "packages/*"
@@ -22,7 +22,7 @@
     },
     "apps/electron": {
       "name": "@gts-viewer/electron",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "dependencies": {
         "@dagrejs/dagre": "^1.1.5",
         "@gts-viewer/shared": "file:../../packages/shared",
@@ -75,7 +75,7 @@
     },
     "apps/server": {
       "name": "@gts/server",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "dependencies": {
         "@gts/shared": "*",
         "cors": "2.8.5",
@@ -108,7 +108,7 @@
     },
     "apps/vscode-extension": {
       "name": "gts-kit",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "license": "Apache-2.0",
       "devDependencies": {
         "@types/node": "^20.11.30",
@@ -1734,18 +1734,16 @@
       }
     },
     "node_modules/@globaltypesystem/gts-ts": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@globaltypesystem/gts-ts/-/gts-ts-0.8.1.tgz",
-      "integrity": "sha512-uwNcWjWT/iekUo14z7c1uPbLKcSq2jne/d5gOKA3XvBDKhH1fvfji2AArIPIUbNtu+LrNy0JsdQ+Eid5caHzqw==",
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@globaltypesystem/gts-ts/-/gts-ts-0.11.0.tgz",
+      "integrity": "sha512-lZYx+DPzrz6zAYNOTVxstNGT6o+aiBlaDsB0T7bmQT/BOAE4UTsDa3cY3/44M300UD0QTqG1pgws7v79BN/isA==",
       "license": "Apache-2.0",
       "dependencies": {
-        "ajv": "^8.18.0",
-        "ajv-formats": "^2.1.1",
         "commander": "^12.0.0",
-        "fastify": "^5.12.2",
+        "fastify": "^5.12.5",
+        "json-schema-library": "11.6.14",
         "jsonc-parser": "^3.3.1",
-        "re2-wasm": "^1.0.2",
-        "regjsparser": "^0.13.3",
+        "re2js": "^2.8.6",
         "uuid": "^11.1.1",
         "yaml": "^2.9.1"
       },
@@ -1757,23 +1755,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/@globaltypesystem/gts-ts/node_modules/ajv-formats": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
-      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@gts-viewer/electron": {
       "resolved": "apps/electron",
       "link": true
@@ -1860,6 +1841,30 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/@hyperjump/json-schema-formats": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@hyperjump/json-schema-formats/-/json-schema-formats-1.1.0.tgz",
+      "integrity": "sha512-vLMIOwMThlgWgPJBV39Ds7kaTaygK0+UxjvQShTmKB8rRy8HXq472jnHP8/uaik+77HDx2M+W5Bvzhq6zFc2zQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@hyperjump/uri": "^1.3.2",
+        "idn-hostname": "^15.1.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/hyperjump-io"
+      }
+    },
+    "node_modules/@hyperjump/uri": {
+      "version": "1.3.9",
+      "resolved": "https://registry.npmjs.org/@hyperjump/uri/-/uri-1.3.9.tgz",
+      "integrity": "sha512-cxG5vyIdx3gUb/OQD/FDruQQcGNzF2aKTXWJ6LzlAC1kh97YZQSRsF3hL274xlTDJ1nWGJGRtknlW6ZpU3Ch+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/jdesrosiers"
+      }
+    },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
@@ -2955,6 +2960,12 @@
         "win32"
       ]
     },
+    "node_modules/@sagold/json-pointer": {
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/@sagold/json-pointer/-/json-pointer-7.2.1.tgz",
+      "integrity": "sha512-8EX4r5Royl5M3qNPTh5W5njdOtRqbWgQfVv26DbzjGj2/55b60EqvbiqUIglzw7fADfY/Io6jDJxGNJHmC+g8g==",
+      "license": "MIT"
+    },
     "node_modules/@sindresorhus/is": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
@@ -7908,6 +7919,12 @@
         "@types/yauzl": "^2.9.1"
       }
     },
+    "node_modules/fast-copy": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/fast-copy/-/fast-copy-4.3.0.tgz",
+      "integrity": "sha512-oWBZLHWpUYt2A471n+ayC4+bJSGDWpl2h3COgBxYX5xHFnr7KqOSrYJZX82ZmrtAfVK+SqsOuNMgsoL+lJquuQ==",
+      "license": "MIT"
+    },
     "node_modules/fast-decode-uri-component": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/fast-decode-uri-component/-/fast-decode-uri-component-1.0.1.tgz",
@@ -8873,6 +8890,18 @@
         "node": "^8.11.2 || >=10"
       }
     },
+    "node_modules/idn-hostname": {
+      "version": "15.1.19",
+      "resolved": "https://registry.npmjs.org/idn-hostname/-/idn-hostname-15.1.19.tgz",
+      "integrity": "sha512-pRGRbFpQWCptOBWw9Gn5DXtPdern5/XtdkcXdoEavjd+sh72jNm2eVI1eeysp64UisXPfaqoQrnLUKpSN4hJWw==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20.12.0 <21 || >=22.0.0"
+      }
+    },
     "node_modules/ieee754": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
@@ -9216,6 +9245,7 @@
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
       "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
       "license": "MIT",
       "bin": {
         "jsesc": "bin/jsesc"
@@ -9231,6 +9261,36 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/json-schema-library": {
+      "version": "11.6.14",
+      "resolved": "https://registry.npmjs.org/json-schema-library/-/json-schema-library-11.6.14.tgz",
+      "integrity": "sha512-fN8X+ZBUOPDF7B9ZBjVq4ZKay0K/U9KQeJrQp4GqvjiPCMw/En8EJM0OHcFKBHynz6MDPJ0lIm/CZFbk0WhbZA==",
+      "license": "MIT",
+      "dependencies": {
+        "@hyperjump/json-schema-formats": "^1.0.8",
+        "@sagold/json-pointer": "^7.2.1",
+        "fast-copy": "^4.2.0",
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^4.2.2",
+        "valid-url": "^1.0.9"
+      }
+    },
+    "node_modules/json-schema-library/node_modules/fast-uri": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-4.2.3.tgz",
+      "integrity": "sha512-I1PXwP5eAhlNlcdpjt9CgB59op2ZvZfxw+BkqGFVIUOgNpCVTcTqp3HhTX7brxj5vsip+nSY4nTvff+eIA76hg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
     "node_modules/json-schema-ref-resolver": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-ref-resolver/-/json-schema-ref-resolver-3.0.0.tgz",
@@ -10780,7 +10840,6 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
       "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -10905,13 +10964,13 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/re2-wasm": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/re2-wasm/-/re2-wasm-1.0.2.tgz",
-      "integrity": "sha512-VXUdgSiUrE/WZXn6gUIVVIsg0+Hp6VPZPOaHCay+OuFKy6u/8ktmeNEf+U5qSA8jzGGFsg8jrDNu1BeHpz2pJA==",
-      "license": "Apache-2.0",
+    "node_modules/re2js": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/re2js/-/re2js-2.9.0.tgz",
+      "integrity": "sha512-rZpqkd4ETP3GrQ5mDLzADr14OleeKdb/40lG84WE8absRfsVLJpWt2ifjtYYeoPqeouIkcxhTlurxIXfR5kR5Q==",
+      "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=20.0.0"
       }
     },
     "node_modules/react": {
@@ -11067,18 +11126,6 @@
         "node": ">= 12.13.0"
       }
     },
-    "node_modules/regjsparser": {
-      "version": "0.13.3",
-      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.3.tgz",
-      "integrity": "sha512-ycwFAS14Jw4mppvmK4GR/J6u3WpWpjkEApehuHtLc/8VpPNpDMbQ4WjqwplXifGeyKOzHSFLmSPqzksDQE2Sfg==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "jsesc": "~3.1.0"
-      },
-      "bin": {
-        "regjsparser": "bin/parser"
-      }
-    },
     "node_modules/require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
@@ -12855,6 +12902,11 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/valid-url": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/valid-url/-/valid-url-1.0.9.tgz",
+      "integrity": "sha512-QQDsV8OnSf5Uc30CKSwG9lnhMPe6exHtTXLRYX8uMwKENy640pU+2BgBL0LRbDh/eYRahNCS7aewCx0wf3NYVA=="
+    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -13793,7 +13845,7 @@
     },
     "packages/layout-storage": {
       "name": "@gts/layout-storage",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "devDependencies": {
         "typescript": "^5.3.3"
       }
@@ -13816,7 +13868,7 @@
       "name": "@gts/shared",
       "version": "0.2.7",
       "dependencies": {
-        "@globaltypesystem/gts-ts": "^0.8.1",
+        "@globaltypesystem/gts-ts": "^0.11.0",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "js-yaml": "^4.1.0",
diff --git a/package.json b/package.json
index b7b10cb..5c3ff3b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "gts-monorepo",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": true,
   "workspaces": [
     "apps/*",
diff --git a/packages/layout-storage/package.json b/packages/layout-storage/package.json
index a737a2c..5e02b21 100644
--- a/packages/layout-storage/package.json
+++ b/packages/layout-storage/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@gts/layout-storage",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 7d57a7b..f641cbf 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -16,7 +16,7 @@
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@globaltypesystem/gts-ts": "^0.8.1",
+    "@globaltypesystem/gts-ts": "^0.11.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "js-yaml": "^4.1.0",
diff --git a/packages/shared/src/entities.ts b/packages/shared/src/entities.ts
index 2c12daa..48a3341 100644
--- a/packages/shared/src/entities.ts
+++ b/packages/shared/src/entities.ts
@@ -3,7 +3,8 @@ import {
   validateGtsID as gtsValidateID,
   matchIDPattern as gtsMatchIDPattern,
   extractID as gtsExtractID,
-  Gts
+  Gts,
+  X_GTS_REF_SELF
 } from '@globaltypesystem/gts-ts'
 import type {
   ValidationResult as GtsValidationResult,
@@ -49,10 +50,21 @@ export function normalizeGtsId(id: string): string {
  * Does NOT accept wildcard patterns — use {@link isGtsIdOrPattern} for that.
  */
 export function isGtsId(value: string): boolean {
-  if (!value || typeof value !== 'string') return false
+  const result = validateNormalizedGtsId(value)
+  return !!result && result.ok && !result.is_wildcard
+}
+
+/**
+ * gts-ts validation of the normalized value, or null when it can't be a GTS id
+ * at all. gts-ts reports a missing "gts." prefix by throwing (and catching) an
+ * error, which made checking every string of every scanned file - nearly all of
+ * them plain words or URLs - the dominant cost of indexing a large workspace.
+ */
+function validateNormalizedGtsId(value: string): GtsValidationResult | null {
+  if (!value || typeof value !== 'string') return null
   const normalized = normalizeGtsId(value)
-  const result = gtsValidateID(normalized)
-  return result.ok && !result.is_wildcard
+  if (!normalized.startsWith('gts.')) return null
+  return gtsValidateID(normalized)
 }
 
 /**
@@ -90,10 +102,7 @@ export function isGtsObj(value: string): boolean {
  * isGtsIdOrPattern('not-a-gts-id')                  // false
  */
 export function isGtsIdOrPattern(value: string): boolean {
-  if (!value || typeof value !== 'string') return false
-  const normalized = normalizeGtsId(value)
-  const result = gtsValidateID(normalized)
-  return result.ok
+  return validateNormalizedGtsId(value)?.ok === true
 }
 
 /**
@@ -109,24 +118,22 @@ export function isGtsIdOrPattern(value: string): boolean {
  * isGtsPattern('gts.x.core.events.type.v1~')   // false (full ID, not a pattern)
  */
 export function isGtsPattern(value: string): boolean {
-  if (!value || typeof value !== 'string') return false
-  const normalized = normalizeGtsId(value)
-  const result = gtsValidateID(normalized)
-  return result.ok && (result.is_wildcard === true)
+  const result = validateNormalizedGtsId(value)
+  return !!result && result.ok && (result.is_wildcard === true)
 }
 
 /**
- * Check if a GTS x-gts-ref value is valid. Accepts:
- * - Full GTS type IDs (e.g. "gts.vendor.pkg.ns.type.v1~")
+ * Check if a GTS reference keyword operand (`x-gts-type-ref`,
+ * `x-gts-instance-ref`, `x-gts-pattern-ref`) is valid. Accepts:
+ * - Full GTS IDs (e.g. "gts.vendor.pkg.ns.type.v1~")
  * - Wildcard patterns (e.g. "gts.*", "gts.vendor.pkg.*")
- * - JSON Pointer references starting with "/" (e.g. "/$id")
+ * - The reserved selected-type operand "/$id"
  *
  * Uses the official gts-ts library for GTS ID/pattern validation.
  */
 export function isValidXGtsRef(value: string): boolean {
   if (!value || typeof value !== 'string') return false
-  // JSON Pointer references are valid x-gts-ref values
-  if (value.startsWith('/')) return true
+  if (value === X_GTS_REF_SELF) return true
   // Otherwise validate as GTS ID or pattern
   return isGtsIdOrPattern(value)
 }
@@ -513,15 +520,9 @@ export class JsonEntity {
             return
           }
           if (typeof node === 'object') {
+            // A string value is checked (once) by the recursive call itself.
             Object.entries(node).forEach(([k, v]) => {
-              const nextPath = currentPath ? `${currentPath}.${k}` : k
-              if (typeof v === 'string') {
-                const normalized = normalizeGtsId(v)
-                if (isGtsId(normalized)) {
-                  found.push({ id: normalized, sourcePath: nextPath })
-                }
-              }
-              walk(v, nextPath)
+              walk(v, currentPath ? `${currentPath}.${k}` : k)
             })
           }
         }
diff --git a/packages/shared/src/gts-styling.ts b/packages/shared/src/gts-styling.ts
index f6d2a05..5b669d6 100644
--- a/packages/shared/src/gts-styling.ts
+++ b/packages/shared/src/gts-styling.ts
@@ -66,7 +66,7 @@ export interface GtsStyleAnalysis {
  * authoritative gts-ts validation results surfaced through `entityLookup`:
  * a segment whose cumulative entity failed gts-ts validation (`isValid: false`)
  * is rendered as an error. GTS *rule* violations (abstract instantiation,
- * derivation incompatibility, x-gts-ref, ...) are therefore not re-derived here;
+ * derivation incompatibility, reference keywords, ...) are therefore not re-derived here;
  * they are read back from `entityLookup`/the caller's validation errors, keeping
  * gts-ts the single source of truth.
  *
diff --git a/packages/shared/src/registry.ts b/packages/shared/src/registry.ts
index b6c0c91..0cc71fe 100644
--- a/packages/shared/src/registry.ts
+++ b/packages/shared/src/registry.ts
@@ -4,7 +4,7 @@ import { isYamlFileName } from './parse.js'
 import { findSchemaPropertyPath, findXGtsRefPath, findTraitRequiredPath, findRegexPatternPath, getInstanceFieldSubschema } from './schemaParser.js'
 import Ajv, { type ValidateFunction, type ErrorObject } from 'ajv'
 import addFormats from 'ajv-formats'
-import { GtsModifiers, GtsStore, GtsRefValidationMode, createJsonEntity } from '@globaltypesystem/gts-ts'
+import { GtsModifiers, GtsStore, GtsRefValidationMode, createJsonEntity, GTS_REF_KEYWORDS, X_GTS_TYPE_REF, X_GTS_INSTANCE_REF, X_GTS_PATTERN_REF } from '@globaltypesystem/gts-ts'
 // XGtsRefValidator is not re-exported from the package index, so import it from
 // its published subpath module.
 import { XGtsRefValidator } from '@globaltypesystem/gts-ts/dist/x-gts-ref.js'
@@ -26,33 +26,121 @@ const JSON_SCHEMA_ANNOTATION_KEYWORDS = new Set([
 ])
 
 /**
- * Prepare a schema for Ajv instance validation by removing the `x-gts-ref`
- * keyword, mirroring gts-ts's own `GtsStore.normalizeSchema` (the reference
- * implementation strips `x-gts-ref` "so Ajv never sees the unknown keyword"
- * and then prunes combinator branches that were `x-gts-ref`-only).
+ * A gts-ts GtsStore holding the registry's winning entity for each id, plus
+ * what registering them reported.
+ */
+class GtsStoreMirror {
+  readonly store = new GtsStore()
+  // Modifier-declaration errors captured while registering schemas into the
+  // gts-ts store (register() throws these per §9.11.1), keyed by schema id.
+  readonly declErrors = new Map<string, string>()
+  // Registry id -> id the entity is registered under in the store, so a
+  // removed/replaced entity can be unregistered without re-extracting its id.
+  private readonly storeIds = new Map<string, string>()
+  // Ids matching a wildcard pattern, valid until the store's entity set changes.
+  private readonly matchCache = new Map<string, string[]>()
+
+  constructor() {
+    // gts-ts resolves a wildcard reference operand by testing every registered
+    // id under the pattern's literal prefix, on every validation that reaches
+    // it; with `gts.x.*`-style operands and 100K+ entities that dominated
+    // workspace validation. The result only depends on the registered ids, and
+    // this mirror performs every mutation of the store, so it is memoized here
+    // until the next add/remove. (Private gts-ts method: if it is renamed, the
+    // store simply runs unmemoized.)
+    const store = this.store as unknown as { matchingIds?: (pattern: string) => string[] }
+    const matchingIds = store.matchingIds
+    if (typeof matchingIds !== 'function') return
+    store.matchingIds = (pattern: string) => {
+      let ids = this.matchCache.get(pattern)
+      if (!ids) {
+        ids = matchingIds.call(this.store, pattern)
+        this.matchCache.set(pattern, ids)
+      }
+      return ids
+    }
+  }
+
+  /** Register `entity`, replacing whatever was registered for its id. */
+  add(entity: JsonEntity): void {
+    this.matchCache.clear()
+    this.remove(entity.id)
+    const storeEntity = createJsonEntity(entity.content)
+    try {
+      this.store.register(storeEntity)
+      this.storeIds.set(entity.id, storeEntity.id)
+    } catch (err) {
+      // A schema register() rejects (§9.11.1 declaration error) is reported by
+      // validateEntity; an instance that can't be registered (e.g. malformed or
+      // UUID-less id) is reported through the normal instance-validation path.
+      if (entity instanceof JsonSchema) {
+        this.declErrors.set(entity.id, err instanceof Error ? err.message : String(err))
+      }
+    }
+  }
+
+  /** Unregister whatever is registered for registry id `id`. */
+  remove(id: string): void {
+    this.declErrors.delete(id)
+    const storeId = this.storeIds.get(id)
+    if (storeId === undefined) return
+    this.storeIds.delete(id)
+    this.matchCache.clear()
+    this.store.unregister(storeId)
+  }
+}
+
+/** True when two file contents (parsed values, or raw text for unparsable files) are identical. */
+function sameFileContent(a: any, b: any): boolean {
+  if (a === b) return true
+  if (typeof a === 'string' || typeof b === 'string') return false
+  try {
+    return JSON.stringify(a) === JSON.stringify(b)
+  } catch {
+    return false
+  }
+}
+
+/** The reference keywords whose values name concrete entities (§9.6.1). */
+const ENTITY_REF_KEYWORDS = [X_GTS_TYPE_REF, X_GTS_INSTANCE_REF]
+
+/** True for the GTS reference keywords (`x-gts-type-ref`, `x-gts-instance-ref`, `x-gts-pattern-ref`). */
+function isGtsRefKeyword(key: string): boolean {
+  return (GTS_REF_KEYWORDS as readonly string[]).includes(key)
+}
+
+/** True when `schema` declares any GTS reference keyword. */
+function hasGtsRefKeyword(schema: any): boolean {
+  return GTS_REF_KEYWORDS.some(key => schema[key] !== undefined)
+}
+
+/**
+ * Prepare a schema for Ajv instance validation by removing the GTS reference
+ * keywords (`x-gts-type-ref`, `x-gts-instance-ref`, `x-gts-pattern-ref`) and
+ * pruning combinator branches that were reference-keyword-only.
  *
- * This matters for combinators: a branch like `{ "x-gts-ref": "…" }` becomes an
+ * This matters for combinators: a branch like `{ "x-gts-type-ref": "…" }` becomes an
  * empty schema once the keyword is dropped, i.e. always-true. Left in place, an
  * `oneOf` of two such branches matches *both* and Ajv spuriously reports
  * "must match exactly one schema in oneOf" for a value that is perfectly valid.
- * The actual `x-gts-ref` assertions — including correct oneOf/anyOf branch
- * counting — are enforced separately by `XGtsRefValidator` (§9.6).
+ * The actual reference assertions — including correct oneOf/anyOf branch
+ * counting — are enforced separately by the gts-ts store (§9.6).
  *
  * Unlike gts-ts's full `normalizeSchema`, this intentionally does NOT rewrite
  * `$id`/`$ref` (it leaves any `gts://` prefixes untouched) because the
  * registry's Ajv instance resolves those via its own `gts://`-aware loader.
  */
-function stripXGtsRefForAjv(schema: any): any {
+function stripGtsRefKeywordsForAjv(schema: any): any {
   if (schema === null || typeof schema !== 'object') return schema
-  if (Array.isArray(schema)) return schema.map(stripXGtsRefForAjv)
+  if (Array.isArray(schema)) return schema.map(stripGtsRefKeywordsForAjv)
 
   const normalized: Record<string, any> = {}
   for (const [key, value] of Object.entries(schema)) {
-    if (key === 'x-gts-ref') continue
-    normalized[key] = value && typeof value === 'object' ? stripXGtsRefForAjv(value) : value
+    if (isGtsRefKeyword(key)) continue
+    normalized[key] = value && typeof value === 'object' ? stripGtsRefKeywordsForAjv(value) : value
   }
 
-  // Drop combinator subschemas whose only assertion was `x-gts-ref`, so Ajv
+  // Drop combinator subschemas whose only assertion was a reference keyword, so Ajv
   // doesn't treat their remaining annotations as always-true branches.
   for (const combinator of ['oneOf', 'anyOf', 'allOf'] as const) {
     if (!Array.isArray(normalized[combinator])) continue
@@ -62,8 +150,8 @@ function stripXGtsRefForAjv(schema: any): any {
         original &&
         typeof original === 'object' &&
         !Array.isArray(original) &&
-        original['x-gts-ref'] !== undefined &&
-        Object.keys(original).every(key => key === 'x-gts-ref' || JSON_SCHEMA_ANNOTATION_KEYWORDS.has(key))
+        hasGtsRefKeyword(original) &&
+        Object.keys(original).every(key => isGtsRefKeyword(key) || JSON_SCHEMA_ANNOTATION_KEYWORDS.has(key))
       return !hasOnlyXGtsRefAssertion
     })
     if (normalized[combinator].length === 0) delete normalized[combinator]
@@ -88,6 +176,110 @@ function matchesFormat(format: Format, value: string): boolean {
   return false
 }
 
+/** Ajv configured for GTS: the options, formats and keywords every instance shares. */
+function createGtsAjv(options: { validateSchema?: boolean; loadSchema?: (uri: string) => Promise<any> } = {}): Ajv {
+  const ajv = new Ajv({
+    strict: false,
+    allErrors: true,
+    verbose: true,
+    // Enable full JSON Schema support
+    discriminator: true,
+    allowUnionTypes: true,
+    // Provide data alongside errors
+    $data: true,
+    // Disable code generation for CSP compliance (VS Code webviews)
+    code: { source: false },
+    ...options
+  })
+
+  // Add format validation (email, uri, date-time, etc.). Default "full" mode
+  // validates real value ranges (e.g. rejects month 13, offset +25:00).
+  addFormats(ajv)
+
+  // Tighten the temporal formats to strict RFC 3339. ajv-formats' full-mode
+  // date/time splits on `/t|\s/i`, so it accepts a space instead of `T`
+  // (permitted by RFC 3339 §5.6's NOTE, but not by the ABNF grammar GTS
+  // requires). Compose the two *standard* ajv-formats validators so a value
+  // must satisfy BOTH: the "fast" grammar (strict `T` separator + mandatory
+  // time-offset) AND the "full" validator (real calendar/clock ranges).
+  for (const name of ['date', 'time', 'date-time'] as const) {
+    const fast = addFormats.get(name, 'fast')
+    const full = addFormats.get(name, 'full')
+    ajv.addFormat(name, {
+      type: 'string',
+      validate: (value: string) => matchesFormat(fast, value) && matchesFormat(full, value),
+    })
+  }
+
+  // GTS id formats emitted by schema generators (e.g. gts-rust) as annotations
+  // next to an `x-gts-type-ref`/`x-gts-instance-ref` that does the actual checking. Registered as
+  // accept-all — exactly how Ajv treated them before (ignored as unknown) —
+  // so each compile no longer logs an "unknown format" warning.
+  // Same for the sized-integer formats Rust's schemars emits (int32/int64 are
+  // already provided by ajv-formats).
+  for (const name of ['gts-instance-id', 'gts-type-id', 'int8', 'int16', 'uint', 'uint8', 'uint16', 'uint32', 'uint64']) {
+    ajv.addFormat(name, true)
+  }
+
+  // Add custom schema loader that resolves GTS IDs from the registry
+  ajv.addKeyword({
+    keyword: 'gtsRef',
+    schemaType: 'string',
+  })
+
+  return ajv
+}
+
+// Meta-schema validation depends only on the Ajv options, never on the
+// registry, so one instance — whose meta-schemas are compiled once — serves
+// every schema. Each schema still compiles in its own fresh instance, and that
+// instance used to compile the draft-07 meta-schema from scratch first: ~80% of
+// all validation time, minutes on a workspace with 100K+ schemas.
+let sharedMetaValidator: Ajv | null = null
+
+/** True for the json-schema.org URIs the registry's schema loader resolves to `true` (accept-all). */
+function isStandardJsonSchemaUri(uri: string): boolean {
+  const id = decodeGtsId(uri)
+  return id.startsWith('https://json-schema.org') || id.startsWith('http://json-schema.org')
+}
+
+/**
+ * Meta-validate `schema` exactly as Ajv does before adding it to an instance,
+ * but against the shared meta-schemas; throws Ajv's own "schema is invalid"
+ * error. Returns false, without validating, when the schema names a `$schema`
+ * that only the per-instance loader can resolve.
+ */
+function metaValidateShared(schema: any): boolean {
+  if (!schema || typeof schema !== 'object') return true
+  const ajv = (sharedMetaValidator ??= createGtsAjv())
+  const $schema = schema.$schema
+  if ($schema !== undefined) {
+    if (typeof $schema !== 'string') return false
+    let known: boolean
+    try {
+      known = Boolean(ajv.getSchema($schema))
+    } catch {
+      return false
+    }
+    // Any other json-schema.org meta-schema (e.g. draft 2020-12, which plain
+    // Ajv doesn't bundle) is loaded as `true`, so the schema is valid against it.
+    if (!known) return isStandardJsonSchemaUri($schema)
+  }
+  if (!ajv.validateSchema(schema)) throw new Error(`schema is invalid: ${ajv.errorsText(ajv.errors)}`)
+  return true
+}
+
+/**
+ * A meta-validated schema without its `$schema`, so the instance compiling it
+ * doesn't load and compile that meta-schema again. `$schema` has no other
+ * effect on compilation.
+ */
+function withoutMetaSchemaRef(schema: any): any {
+  if (!schema || typeof schema !== 'object' || !('$schema' in schema)) return schema
+  const { $schema: _metaSchema, ...rest } = schema
+  return rest
+}
+
 /**
  * Convert an XGtsRefValidator field path (dot/bracket notation, e.g.
  * `value.tags[0]`) into a JSON-Pointer-style instancePath (`/value/tags/0`)
@@ -108,13 +300,13 @@ function normalizeToArray(content: any): any[] {
 /**
  * True when a resolved subschema describes a *scalar data value* rather than a
  * GTS reference: it constrains the value with a scalar `type`, a `format`, an
- * `enum`, or a `const`, and does NOT declare it as a reference via `x-gts-ref`
+ * `enum`, or a `const`, and does NOT declare it as a reference via a GTS reference keyword
  * or `$ref`. Used to suppress the syntactic "GTS reference not found" check for
  * fields whose GTS-id-shaped value is just data (e.g. a `format: uuid` string).
  */
 function isScalarDataField(sub: any): boolean {
   if (!sub || typeof sub !== 'object') return false
-  if (sub['x-gts-ref'] !== undefined || sub['$ref'] !== undefined) return false
+  if (hasGtsRefKeyword(sub) || sub['$ref'] !== undefined) return false
   const scalarTypes = new Set(['string', 'number', 'integer', 'boolean', 'null'])
   const t = sub.type
   const hasScalarType = typeof t === 'string'
@@ -131,7 +323,7 @@ function isScalarDataField(sub: any): boolean {
  *   to `id` changes their meaning, so this relation is followed **transitively**.
  *
  * `references.get(id)` — entity ids that merely *point at* `id` by GTS id (any
- *   GTS id field, `x-gts-ref`). They must be re-checked when `id` changes/renames,
+ *   GTS id field, `x-gts-type-ref`/`x-gts-instance-ref`). They must be re-checked when `id` changes/renames,
  *   but their own shape is unaffected, so this relation is applied **depth-1**.
  */
 interface DependencyGraph {
@@ -171,14 +363,11 @@ export class JsonRegistry {
   // Default file to open/select when displaying layout
   private defaultFilePath: string | null
 
-  // Lazily-built gts-ts store mirroring the registry's schemas, used to
-  // delegate GTS-specific schema validation (derivation §9.12, traits OP#13,
-  // modifier declaration/placement §9.11) that plain Ajv cannot express. It is
-  // invalidated whenever schemas change and rebuilt on next demand.
-  private gtsStore: GtsStore | null = null
-  // Modifier-declaration errors captured while registering schemas into the
-  // gts-ts store (register() throws these per §9.11.1), keyed by schema id.
-  private gtsStoreDeclErrors: Map<string, string> = new Map()
+  // Lazily-built gts-ts store mirroring the registry's schemas and instances,
+  // used to delegate GTS-specific schema validation (derivation §9.12, traits
+  // OP#13, modifier declaration/placement §9.11) that plain Ajv cannot
+  // express. Once built it is kept in sync as entities are indexed/removed.
+  private gtsMirror: GtsStoreMirror | null = null
 
   // Cached reverse-dependency graph used by getDependentFilePaths(). Rebuilt
   // lazily and invalidated whenever the entity set changes (any indexFile /
@@ -231,8 +420,7 @@ export class JsonRegistry {
 
   /** Drop the cached gts-ts store so it is rebuilt from current schemas on next use. */
   private invalidateGtsStore(): void {
-    this.gtsStore = null
-    this.gtsStoreDeclErrors.clear()
+    this.gtsMirror = null
   }
 
   /**
@@ -245,58 +433,93 @@ export class JsonRegistry {
    * rather than aborting the whole build; instances that fail to register are
    * skipped (they surface through the normal instance-validation path).
    */
-  private getGtsStore(): GtsStore {
-    if (this.gtsStore) return this.gtsStore
-    const store = new GtsStore()
-    this.gtsStoreDeclErrors.clear()
-    for (const schema of this.jsonSchemas.values()) {
-      try {
-        store.register(createJsonEntity(schema.content))
-      } catch (err) {
-        this.gtsStoreDeclErrors.set(schema.id, err instanceof Error ? err.message : String(err))
-      }
+  private getGtsMirror(): GtsStoreMirror {
+    if (!this.gtsMirror) {
+      const mirror = new GtsStoreMirror()
+      for (const schema of this.jsonSchemas.values()) mirror.add(schema)
+      for (const obj of this.jsonObjs.values()) mirror.add(obj)
+      this.gtsMirror = mirror
     }
-    for (const obj of this.jsonObjs.values()) {
-      try {
-        store.register(createJsonEntity(obj.content))
-      } catch {
-        // Instance couldn't be registered (e.g. malformed/UUID-less id); it is
-        // reported through validateEntity's normal path, not via the store.
+    return this.gtsMirror
+  }
+
+  private getGtsStore(): GtsStore {
+    return this.getGtsMirror().store
+  }
+
+  /**
+   * Build the gts-ts store ahead of validation, calling `tick` between
+   * entities so the caller can yield: built on demand, it blocks for seconds
+   * on a workspace with 100K+ entities. The store is only adopted when the
+   * registry didn't change while it was being built.
+   */
+  async prepareGtsStore(tick: () => Promise<void>): Promise<void> {
+    for (let attempt = 0; attempt < 2 && !this.gtsMirror; attempt++) {
+      const generation = this.contentGeneration
+      const mirror = new GtsStoreMirror()
+      for (const entities of [Array.from(this.jsonSchemas.values()), Array.from(this.jsonObjs.values())]) {
+        for (const entity of entities) {
+          mirror.add(entity)
+          await tick()
+        }
       }
+      if (!this.gtsMirror && this.contentGeneration === generation) this.gtsMirror = mirror
     }
-    this.gtsStore = store
-    return store
   }
 
   /**
-   * Invalidate a file and remove its JsonFile and associated records from the registry.
+   * Mirror a newly winning entity (the one `jsonSchemas`/`jsonObjs` now hold
+   * for its id) into the gts-ts store, if it has been built. Updating it in
+   * place instead of dropping it matters on large workspaces: rebuilding it
+   * re-registers every entity, which took seconds and ran on every edit.
    */
-  invalidateFile(path: string): void {
-    // Any schema set change invalidates the derived gts-ts store and the
-    // reverse-dependency graph (both are rebuilt lazily on next use).
-    this.invalidateGtsStore()
+  private addToGtsStore(entity: JsonEntity): void {
+    this.gtsMirror?.add(entity)
+  }
+
+  /** Drop the entity registered for registry id `id` from the gts-ts store, if any. */
+  private removeFromGtsStore(id: string): void {
+    this.gtsMirror?.remove(id)
+  }
+
+  /** Record that the indexed content changed: derived caches and memoized results are stale. */
+  private markContentChanged(): void {
     this.depGraph = null
     this.contentGeneration++
-    if (this.jsonFiles.has(path)) {
-      this.jsonFiles.delete(path)
-    }
-    if (this.invalidFiles.has(path)) {
-      this.invalidFiles.delete(path)
-    }
-    if (this.jsonFileObjs.has(path)) {
-      for (const obj of this.jsonFileObjs.get(path)!) {
+  }
+
+  /**
+   * Invalidate a file and remove its JsonFile and associated records from the registry.
+   * Returns false (and leaves every cache intact) when nothing was indexed for it.
+   */
+  invalidateFile(path: string): boolean {
+    const objs = this.jsonFileObjs.get(path)
+    const schemas = this.jsonFileSchemas.get(path)
+    const hadRecords = this.jsonFiles.has(path) || this.invalidFiles.has(path) || !!objs?.length || !!schemas?.length
+    if (!hadRecords) return false
+    // Any entity set change invalidates the reverse-dependency graph (rebuilt
+    // lazily) and every memoized validation result; the gts-ts store is
+    // updated in place.
+    this.markContentChanged()
+    this.jsonFiles.delete(path)
+    this.invalidFiles.delete(path)
+    if (objs) {
+      for (const obj of objs) {
         this.jsonObjs.delete(obj.id)
+        this.removeFromGtsStore(obj.id)
       }
       this.jsonFileObjs.delete(path)
       this.jsonFileObjs.set(path, [])
     }
-    if (this.jsonFileSchemas.has(path)) {
-      for (const schema of this.jsonFileSchemas.get(path)!) {
+    if (schemas) {
+      for (const schema of schemas) {
         this.jsonSchemas.delete(schema.id)
+        this.removeFromGtsStore(schema.id)
       }
       this.jsonFileSchemas.delete(path)
       this.jsonFileSchemas.set(path, [])
     }
+    return true
   }
 
   /**
@@ -343,8 +566,8 @@ export class JsonRegistry {
    *
    *  references (depth-1 — Type #2 id reference):
    *    - any GTS id used anywhere in the entity's content (JsonEntity.gtsRefs),
-   *      which already includes `x-gts-ref` targets (their concrete values are
-   *      valid GTS ids). Wildcard `x-gts-ref` *patterns* are authoring
+   *      which already includes entity-reference targets (their concrete values
+   *      are valid GTS ids). Wildcard reference *patterns* are authoring
    *      constraints; the concrete instance value that matches carries the real
    *      id edge via gtsRefs, so patterns need no separate reverse edge.
    */
@@ -557,9 +780,15 @@ export class JsonRegistry {
    * Process a file and store its entities if they are GTS entities.
    * This is a helper used by both scanFile and ingestFiles.
    */
-  private processFileContent(path: string, name: string, content: any, cfg: GtsConfig): void {
+  private processFileContent(path: string, name: string, content: any, cfg: GtsConfig): boolean {
+    // Re-indexing identical content (opening a file, saving without changes,
+    // revalidating open documents) must not count as a change: a change throws
+    // away every memoized validation result and compiled validator.
+    const previous = this.jsonFiles.get(path) ?? this.invalidFiles.get(path)
+    if (previous && previous.name === name && sameFileContent(previous.content, content)) return false
+
     // Cleanup any existing records for this file
-    this.invalidateFile(path)
+    let changed = this.invalidateFile(path)
 
     // Create JsonFile
     const jsonFile = new JsonFile(path, name, content)
@@ -570,7 +799,8 @@ export class JsonRegistry {
     if (jsonFile.validation && jsonFile.validation.errors.length > 0) {
       // Store JsonFile if it's invalid to show it in the UI
       this.invalidFiles.set(path, jsonFile)
-      return
+      this.markContentChanged()
+      return true
     }
 
     // Use the file's parsed content: JsonFile parses raw string input (JSON/JSONC
@@ -584,6 +814,10 @@ export class JsonRegistry {
       const hasSelectedId = entity?.selectedEntityIdField !== undefined || entity?.selectedSchemaIdField !== undefined
       if (entity && (!requireSelectedId || hasSelectedId) && entity.isGtsEntity()) {
         hasGtsEntities = true
+        if (!changed) {
+          this.markContentChanged()
+          changed = true
+        }
         if (entity instanceof JsonSchema) {
           this.jsonSchemas.set(entity.id, entity)
           this.jsonFileSchemas.set(path, [...this.jsonFileSchemas.get(path) || [], entity])
@@ -591,6 +825,7 @@ export class JsonRegistry {
           this.jsonObjs.set(entity.id, entity as JsonObj)
           this.jsonFileObjs.set(path, [...this.jsonFileObjs.get(path) || [], entity as JsonObj])
         }
+        this.addToGtsStore(entity)
       }
     }
 
@@ -617,6 +852,7 @@ export class JsonRegistry {
     if (hasGtsEntities && !this.jsonFiles.has(path)) {
       this.jsonFiles.set(path, jsonFile)
     }
+    return changed
   }
 
   /**
@@ -625,16 +861,18 @@ export class JsonRegistry {
    * This is the incremental counterpart to ingestFiles: it upserts one file's
    * entities without re-processing the whole workspace and without running Ajv.
    * Use it to keep a long-lived registry in sync with editor/file changes.
+   * Returns whether the indexed state changed (false for identical content).
    */
-  indexFile(path: string, name: string, content: any, cfg: GtsConfig): void {
+  indexFile(path: string, name: string, content: any, cfg: GtsConfig): boolean {
     // Skip files in the .gts-viewer directory (cross-platform, browser-safe)
     if (/(^|[\\\/])\.gts-viewer[\\\/]/.test(path)) {
-      return
+      return false
     }
     try {
-      this.processFileContent(path, name, content, getGtsConfig(cfg))
+      return this.processFileContent(path, name, content, getGtsConfig(cfg))
     } catch (error) {
       console.error(`Failed to index file ${path}:`, error)
+      return true
     }
   }
 
@@ -668,7 +906,7 @@ export class JsonRegistry {
 
   /**
    * Validation result of an entity that an instance references through an
-   * `x-gts-ref` field, evaluated within the chain of instances being validated
+   * entity-reference field, evaluated within the chain of instances being validated
    * (`chain`). Returns null for a reference cycle, which is treated as valid
    * (like gts-ts's visiting guard).
    *
@@ -705,12 +943,12 @@ export class JsonRegistry {
     const cache = this.instanceValidators.byContent
     let validator = cache.get(schemaContent)
     if (!validator) {
-      // Strip `x-gts-ref` first (mirroring gts-ts's normalizeSchema) so Ajv never
-      // sees the unknown keyword and, crucially, so `x-gts-ref`-only combinator
-      // branches don't collapse into always-true schemas and make e.g.
-      // `oneOf: [{x-gts-ref}, {x-gts-ref}]` fail. The `x-gts-ref` assertions
-      // themselves are enforced by XGtsRefValidator.
-      validator = this.createAjvInstance().compileAsync(stripXGtsRefForAjv(schemaContent))
+      // Strip the reference keywords first so Ajv never sees them and,
+      // crucially, so reference-only combinator branches don't collapse into
+      // always-true schemas and make e.g.
+      // `oneOf: [{x-gts-type-ref}, {x-gts-instance-ref}]` fail. The reference
+      // assertions themselves are enforced by the gts-ts store.
+      validator = this.compileSchema(stripGtsRefKeywordsForAjv(schemaContent))
       cache.set(schemaContent, validator)
       validator.catch(() => { if (cache.get(schemaContent) === validator) cache.delete(schemaContent) })
     }
@@ -774,9 +1012,19 @@ export class JsonRegistry {
           continue
         }
 
+        // In a schema, an `x-gts-pattern-ref` operand only constrains what
+        // values look like (§9.6: it names no entity, and gts-ts never looks it
+        // up), and `x-gts-traits` values are trait data, checked against the
+        // trait schema by gts-ts. Neither has to exist. (`x-gts-type-ref` /
+        // `x-gts-instance-ref` operands are checked by gts-ts as well.)
+        const segments = ref.sourcePath.replace(/\[\d+\]/g, '').split('.')
+        if (entity instanceof JsonSchema && (segments[segments.length - 1] === X_GTS_PATTERN_REF || segments.includes('x-gts-traits'))) {
+          continue
+        }
+
         // Schema-aware skip: when the instance's schema types this field as a
         // scalar data value (a `format`/scalar `type`/`enum`/`const`, and NOT a
-        // reference via `x-gts-ref`/`$ref`), its GTS-id-shaped value is data,
+        // reference via a reference keyword/`$ref`), its GTS-id-shaped value is data,
         // not a reference, so its existence must not be checked. Configured
         // id/schema fields are never exempted (they are references by design).
         const lastSegment = ref.sourcePath.replace(/\[\d+\]/g, '').split('.').pop() || ''
@@ -816,9 +1064,8 @@ export class JsonRegistry {
     if (entity instanceof JsonSchema) {
       // Validate the schema itself (meta-validation)
       try {
-        const ajv = this.createAjvInstance()
         // Try to compile the schema to check if it's valid (async to support $ref resolution)
-        await ajv.compileAsync(entity.content)
+        await this.compileSchema(entity.content)
       } catch (error: any) {
         // If Ajv provides a detailed errors array, use it for precise paths
         if (Array.isArray(error?.errors) && error.errors.length > 0) {
@@ -850,8 +1097,8 @@ export class JsonRegistry {
       //   - §9.11 misplaced document-level keywords + final-base-in-chain guard
       //   - §9.12 (OP#12) derivation constraint compatibility with the parent
       //   - §9.7  (OP#13) trait schema/value validation across the chain
-      const store = this.getGtsStore()
-      const declError = this.gtsStoreDeclErrors.get(entity.id)
+      const { store, declErrors } = this.getGtsMirror()
+      const declError = declErrors.get(entity.id)
       if (declError) {
         // register() rejected this schema outright (§9.11.1); surface it and
         // skip chain validation (the schema isn't in the store).
@@ -869,12 +1116,14 @@ export class JsonRegistry {
           for (const msg of rawMessages) {
             const propMatch = msg.match(/^Property '([^']+)'/)
             const propPath = propMatch ? propMatch[1] : null
-            // A "Referenced x-gts-ref entity '<id>' is invalid: ..." message is
-            // caused by a specific `x-gts-ref` node, not by the schema's own
-            // `$id`; anchor it to that node so the squiggle lands on the ref
-            // (e.g. line with `"x-gts-ref": "<id>"`) rather than the document
-            // root. Everything else keeps the previous `$id` fallback.
-            const refMatch = propPath ? null : msg.match(/^Referenced x-gts-ref entity '([^']+)'/)
+            // A "Referenced type '<id>' is invalid: ..." / "<path> names '<id>',
+            // which is invalid: ..." message is caused by a specific reference
+            // node, not by the schema's own `$id`; anchor it to that node so the
+            // squiggle lands on the ref (e.g. line with `"x-gts-type-ref": "<id>"`)
+            // rather than the document root. Everything else keeps the previous
+            // `$id` fallback.
+            const refMatch = propPath ? null : msg.match(/^Referenced (?:type|entity) '([^']+)' is invalid| names '([^']+)', which is invalid/)
+            const refId = refMatch ? refMatch[1] ?? refMatch[2] : null
             // A "trait validation: ..." message comes from the OP#13 trait
             // completeness check; anchor it to the unmet `x-gts-traits-schema`
             // requirement (the specific `required` entry when we can name the
@@ -887,14 +1136,23 @@ export class JsonRegistry {
             const regexPath = !propPath && !refMatch && !isTraitError && /regular expression|Unsupported pattern/.test(msg)
               ? findRegexPatternPath(entity.content, msg)
               : null
+            // The keyword-placement/unknown-keyword guards (§9.11, §9.7.1) report
+            // the offending keyword's JSON path(s) inline as "… found at: a/b/c,
+            // d/e/f". Anchor the diagnostic to the first such path so the squiggle
+            // lands on the actual keyword (e.g. properties/subject_type/x-gts-type-ref)
+            // instead of the schema's `$id` — and so a self-referencing reference keyword
+            // elsewhere no longer appears to "own" an error from another field.
+            const foundAtMatch = !propPath && !refMatch && !isTraitError && !regexPath
+              ? msg.match(/ found at: (.+)$/)
+              : null
             let instancePath: string | null = null
             let params: Record<string, any> = {}
             if (propPath) {
               instancePath = findSchemaPropertyPath(entity.content, propPath)
               params = { property: propPath }
             } else if (refMatch) {
-              instancePath = findXGtsRefPath(entity.content, refMatch[1])
-              params = { refValue: refMatch[1] }
+              instancePath = findXGtsRefPath(entity.content, refId!)
+              params = { refValue: refId }
             } else if (isTraitError) {
               const traitMatch = msg.match(/required (?:property|trait) '([^']+)'/)
               const traitName = traitMatch ? traitMatch[1] : undefined
@@ -902,6 +1160,13 @@ export class JsonRegistry {
               params = traitName ? { trait: traitName } : {}
             } else if (regexPath) {
               instancePath = regexPath
+            } else if (foundAtMatch) {
+              // The reported path uses `/` separators and `[n]` array indices
+              // (e.g. "allOf[0]/properties/x/x-gts-type-ref"); the depth-guard also
+              // appends " (nesting exceeds …)" which is not part of the path.
+              const firstPath = foundAtMatch[1].split(', ')[0].replace(/ \(.*\)$/, '').trim()
+              instancePath = fieldPathToInstancePath(firstPath)
+              params = { keywordPath: firstPath }
             }
             validation.errors.push({
               instancePath: instancePath || '/$id',
@@ -914,15 +1179,14 @@ export class JsonRegistry {
         }
       }
 
-      // §9.6: validate the `x-gts-ref` *pattern declarations* inside the schema
-      // (e.g. a literal that is neither a valid GTS ID/pattern nor a resolvable
-      // JSON Pointer). This checks the schema authoring, not an instance value.
+      // §9.6.3: validate the reference keyword *operands* inside the schema
+      // (e.g. a literal that is neither a valid GTS ID/pattern nor `/$id`). This checks the schema authoring, not an instance value.
       const refDeclErrors = new XGtsRefValidator().validateSchema(entity.content)
       for (const err of refDeclErrors) {
         validation.errors.push({
           instancePath: fieldPathToInstancePath(err.fieldPath),
           schemaPath: '#',
-          keyword: 'x-gts-ref',
+          keyword: err.keyword ?? 'x-gts-schema',
           message: err.reason,
           params: { value: err.value, refPattern: err.refPattern }
         })
@@ -1024,47 +1288,53 @@ export class JsonRegistry {
           validation.errors.push(...formatted)
         }
 
-        // §9.6: `x-gts-ref` is an assertion keyword on instance string values
+        // §9.6: the reference keywords are assertions on instance string values
         // (the value must be a GTS ID matching the declared prefix/pattern).
-        // Ajv treats it as an unknown keyword and silently ignores it, so it is
+        // Ajv treats them as unknown keywords and silently ignores them, so they are
         // enforced explicitly here (mirrors gts-ts store.validateInstance).
-        // The validator gets the registry's gts-ts store so it can follow
-        // `gts://` `$ref`s (e.g. `allOf: [{ $ref: <parent type> }]`) into parent
-        // schemas: without one, every such `$ref` is unresolvable and gts-ts
-        // reports "Cannot resolve $ref ... for x-gts-ref traversal" (it fails
-        // closed rather than skip the parent's constraints). It runs in
-        // any-present mode to collect the referenced ids for the any-valid
-        // check below; its own "not found" errors repeat the gtsRefs registry
-        // check above and are dropped.
-        const refValidator = new XGtsRefValidator(this.getGtsStore(), GtsRefValidationMode.AnyPresent)
-        const xGtsRefErrors = refValidator.validateInstance(entity.content, schema.content, '', undefined, entity.id)
-        for (const err of xGtsRefErrors) {
-          if (/^Referenced entity '.+' not found in registry$/.test(err.reason)) continue
+        // Since gts-ts 0.11 XGtsRefValidator is registry-less, so the check is
+        // delegated to the registry's gts-ts store, which follows `gts://`
+        // `$ref`s into parent schemas. It runs in any-present mode (the
+        // any-valid check is done below); only reference-keyword issues are
+        // kept (Ajv already reported the rest), and "not found" errors repeat
+        // the gtsRefs registry check above and are dropped.
+        const store = this.getGtsStore()
+        const storeResult = store.get(entity.id)
+          ? store.validateInstance(entity.id, GtsRefValidationMode.AnyPresent)
+          : null
+        for (const issue of storeResult?.errors ?? []) {
+          if (!issue.keyword.startsWith('x-gts-')) continue
+          if (/not found/.test(issue.message)) continue
           validation.errors.push({
-            instancePath: fieldPathToInstancePath(err.fieldPath),
-            schemaPath: '#',
-            keyword: 'x-gts-ref',
-            message: err.reason,
-            params: { value: err.value, refPattern: err.refPattern }
+            instancePath: issue.instancePath,
+            schemaPath: issue.schemaPath || '#',
+            keyword: issue.keyword,
+            message: issue.message,
+            params: issue.params
           })
         }
 
         // §9.6 `gts-ref-validation=any-valid` (the spec's default policy): an
-        // entity referenced through an `x-gts-ref` field must itself be valid,
+        // entity referenced through an entity-reference field must itself be valid,
         // transitively, or the referencing instance is invalid too.
-        for (const referencedId of refValidator.getReferencedIds()) {
+        const checkedIds = new Set<string>()
+        for (const { id: referencedId, sourcePath } of entity.gtsRefs ?? []) {
+          if (checkedIds.has(referencedId)) continue
+          const fieldSchema = getInstanceFieldSubschema(schema.content, sourcePath)
+          const keyword = ENTITY_REF_KEYWORDS.find(key => fieldSchema?.[key] !== undefined)
+          if (!keyword) continue
+          checkedIds.add(referencedId)
           const dependency = this.jsonObjs.get(referencedId) ?? this.jsonSchemas.get(referencedId)
           if (!dependency || dependency === entity) continue
           const dependencyValidation = await this.referencedEntityValidation(dependency, chain)
           const firstError = dependencyValidation?.errors[0]
           if (!firstError) continue
-          const sourcePath = entity.gtsRefs?.find(ref => ref.id === referencedId)?.sourcePath
           validation.errors.push({
             instancePath: sourcePath && sourcePath !== 'root'
               ? '/' + sourcePath.replace(/\./g, '/').replace(/\[(\d+)\]/g, '/$1')
               : '/',
             schemaPath: '#',
-            keyword: 'x-gts-ref',
+            keyword,
             message: `Referenced entity '${referencedId}' is invalid: ${firstError.message}`,
             params: { value: referencedId }
           })
@@ -1153,30 +1423,37 @@ export class JsonRegistry {
     })
   }
 
+  /**
+   * Compile `schema` with an Ajv instance that resolves GTS `$ref`s from the
+   * registry. Rejects exactly like `compileAsync` did when each fresh instance
+   * meta-validated schemas itself, but the meta-validation runs against the
+   * shared, compiled-once meta-schemas (see metaValidateShared). Schemas naming
+   * a `$schema` the shared instance doesn't know keep the full per-instance path.
+   */
+  private async compileSchema(schema: any): Promise<ValidateFunction> {
+    if (!metaValidateShared(schema)) return this.createAjvInstance(false).compileAsync(schema)
+    return this.createAjvInstance(true).compileAsync(withoutMetaSchemaRef(schema))
+  }
+
   /**
    * Create an Ajv instance with custom schema resolver.
    * This resolver handles GTS ID references and supports all JSON Schema features.
+   *
+   * With `sharedMeta`, the instance doesn't meta-validate schemas itself: the
+   * caller validated the root (compileSchema) and the loader validates every
+   * schema it loads, both against the shared meta-schemas.
    */
-  private createAjvInstance(): Ajv {
+  private createAjvInstance(sharedMeta: boolean): Ajv {
     const registry = this
 
-    const ajv = new Ajv({
-      strict: false,
-      allErrors: true,
-      verbose: true,
-      // Enable full JSON Schema support
-      discriminator: true,
-      allowUnionTypes: true,
-      // Provide data alongside errors
-      $data: true,
-      // Disable code generation for CSP compliance (VS Code webviews)
-      code: { source: false },
+    return createGtsAjv({
+      validateSchema: !sharedMeta,
       // Custom schema loader for GTS ID resolution
       loadSchema: async (uri: string): Promise<any> => {
         const schemaId = decodeGtsId(uri)
 
         // Allow standard JSON Schema references
-        if (schemaId.startsWith('https://json-schema.org') || schemaId.startsWith('http://json-schema.org')) {
+        if (isStandardJsonSchemaUri(uri)) {
           return true
         }
 
@@ -1186,46 +1463,10 @@ export class JsonRegistry {
           // Show human-readable error message with decoded URI
           throw new Error(`Schema not found for $ref: ${schemaId}`)
         }
+        if (sharedMeta && metaValidateShared(schema.content)) return withoutMetaSchemaRef(schema.content)
         return schema.content
       }
     })
-
-    // Add format validation (email, uri, date-time, etc.). Default "full" mode
-    // validates real value ranges (e.g. rejects month 13, offset +25:00).
-    addFormats(ajv)
-
-    // Tighten the temporal formats to strict RFC 3339. ajv-formats' full-mode
-    // date/time splits on `/t|\s/i`, so it accepts a space instead of `T`
-    // (permitted by RFC 3339 §5.6's NOTE, but not by the ABNF grammar GTS
-    // requires). Compose the two *standard* ajv-formats validators so a value
-    // must satisfy BOTH: the "fast" grammar (strict `T` separator + mandatory
-    // time-offset) AND the "full" validator (real calendar/clock ranges).
-    for (const name of ['date', 'time', 'date-time'] as const) {
-      const fast = addFormats.get(name, 'fast')
-      const full = addFormats.get(name, 'full')
-      ajv.addFormat(name, {
-        type: 'string',
-        validate: (value: string) => matchesFormat(fast, value) && matchesFormat(full, value),
-      })
-    }
-
-    // GTS id formats emitted by schema generators (e.g. gts-rust) as annotations
-    // next to an `x-gts-ref` that does the actual checking. Registered as
-    // accept-all — exactly how Ajv treated them before (ignored as unknown) —
-    // so each compile no longer logs an "unknown format" warning.
-    // Same for the sized-integer formats Rust's schemars emits (int32/int64 are
-    // already provided by ajv-formats).
-    for (const name of ['gts-instance-id', 'gts-type-id', 'int8', 'int16', 'uint', 'uint8', 'uint16', 'uint32', 'uint64']) {
-      ajv.addFormat(name, true)
-    }
-
-    // Add custom schema loader that resolves GTS IDs from the registry
-    ajv.addKeyword({
-      keyword: 'gtsRef',
-      schemaType: 'string',
-    })
-
-    return ajv
   }
 
   /**
diff --git a/packages/shared/src/schemaParser.ts b/packages/shared/src/schemaParser.ts
index 884067e..408b60a 100644
--- a/packages/shared/src/schemaParser.ts
+++ b/packages/shared/src/schemaParser.ts
@@ -1,4 +1,5 @@
 import { isGtsId, isGtsType as checkGtsType, isGtsObj as checkGtsObj, normalizeGtsId } from '@gts/shared'
+import { GTS_REF_KEYWORDS, type GtsRefKeyword } from '@globaltypesystem/gts-ts'
 
 export interface PropertyInfo {
   name: string
@@ -93,7 +94,7 @@ export function parseJsonToProperties(data: any, name = 'root'): PropertyInfo[]
           }
         }
 
-        // For plain nested objects, use recursive parsing without any x-gts-ref special handling
+        // For plain nested objects, use recursive parsing without any reference-keyword special handling
         return {
           name: key,
           type: 'object',
@@ -158,9 +159,10 @@ export function parseSchemaToProperties(schema: any): PropertyInfo[] {
         description = description ? `${description}\n${patDescription}` : patDescription
       }
 
-      if (prop['x-gts-ref']) {
-        const gtsTypeDescription = `GTS Type: ${prop['x-gts-ref']}`
-        description = description ? `${description}\n${gtsTypeDescription}` : gtsTypeDescription
+      for (const [keyword, label] of [['x-gts-type-ref', 'GTS Type'], ['x-gts-instance-ref', 'GTS Instance'], ['x-gts-pattern-ref', 'GTS Pattern']] as const) {
+        if (!prop[keyword]) continue
+        const refDescription = `${label}: ${prop[keyword]}`
+        description = description ? `${description}\n${refDescription}` : refDescription
         isGtsType = true
       }
 
@@ -402,11 +404,12 @@ export function findSchemaPropertyPath(content: any, propPath: string): string |
 }
 
 /**
- * Locate the JSON Pointer instancePath of the `x-gts-ref` keyword whose value
+ * Locate the JSON Pointer instancePath of the reference keyword
+ * (`x-gts-type-ref` / `x-gts-instance-ref` / `x-gts-pattern-ref`) whose value
  * equals `refValue` (any `gts://` prefix ignored), searching every position in
- * the schema document. Used to anchor a "Referenced x-gts-ref entity '<id>' is
- * invalid" diagnostic to the offending `x-gts-ref` node rather than the
- * document root. Returns null when no matching `x-gts-ref` is present.
+ * the schema document. Used to anchor a "Referenced type '<id>' is invalid"
+ * diagnostic to the offending reference node rather than the document root.
+ * Returns null when no matching reference keyword is present.
  */
 export function findXGtsRefPath(content: any, refValue: string): string | null {
   const target = normalizeGtsId(refValue)
@@ -422,7 +425,7 @@ export function findXGtsRefPath(content: any, refValue: string): string | null {
     }
     for (const [key, value] of Object.entries(node)) {
       const childPath = `${currentPath}/${key}`
-      if (key === 'x-gts-ref' && typeof value === 'string' && normalizeGtsId(value) === target) {
+      if (GTS_REF_KEYWORDS.includes(key as GtsRefKeyword) && typeof value === 'string' && normalizeGtsId(value) === target) {
         return childPath
       }
       const res = walk(value, childPath)