Auto stash before rebase of "relpace_lsp_with_rust" onto "origin/relpace_lsp_with_rust"

test rust lsp
2025-11-16 20:55:25 +01:00 · 2025-09-07 07:18:18 +02:00
363 changed files with 1980 additions and 78662 deletions
@@ -9,4 +9,8 @@ __pycache__
 .nox
 *.g4
 .antlr
-.claude
+
+target
+client/node_modules
+client/dist
+client/out
@@ -0,0 +1,10 @@
+This folder contains debug and task configurations for developing the extension and the Rust language server.
+
+- `launch.json`: Debug configurations for the Extension Host and for the Rust server (expects `CodeLLDB` extension).
+- `tasks.json`: Tasks to build the client (`npm run build`) and server (`cargo build`).
+
+Usage:
+
+1. Install the `vadimcn.vscode-lldb` (CodeLLDB) extension for Rust debugging.
+2. Run the `npm: build (client)` task or use the Run Extension configuration which will run it as a preLaunchTask.
+3. Use `Launch Rust server (CodeLLDB)` to build and run the server under the debugger.
@@ -1,97 +1,28 @@
-// A launch configuration that compiles the extension and then opens it inside a new window
-// Use IntelliSense to learn about possible attributes.
-// Hover to view descriptions of existing attributes.
-// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 {
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
-            "name": "Run Extension",
            "type": "extensionHost",
            "request": "launch",
-            "runtimeExecutable": "${execPath}",
-            "args": [
-                "--extensionDevelopmentPath=${env:TEMP}/nx-post-support-vscode-debug",
-                "${env:TEMP}/nx-post-support-vscode-debug",
-                "${env:TEMP}/nx-post-support-vscode-debug/test/test.tcl"
-            ],
-            "cwd": "${env:TEMP}/nx-post-support-vscode-debug",
-            "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"],
-            "sourceMaps": true,
-            "resolveSourceMapLocations": [
-                "${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js",
-                "!**/node_modules/**"
-            ],
-            "skipFiles": ["<node_internals>/**"],
+            "name": "Run TCL LSP",
+            "runtimeExecutable": "${execPath}/",
+            "args": ["--extensionDevelopmentPath=${workspaceFolder}/", "${workspaceFolder}/test/"],
+            "outFiles": ["${workspaceFolder}/client/out/**/*.js"],
            "autoAttachChildProcesses": true,
-            "preLaunchTask": "NX Post Support: Compile Debug"
+            "preLaunchTask": "npm: build"
        },
        {
-            "name": "Python Attach",
-            "type": "debugpy",
-            "request": "attach",
-            "processId": "${command:pickProcess}",
-            "justMyCode": false,
-            "presentation": {
-                "hidden": false,
-                "group": "",
-                "order": 3
-            }
-        },
-        {
-            "name": "Debug Extension (hidden)",
-            "type": "extensionHost",
+            "name": "Debug Rust LSP Server (debug)",
+            "type": "lldb",
            "request": "launch",
-            "runtimeExecutable": "${execPath}",
-            "args": [
-                "--extensionDevelopmentPath=${env:TEMP}/nx-post-support-vscode-debug",
-                "${env:TEMP}/nx-post-support-vscode-debug",
-                "${env:TEMP}/nx-post-support-vscode-debug/test/test.tcl"
-            ],
-            "cwd": "${env:TEMP}/nx-post-support-vscode-debug",
-            "outFiles": ["${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js"],
-            "sourceMaps": true,
-            "resolveSourceMapLocations": [
-                "${env:TEMP}/nx-post-support-vscode-debug/dist/**/*.js",
-                "!**/node_modules/**"
-            ],
-            "skipFiles": ["<node_internals>/**"],
-            "env": {
-                "USE_DEBUGPY": "True",
-                "NXPS_DEBUG_HOST": "127.0.0.1",
-                "NXPS_DEBUG_PORT": "5678"
-            },
-            "presentation": {
-                "hidden": true,
-                "group": "",
-                "order": 4
-            }
-        },
-        {
-            "name": "Python debug server (hidden)",
-            "type": "debugpy",
-            "request": "attach",
-            "listen": { "host": "127.0.0.1", "port": 5678 },
-            "justMyCode": false,
-            "logToFile": true,
-            "presentation": {
-                "hidden": true,
-                "group": "",
-                "order": 4
-            }
-        }
-    ],
-    "compounds": [
-        {
-            "name": "Debug Extension and Python",
-            "configurations": ["Python debug server (hidden)", "Debug Extension (hidden)"],
-            "stopAll": true,
-            "preLaunchTask": "NX Post Support: Compile Debug",
-            "presentation": {
-                "hidden": false,
-                "group": "",
-                "order": 1
-            }
+            "program": "${workspaceFolder}/server/target/debug/server.exe",
+            "args": [],
+            "env": { "RUST_BACKTRACE": "1" },
+            "preLaunchTask": "cargo: build server",
+            "stopOnEntry": true
        }
    ]
 }
@@ -1,57 +0,0 @@
-param(
-    [Parameter(Mandatory = $true)]
-    [string]$WorkspaceRoot,
-
-    [Parameter(Mandatory = $true)]
-    [string]$DebugRoot
-)
-
-Set-StrictMode -Version Latest
-$ErrorActionPreference = "Stop"
-
-function ConvertFrom-ExtendedWindowsPath {
-    param([string]$Path)
-
-    if ($Path.StartsWith("\\?\UNC\", [System.StringComparison]::OrdinalIgnoreCase)) {
-        return "\\" + $Path.Substring(8)
-    }
-    if ($Path.StartsWith("\\?\", [System.StringComparison]::OrdinalIgnoreCase)) {
-        return $Path.Substring(4)
-    }
-    return $Path
-}
-
-$workspacePath = ConvertFrom-ExtendedWindowsPath $WorkspaceRoot
-$workspaceItem = Get-Item -LiteralPath $workspacePath
-if (-not $workspaceItem.PSIsContainer) {
-    throw "Workspace root is not a directory: $workspacePath"
-}
-$workspacePath = $workspaceItem.FullName
-
-$debugPath = ConvertFrom-ExtendedWindowsPath $DebugRoot
-$tempPath = [System.IO.Path]::GetFullPath([System.IO.Path]::GetTempPath()).TrimEnd("\")
-$debugParent = [System.IO.Path]::GetFullPath((Split-Path -Parent $debugPath)).TrimEnd("\")
-if (-not $debugParent.Equals($tempPath, [System.StringComparison]::OrdinalIgnoreCase)) {
-    throw "Debug alias must be located directly below the user temp directory: $debugPath"
-}
-
-if (Test-Path -LiteralPath $debugPath) {
-    $debugItem = Get-Item -LiteralPath $debugPath -Force
-    if ($debugItem.LinkType -ne "Junction") {
-        throw "Debug alias exists but is not a junction: $debugPath"
-    }
-
-    $currentTarget = (Get-Item -LiteralPath $debugItem.Target).FullName
-    if (-not $currentTarget.Equals($workspacePath, [System.StringComparison]::OrdinalIgnoreCase)) {
-        # Removing a junction removes only the link, never the target directory.
-        Remove-Item -LiteralPath $debugPath -Force
-    }
-}
-
-if (-not (Test-Path -LiteralPath $debugPath)) {
-    New-Item -ItemType Junction -Path $debugPath -Target $workspacePath | Out-Null
-}
-
-Write-Output "Debug extension path: $debugPath -> $workspacePath"
-& npm.cmd --prefix $workspacePath run compile:debug
-exit $LASTEXITCODE
@@ -2,25 +2,10 @@
    "version": "2.0.0",
    "tasks": [
        {
-            "label": "NX Post Support: Compile Debug",
-            "type": "process",
-            "command": "powershell.exe",
-            "args": [
-                "-NoLogo",
-                "-NoProfile",
-                "-ExecutionPolicy",
-                "Bypass",
-                "-Command",
-                "& { param([string]$WorkspaceRoot, [string]$DebugRoot); $scriptRoot = $WorkspaceRoot; if ($scriptRoot.StartsWith('\\\\?\\')) { $scriptRoot = $scriptRoot.Substring(4) }; & (Join-Path $scriptRoot '.vscode\\prepare-debug.ps1') -WorkspaceRoot $WorkspaceRoot -DebugRoot $DebugRoot; exit $LASTEXITCODE }",
-                "${workspaceFolder}",
-                "${env:TEMP}\\nx-post-support-vscode-debug"
-            ],
-            "problemMatcher": [],
-            "presentation": {
-                "reveal": "always",
-                "panel": "dedicated",
-                "clear": true
-            }
+            "type": "npm",
+            "script": "build",
+            "label": "npm: build",
+            "path": "./"
        }
    ]
 }
@@ -1,9 +1,3 @@
-## Unreleased
-
- Add signature help for custom TCL procedures and built-in NX/MOM procedures
- Clean stale TCL indexes on close, delete, and rename operations
- Make background parsing and index updates thread-safe
-
 ## [0.0.1]

 - Initial release
@@ -18,12 +12,4 @@

 ## [0.2.0]

- Add DEF File Support
-
-## [2026.6.100]
-
- Fix several bugs
-
-## [2026.6.200]
-
- Fix foramtting bug
+- Add DEF File Support
@@ -9,7 +9,6 @@ A comprehensive VS Code extension providing language support for NX CAM postproc
 - **Multi-language Support** - Supports NX CDL, TCL, and DEF file formats
 - **Intelligent Code Analysis** - Linting and error detection for postprocessor code
 - **Auto-completion** - Context-aware code completion for faster development
- **Signature Help** - Shows parameters and documentation for custom and NX procedures

 ## Supported File Types

@@ -20,9 +19,8 @@ A comprehensive VS Code extension providing language support for NX CAM postproc
 ## Installation

 1. Install from the VS Code Marketplace
-2. Install Python 3.11 or higher
-3. Open any `.cdl`, `.tcl`, or `.def` file
-4. The extension will automatically activate and provide language support
+2. Open any `.cdl`, `.tcl`, or `.def` file
+3. The extension will automatically activate and provide language support

 ## Configuration

@@ -41,30 +39,6 @@ Simply open any supported file type and enjoy:
 - Code completion
 - Code formatting (Format Document command)
 - Hover information
- Signature help while entering procedure arguments
-
-## Development and debugging
-
-Install the root and client dependencies before the first debug session:
-
-```powershell
-npm install
-npm install --prefix client
-```
-
-Use one of the checked-in VS Code launch configurations:
-
- **Run Extension** debugs the TypeScript extension host.
- **Debug Extension and Python** debugs both the TypeScript extension and the
-  Python language server. This is the recommended configuration for LSP work.
- **Python Attach** attaches manually to an already running Python process.
-
-The launch configuration creates a fresh non-minified bundle with embedded
-source maps and opens `test/test.tcl` so the extension activates immediately.
-For combined debugging, the Python adapter listens on `127.0.0.1:5678`; the
-language server waits for that adapter before initialization. The NX
-Postprocessor Support output channel reports `Python debug mode: enabled` and
-shows `_debug_server.py` in the server command when the debug path is active.

 ## Contributing

@@ -0,0 +1,56 @@
+//@ts-check
+const esbuild = require('esbuild');
+
+/**
+ * @typedef {import('esbuild').BuildOptions} BuildOptions
+ */
+
+/** @type BuildOptions */
+const sharedDesktopOptions = {
+	bundle: true,
+	external: ['vscode'],
+	target: 'es2020',
+	platform: 'node',
+	sourcemap: true,
+};
+
+/** @type BuildOptions */
+const desktopOptions = {
+	entryPoints: ['src/extension.ts'],
+	outfile: 'dist/desktop/extension.js',
+	format: 'cjs',
+	...sharedDesktopOptions,
+};
+
+function createContexts() {
+	return Promise.all([esbuild.context(desktopOptions)]);
+}
+
+createContexts()
+	.then((contexts) => {
+		if (process.argv[2] === '--watch') {
+			const promises = [];
+			for (const context of contexts) {
+				promises.push(context.watch());
+			}
+			return Promise.all(promises).then(() => {
+				return undefined;
+			});
+		} else {
+			const promises = [];
+			for (const context of contexts) {
+				promises.push(context.rebuild());
+			}
+			Promise.all(promises)
+				.then(async () => {
+					for (const context of contexts) {
+						await context.dispose();
+					}
+				})
+				.then(() => {
+					return undefined;
+				})
+				.catch(console.error);
+		}
+	})
+	.catch(console.error);
@@ -10,53 +10,31 @@
      "license": "MIT",
      "dependencies": {
        "@vscode/python-extension": "^1.0.5",
-        "fs-extra": "^11.3.0",
-        "vscode-languageclient": "^9.0.1"
+        "fs-extra": "11.3.1"
      },
      "devDependencies": {
-        "@types/fs-extra": "^11.0.4",
-        "@types/node": "^22.10.5",
-        "@types/vscode": "^1.96.0"
+        "@types/node": "^22.18.0",
+        "@types/vscode": "^1.96.0",
+        "vscode-languageclient": "^9.0.1"
      },
      "engines": {
        "vscode": "^1.96.0"
      }
    },
-    "node_modules/@types/fs-extra": {
-      "version": "11.0.4",
-      "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-11.0.4.tgz",
-      "integrity": "sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/jsonfile": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/jsonfile": {
-      "version": "6.1.4",
-      "resolved": "https://registry.npmjs.org/@types/jsonfile/-/jsonfile-6.1.4.tgz",
-      "integrity": "sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
    "node_modules/@types/node": {
-      "version": "22.10.5",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.5.tgz",
-      "integrity": "sha512-F8Q+SeGimwOo86fiovQh8qiXfFEh2/ocYv7tU5pJ3EXMSSxk1Joj5wefpFK2fHTf/N6HKGSxIDBT9f3gCxXPkQ==",
+      "version": "22.18.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.18.0.tgz",
+      "integrity": "sha512-m5ObIqwsUp6BZzyiy4RdZpzWGub9bqLJMvZDD0QMXhxjqMHMENlj+SqF5QxoUwaQNFe+8kz8XM8ZQhqkQPTgMQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
-        "undici-types": "~6.20.0"
+        "undici-types": "~6.21.0"
      }
    },
    "node_modules/@types/vscode": {
-      "version": "1.96.0",
-      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.96.0.tgz",
-      "integrity": "sha512-qvZbSZo+K4ZYmmDuaodMbAa67Pl6VDQzLKFka6rq+3WUTY4Kro7Bwoi0CuZLO/wema0ygcmpwow7zZfPJTs5jg==",
+      "version": "1.103.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.103.0.tgz",
+      "integrity": "sha512-o4hanZAQdNfsKecexq9L3eHICd0AAvdbLk6hA60UzGXbGH/q8b/9xv2RgR7vV3ZcHuyKVq7b37IGd/+gM4Tu+Q==",
      "dev": true,
      "license": "MIT"
    },
@@ -74,21 +52,23 @@
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
      "license": "MIT"
    },
    "node_modules/brace-expansion": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
      "license": "MIT",
      "dependencies": {
        "balanced-match": "^1.0.0"
      }
    },
    "node_modules/fs-extra": {
-      "version": "11.3.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz",
-      "integrity": "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==",
+      "version": "11.3.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz",
+      "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==",
      "license": "MIT",
      "dependencies": {
        "graceful-fs": "^4.2.0",
@@ -106,9 +86,9 @@
      "license": "ISC"
    },
    "node_modules/jsonfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
-      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+      "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
      "license": "MIT",
      "dependencies": {
        "universalify": "^2.0.0"
@@ -121,6 +101,7 @@
      "version": "5.1.6",
      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
      "license": "ISC",
      "dependencies": {
        "brace-expansion": "^2.0.1"
@@ -130,9 +111,10 @@
      }
    },
    "node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
@@ -142,9 +124,9 @@
      }
    },
    "node_modules/undici-types": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
      "dev": true,
      "license": "MIT"
    },
@@ -161,6 +143,7 @@
      "version": "8.2.0",
      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
      "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
+      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
@@ -170,6 +153,7 @@
      "version": "9.0.1",
      "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-9.0.1.tgz",
      "integrity": "sha512-JZiimVdvimEuHh5olxhxkht09m3JzUGwggb5eRUkzzJhZ2KjCN0nh55VfiED9oez9DyF8/fz1g1iBV3h+0Z2EA==",
+      "dev": true,
      "license": "MIT",
      "dependencies": {
        "minimatch": "^5.1.0",
@@ -184,6 +168,7 @@
      "version": "3.17.5",
      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
      "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
+      "dev": true,
      "license": "MIT",
      "dependencies": {
        "vscode-jsonrpc": "8.2.0",
@@ -194,6 +179,7 @@
      "version": "3.17.5",
      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
      "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
+      "dev": true,
      "license": "MIT"
    }
  }
@@ -8,12 +8,17 @@
  },
  "dependencies": {
    "@vscode/python-extension": "^1.0.5",
-    "fs-extra": "^11.3.0",
-    "vscode-languageclient": "^9.0.1"
+    "fs-extra": "11.3.1"
  },
  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.10.5",
-    "@types/vscode": "^1.96.0"
+    "@types/node": "^22.18.0",
+    "@types/vscode": "^1.96.0",
+    "vscode-languageclient": "^9.0.1"
+  },
+  "scripts": {
+    "compile": "tsc -b",
+    "watch": "tsc -b -w",
+    "lint": "eslint",
+    "esbuild": "^0.25.0"
  }
-}
+}
@@ -1,14 +0,0 @@
-import * as path from "path"
-
-const folderName = path.basename(__dirname)
-export const EXTENSION_ROOT_DIR =
-    folderName === "common"
-        ? path.dirname(path.dirname(path.dirname(__dirname)))
-        : path.dirname(__dirname)
-export const BUNDLED_PYTHON_SCRIPTS_DIR = path.join(EXTENSION_ROOT_DIR, "server")
-export const SERVER_SCRIPT_PATH = path.join(BUNDLED_PYTHON_SCRIPTS_DIR, "src", `lsp_server.py`)
-export const DEBUG_SERVER_SCRIPT_PATH = path.join(
-    BUNDLED_PYTHON_SCRIPTS_DIR,
-    "src",
-    `_debug_server.py`
-)
@@ -137,102 +137,6 @@ export function hoverCdlHandler(document: vscode.TextDocument, position: vscode.
    return undefined
 }

-function escapeRegExp(value: string): string {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-export function cdlEventAtPosition(
-    document: vscode.TextDocument,
-    position: vscode.Position
-): string | undefined {
-    const line = document.lineAt(position.line).text
-    const match = /^\s*EVENT\s+([^\s{]+)/.exec(line)
-    if (!match) {
-        return undefined
-    }
-
-    const declarationStart = match.index
-    const eventEnd = line.indexOf(match[1], match.index) + match[1].length
-    if (position.character < declarationStart || position.character > eventEnd) {
-        return undefined
-    }
-    return match[1]
-}
-
-export async function definitionCdlEventHandler(
-    document: vscode.TextDocument,
-    position: vscode.Position,
-    token: vscode.CancellationToken
-): Promise<vscode.Location[] | undefined> {
-    const eventName = cdlEventAtPosition(document, position)
-    if (!eventName) {
-        return undefined
-    }
-
-    const handlerName = `MOM_${eventName}`
-    try {
-        const symbols = await vscode.commands.executeCommand<vscode.SymbolInformation[]>(
-            "vscode.executeWorkspaceSymbolProvider",
-            handlerName
-        )
-        const indexedLocations = (symbols || [])
-            .filter(
-                (symbol) =>
-                    symbol.kind === vscode.SymbolKind.Function &&
-                    (symbol.name === handlerName ||
-                        symbol.name.endsWith(`::${handlerName}`))
-            )
-            .map((symbol) => symbol.location)
-        if (indexedLocations.length > 0) {
-            return indexedLocations
-        }
-    } catch {
-        // The Tcl language server may still be starting; use the file fallback below.
-    }
-
-    const declaration = new RegExp(
-        `^\\s*proc\\s+(?:::)?${escapeRegExp(handlerName)}(?=\\s|\\{)`
-    )
-    const tclFiles = await vscode.workspace.findFiles(
-        "**/*.tcl",
-        "**/{.git,.nox,.venv,dist,node_modules,out}/**"
-    )
-    const locations: vscode.Location[] = []
-
-    for (const uri of tclFiles) {
-        if (token.isCancellationRequested) {
-            return undefined
-        }
-        let tclDocument: vscode.TextDocument
-        try {
-            tclDocument = await vscode.workspace.openTextDocument(uri)
-        } catch {
-            continue
-        }
-        for (let lineNumber = 0; lineNumber < tclDocument.lineCount; lineNumber++) {
-            const line = tclDocument.lineAt(lineNumber).text
-            const match = declaration.exec(line)
-            if (!match) {
-                continue
-            }
-            const start = line.indexOf(handlerName, match.index)
-            locations.push(
-                new vscode.Location(
-                    uri,
-                    new vscode.Range(
-                        lineNumber,
-                        start,
-                        lineNumber,
-                        start + handlerName.length
-                    )
-                )
-            )
-        }
-    }
-
-    return locations.length > 0 ? locations : undefined
-}
-
 export function tclDocumentSymbolProvider(document: vscode.TextDocument): vscode.DocumentSymbol[] {
    const symbols: vscode.DocumentSymbol[] = []
    const lines = document.getText().split("\n")
@@ -1,86 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-/* eslint-disable @typescript-eslint/naming-convention */
-import { commands, Disposable, Event, EventEmitter, Uri } from "vscode"
-import { traceError, traceLog } from "./log/logging"
-import { PythonExtension, ResolvedEnvironment } from "@vscode/python-extension"
-
-export interface IInterpreterDetails {
-    path?: string[]
-    resource?: Uri
-}
-
-const onDidChangePythonInterpreterEvent = new EventEmitter<IInterpreterDetails>()
-export const onDidChangePythonInterpreter: Event<IInterpreterDetails> =
-    onDidChangePythonInterpreterEvent.event
-
-let _api: PythonExtension | undefined
-async function getPythonExtensionAPI(): Promise<PythonExtension | undefined> {
-    if (_api) {
-        return _api
-    }
-    _api = await PythonExtension.api()
-    return _api
-}
-
-export async function initializePython(disposables: Disposable[]): Promise<void> {
-    try {
-        const api = await getPythonExtensionAPI()
-
-        if (api) {
-            disposables.push(
-                api.environments.onDidChangeActiveEnvironmentPath((e) => {
-                    onDidChangePythonInterpreterEvent.fire({
-                        path: [e.path],
-                        resource: e.resource?.uri
-                    })
-                })
-            )
-
-            traceLog("Waiting for interpreter from python extension.")
-            onDidChangePythonInterpreterEvent.fire(await getInterpreterDetails())
-        }
-    } catch (error) {
-        traceError("Error initializing python: ", error)
-    }
-}
-
-export async function resolveInterpreter(
-    interpreter: string[]
-): Promise<ResolvedEnvironment | undefined> {
-    const api = await getPythonExtensionAPI()
-    return api?.environments.resolveEnvironment(interpreter[0])
-}
-
-export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
-    const api = await getPythonExtensionAPI()
-    const environment = await api?.environments.resolveEnvironment(
-        api?.environments.getActiveEnvironmentPath(resource)
-    )
-    if (environment?.executable.uri && checkVersion(environment)) {
-        return { path: [environment?.executable.uri.fsPath], resource }
-    }
-    return { path: undefined, resource }
-}
-
-export async function getDebuggerPath(): Promise<string | undefined> {
-    const api = await getPythonExtensionAPI()
-    return api?.debug.getDebuggerPackagePath()
-}
-
-export async function runPythonExtensionCommand(command: string, ...rest: any[]) {
-    await getPythonExtensionAPI()
-    return await commands.executeCommand(command, ...rest)
-}
-
-export function checkVersion(resolved: ResolvedEnvironment | undefined): boolean {
-    const version = resolved?.version
-    if (version?.major === 3 && version?.minor >= 11) {
-        return true
-    }
-    traceError(`Python version ${version?.major}.${version?.minor} is not supported.`)
-    traceError(`Selected python path: ${resolved?.executable.uri?.fsPath}`)
-    traceError("Supported versions are 3.11 and above.")
-    return false
-}
@@ -1,163 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-import * as fsapi from "fs-extra"
-import { Disposable, env, LogOutputChannel, workspace } from "vscode"
-import { State } from "vscode-languageclient"
-import {
-    LanguageClient,
-    LanguageClientOptions,
-    RevealOutputChannelOn,
-    ServerOptions
-} from "vscode-languageclient/node"
-import { DEBUG_SERVER_SCRIPT_PATH, SERVER_SCRIPT_PATH } from "./constants"
-import { traceError, traceInfo, traceVerbose } from "./log/logging"
-import { getDebuggerPath } from "./python"
-import {
-    getExtensionSettings,
-    getGlobalSettings,
-    getWorkspaceSettings,
-    ISettings
-} from "./settings"
-import { getLSClientTraceLevel, getProjectRoot } from "./utilities"
-import { isVirtualWorkspace } from "./vscodeapi"
-
-export type IInitOptions = { settings: ISettings[]; globalSettings: ISettings }
-
-let _disposables: Disposable[] = []
-
-export function disposeServerResources(): void {
-    _disposables.forEach((disposable) => disposable.dispose())
-    _disposables = []
-}
-
-async function createServer(
-    settings: ISettings,
-    serverId: string,
-    serverName: string,
-    outputChannel: LogOutputChannel,
-    initializationOptions: IInitOptions
-): Promise<LanguageClient> {
-    const command = settings.interpreter[0]
-    if (!command) {
-        throw new Error("No Python interpreter is configured for the language server.")
-    }
-    const cwd = settings.cwd
-
-    // Set debugger path needed for debugging python code.
-    const newEnv = { ...process.env }
-    const isDebugScript = await fsapi.pathExists(DEBUG_SERVER_SCRIPT_PATH)
-    const debugRequested = newEnv.USE_DEBUGPY?.toLowerCase() === "true"
-    if (debugRequested && !isDebugScript) {
-        throw new Error(`Python debug bootstrap not found: ${DEBUG_SERVER_SCRIPT_PATH}`)
-    }
-
-    const debuggerPath = debugRequested ? await getDebuggerPath() : undefined
-    if (debugRequested && !debuggerPath) {
-        throw new Error(
-            "Python debugging was requested, but the Python Debugger extension did not provide debugpy."
-        )
-    }
-    if (debugRequested && debuggerPath) {
-        newEnv.DEBUGPY_PATH = debuggerPath
-    } else {
-        newEnv.USE_DEBUGPY = "False"
-    }
-
-    // Set import strategy
-    newEnv.LS_IMPORT_STRATEGY = settings.importStrategy
-
-    // Set notification type
-    newEnv.LS_SHOW_NOTIFICATION = settings.showNotifications
-
-    const serverScript = debugRequested ? DEBUG_SERVER_SCRIPT_PATH : SERVER_SCRIPT_PATH
-    const interpreterArgs = settings.interpreter.slice(1)
-    if (debugRequested && !interpreterArgs.includes("-Xfrozen_modules=off")) {
-        interpreterArgs.push("-Xfrozen_modules=off")
-    }
-    const args = interpreterArgs.concat([serverScript])
-    traceInfo(`Python debug mode: ${debugRequested ? "enabled" : "disabled"}`)
-    traceInfo(`Server run command: ${[command, ...args].join(" ")}`)
-
-    const serverOptions: ServerOptions = {
-        command,
-        args,
-        options: { cwd, env: newEnv }
-    }
-
-    // Options to control the language client
-    const tclFileWatcher = workspace.createFileSystemWatcher("**/*.tcl")
-    const clientOptions: LanguageClientOptions = {
-        // Register the server for python documents
-        documentSelector: isVirtualWorkspace()
-            ? [{ language: "tcl" }]
-            : [
-                  { scheme: "file", language: "tcl" },
-                  { scheme: "untitled", language: "tcl" },
-                  { scheme: "vscode-notebook", language: "tcl" },
-                  { scheme: "vscode-notebook-cell", language: "tcl" }
-              ],
-        outputChannel: outputChannel,
-        traceOutputChannel: outputChannel,
-        revealOutputChannelOn: RevealOutputChannelOn.Never,
-        synchronize: {
-            fileEvents: tclFileWatcher
-        },
-        initializationOptions
-    }
-
-    _disposables.push(tclFileWatcher)
-    return new LanguageClient(serverId, serverName, serverOptions, clientOptions)
-}
-
-export async function restartServer(
-    serverId: string,
-    serverName: string,
-    outputChannel: LogOutputChannel,
-    lsClient?: LanguageClient
-): Promise<LanguageClient | undefined> {
-    if (lsClient) {
-        traceInfo(`Server: Stop requested`)
-        await lsClient.stop()
-        disposeServerResources()
-    }
-    const projectRoot = await getProjectRoot()
-    const workspaceSetting = await getWorkspaceSettings(serverId, projectRoot, true)
-
-    try {
-        const newLSClient = await createServer(
-            workspaceSetting,
-            serverId,
-            serverName,
-            outputChannel,
-            {
-                settings: await getExtensionSettings(serverId, true),
-                globalSettings: await getGlobalSettings(serverId, false)
-            }
-        )
-        traceInfo(`Server: Start requested.`)
-        _disposables.push(
-            newLSClient.onDidChangeState((e) => {
-                switch (e.newState) {
-                    case State.Stopped:
-                        traceVerbose(`Server State: Stopped`)
-                        break
-                    case State.Starting:
-                        traceVerbose(`Server State: Starting`)
-                        break
-                    case State.Running:
-                        traceVerbose(`Server State: Running`)
-                        break
-                }
-            })
-        )
-        await newLSClient.start()
-        const level = getLSClientTraceLevel(outputChannel.logLevel, env.logLevel)
-        await newLSClient.setTrace(level)
-        return newLSClient
-    } catch (ex) {
-        traceError(`Server: Start failed: ${ex}`)
-        disposeServerResources()
-        return undefined
-    }
-}
@@ -1,136 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-import {
-    ConfigurationChangeEvent,
-    ConfigurationScope,
-    WorkspaceConfiguration,
-    WorkspaceFolder
-} from "vscode"
-import { getInterpreterDetails } from "./python"
-import { getConfiguration, getWorkspaceFolders } from "./vscodeapi"
-
-export interface ISettings {
-    cwd: string
-    workspace: string
-    args: string[]
-    path: string[]
-    interpreter: string[]
-    importStrategy: string
-    showNotifications: string
-}
-
-export function getExtensionSettings(
-    namespace: string,
-    includeInterpreter?: boolean
-): Promise<ISettings[]> {
-    return Promise.all(
-        getWorkspaceFolders().map((w) => getWorkspaceSettings(namespace, w, includeInterpreter))
-    )
-}
-
-function resolveVariables(value: string[], workspace?: WorkspaceFolder): string[] {
-    const substitutions = new Map<string, string>()
-    const home = process.env.HOME || process.env.USERPROFILE
-    if (home) {
-        substitutions.set("${userHome}", home)
-    }
-    if (workspace) {
-        substitutions.set("${workspaceFolder}", workspace.uri.fsPath)
-    }
-    substitutions.set("${cwd}", process.cwd())
-    getWorkspaceFolders().forEach((w) => {
-        substitutions.set("${workspaceFolder:" + w.name + "}", w.uri.fsPath)
-    })
-
-    return value.map((s) => {
-        for (const [key, value] of substitutions) {
-            s = s.replace(key, value)
-        }
-        return s
-    })
-}
-
-export function getInterpreterFromSetting(namespace: string, scope?: ConfigurationScope) {
-    const config = getConfiguration(namespace, scope)
-    return config.get<string[]>("interpreter")
-}
-
-export async function getWorkspaceSettings(
-    namespace: string,
-    workspace: WorkspaceFolder,
-    includeInterpreter?: boolean
-): Promise<ISettings> {
-    const config = getConfiguration(namespace, workspace.uri)
-
-    let interpreter: string[] = []
-    if (includeInterpreter) {
-        interpreter = getInterpreterFromSetting(namespace, workspace) ?? []
-        if (interpreter.length === 0) {
-            interpreter = (await getInterpreterDetails(workspace.uri)).path ?? []
-        }
-    }
-
-    const workspaceSetting = {
-        cwd: workspace.uri.fsPath,
-        workspace: workspace.uri.toString(),
-        args: resolveVariables(config.get<string[]>(`args`) ?? [], workspace),
-        path: resolveVariables(config.get<string[]>(`path`) ?? [], workspace),
-        interpreter: resolveVariables(interpreter, workspace),
-        importStrategy: config.get<string>(`importStrategy`) ?? "useBundled",
-        showNotifications: config.get<string>(`showNotifications`) ?? "off",
-        formatter: config.get<boolean>(`formatter`) ?? true,
-        inlayHint: config.get<boolean>(`inlayHint`) ?? true
-    }
-    return workspaceSetting
-}
-
-function getGlobalValue<T>(config: WorkspaceConfiguration, key: string, defaultValue: T): T {
-    const inspect = config.inspect<T>(key)
-    return inspect?.globalValue ?? inspect?.defaultValue ?? defaultValue
-}
-
-export async function getGlobalSettings(
-    namespace: string,
-    includeInterpreter?: boolean
-): Promise<ISettings> {
-    const config = getConfiguration(namespace)
-
-    let interpreter: string[] = []
-    if (includeInterpreter) {
-        interpreter = getGlobalValue<string[]>(config, "interpreter", [])
-        if (interpreter === undefined || interpreter.length === 0) {
-            interpreter = (await getInterpreterDetails()).path ?? []
-        }
-    }
-
-    const setting = {
-        cwd: process.cwd(),
-        workspace: process.cwd(),
-        args: getGlobalValue<string[]>(config, "args", []),
-        path: getGlobalValue<string[]>(config, "path", []),
-        interpreter: interpreter,
-        importStrategy: getGlobalValue<string>(config, "importStrategy", "useBundled"),
-        showNotifications: getGlobalValue<string>(config, "showNotifications", "off"),
-        formatter: config.get<boolean>(`formatter`) ?? true,
-        inlayHint: config.get<boolean>(`inlayHint`) ?? true
-    }
-    return setting
-}
-
-export function checkIfConfigurationChanged(
-    e: ConfigurationChangeEvent,
-    namespace: string
-): boolean {
-    const settings = [
-        `${namespace}.args`,
-        `${namespace}.path`,
-        `${namespace}.interpreter`,
-        `${namespace}.importStrategy`,
-        `${namespace}.showNotifications`,
-        `${namespace}.formatter`,
-        `${namespace}.inlayHint`
-    ]
-    const changed = settings.map((s) => e.affectsConfiguration(s))
-    return changed.includes(true)
-}
@@ -1,18 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-import * as path from "path"
-import * as fs from "fs-extra"
-import { EXTENSION_ROOT_DIR } from "./constants"
-
-export interface IServerInfo {
-    name: string
-    module: string
-}
-
-export function loadServerDefaults(): IServerInfo {
-    const packageJson = path.join(EXTENSION_ROOT_DIR, "package.json")
-    const content = fs.readFileSync(packageJson).toString()
-    const config = JSON.parse(content)
-    return config.serverInfo as IServerInfo
-}
@@ -1,69 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-import * as fs from "fs-extra"
-import * as path from "path"
-import { LogLevel, Uri, WorkspaceFolder } from "vscode"
-import { Trace } from "vscode-jsonrpc/node"
-import { getWorkspaceFolders } from "./vscodeapi"
-
-function logLevelToTrace(logLevel: LogLevel): Trace {
-    switch (logLevel) {
-        case LogLevel.Error:
-        case LogLevel.Warning:
-        case LogLevel.Info:
-            return Trace.Messages
-
-        case LogLevel.Debug:
-        case LogLevel.Trace:
-            return Trace.Verbose
-
-        case LogLevel.Off:
-        default:
-            return Trace.Off
-    }
-}
-
-export function getLSClientTraceLevel(channelLogLevel: LogLevel, globalLogLevel: LogLevel): Trace {
-    if (channelLogLevel === LogLevel.Off) {
-        return logLevelToTrace(globalLogLevel)
-    }
-    if (globalLogLevel === LogLevel.Off) {
-        return logLevelToTrace(channelLogLevel)
-    }
-    const level = logLevelToTrace(
-        channelLogLevel <= globalLogLevel ? channelLogLevel : globalLogLevel
-    )
-    return level
-}
-
-export async function getProjectRoot(): Promise<WorkspaceFolder> {
-    const workspaces: readonly WorkspaceFolder[] = getWorkspaceFolders()
-    if (workspaces.length === 0) {
-        return {
-            uri: Uri.file(process.cwd()),
-            name: path.basename(process.cwd()),
-            index: 0
-        }
-    } else if (workspaces.length === 1) {
-        return workspaces[0]
-    } else {
-        let rootWorkspace = workspaces[0]
-        let root = undefined
-        for (const w of workspaces) {
-            if (await fs.pathExists(w.uri.fsPath)) {
-                root = w.uri.fsPath
-                rootWorkspace = w
-                break
-            }
-        }
-
-        for (const w of workspaces) {
-            if (root && root.length > w.uri.fsPath.length && (await fs.pathExists(w.uri.fsPath))) {
-                root = w.uri.fsPath
-                rootWorkspace = w
-            }
-        }
-        return rootWorkspace
-    }
-}
@@ -1,52 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-    commands,
-    ConfigurationScope,
-    Disposable,
-    LogOutputChannel,
-    Uri,
-    window,
-    workspace,
-    WorkspaceConfiguration,
-    WorkspaceFolder
-} from "vscode"
-
-export function createOutputChannel(name: string): LogOutputChannel {
-    return window.createOutputChannel(name, { log: true })
-}
-
-export function getConfiguration(
-    config: string,
-    scope?: ConfigurationScope
-): WorkspaceConfiguration {
-    return workspace.getConfiguration(config, scope)
-}
-
-export function registerCommand(
-    command: string,
-    callback: (...args: any[]) => any,
-    thisArg?: any
-): Disposable {
-    return commands.registerCommand(command, callback, thisArg)
-}
-
-export const { onDidChangeConfiguration } = workspace
-
-export function isVirtualWorkspace(): boolean {
-    const isVirtual =
-        workspace.workspaceFolders &&
-        workspace.workspaceFolders.every((f) => f.uri.scheme !== "file")
-    return !!isVirtual
-}
-
-export function getWorkspaceFolders(): readonly WorkspaceFolder[] {
-    return workspace.workspaceFolders ?? []
-}
-
-export function getWorkspaceFolder(uri: Uri): WorkspaceFolder | undefined {
-    return workspace.getWorkspaceFolder(uri)
-}
@@ -3,7 +3,7 @@ import {
    LanguageClient,
    LanguageClientOptions,
    ServerOptions,
-    TransportKind
+    Executable
 } from "vscode-languageclient/node"
 import {
    formatCdlFile,
@@ -13,137 +13,61 @@ import {
    isFirstLineMachine,
    diagnosticHandler,
    cdlDocumentSymbolProvider,
-    defDocumentSymbolProvider,
-    definitionCdlEventHandler
+    defDocumentSymbolProvider
 } from "./common/handlers"
-import { registerLogger, traceError, traceLog, traceVerbose } from "./common/log/logging"
-import {
-    checkVersion,
-    getInterpreterDetails,
-    initializePython,
-    onDidChangePythonInterpreter,
-    resolveInterpreter
-} from "./common/python"
-import { disposeServerResources, restartServer } from "./common/server"
-import { checkIfConfigurationChanged, getInterpreterFromSetting } from "./common/settings"
-import { loadServerDefaults } from "./common/setup"
-import { getLSClientTraceLevel } from "./common/utilities"
-import { createOutputChannel, onDidChangeConfiguration, registerCommand } from "./common/vscodeapi"
-
-let client: LanguageClient | undefined

+let client: LanguageClient
+interface InitializationOptions {
+    perFileParser: Record<string, string>
+}
 export async function activate(context: vscode.ExtensionContext) {
-    // This is required to get server name and module. This should be
-    // the first thing that we do in this extension.
-    const serverInfo = loadServerDefaults()
-    const serverName = serverInfo.name
-    const serverId = serverInfo.module
-    const pythonDebugMode = process.env.USE_DEBUGPY?.toLowerCase() === "true"
-
-    // Setup logging
-    const outputChannel = createOutputChannel(serverName)
-    context.subscriptions.push(outputChannel, registerLogger(outputChannel))
-
-    const changeLogLevel = async (c: vscode.LogLevel, g: vscode.LogLevel) => {
-        const level = getLSClientTraceLevel(c, g)
-        await client?.setTrace(level)
-    }
-
-    context.subscriptions.push(
-        outputChannel.onDidChangeLogLevel(async (e) => {
-            await changeLogLevel(e, vscode.env.logLevel)
-        }),
-        vscode.env.onDidChangeLogLevel(async (e) => {
-            await changeLogLevel(outputChannel.logLevel, e)
-        })
+    // Allow overriding the server executable path via environment variable so
+    // the extension can attach to a debug-run server started externally.
+    // If `TCL_LSP_SERVER_PATH` is set, use that path; otherwise fall back to
+    // the packaged server inside the extension.
+    let serverCommand: string
+    const serverModule = vscode.Uri.joinPath(
+        context.extensionUri,
+        "server",
+        "target",
+        ...(process.platform === "win32"
+            ? ["x86_64-pc-windows-gnu", "release", "lsp-main.exe"]
+            : ["x86_64-unknown-linux-gnu", "release", "lsp-main"])
    )
+    serverCommand = serverModule.fsPath

-    // Log Server information
-    traceLog(`Name: ${serverInfo.name}`)
-    traceLog(`Module: ${serverInfo.module}`)
-    traceVerbose(`Full Server Info: ${JSON.stringify(serverInfo)}`)
-
-    const runServerImpl = async () => {
-        const interpreter = getInterpreterFromSetting(serverId)
-        if (interpreter && interpreter.length > 0) {
-            if (checkVersion(await resolveInterpreter(interpreter))) {
-                traceVerbose(
-                    `Using interpreter from ${serverInfo.module}.interpreter: ${interpreter.join(" ")}`
-                )
-                client = await restartServer(serverId, serverName, outputChannel, client)
-            }
-            return
-        }
-
-        const interpreterDetails = await getInterpreterDetails()
-        if (interpreterDetails.path) {
-            traceVerbose(
-                `Using interpreter from Python extension: ${interpreterDetails.path.join(" ")}`
-            )
-            client = await restartServer(serverId, serverName, outputChannel, client)
-            return
-        }
-
-        traceError(
-            "Python interpreter missing:\r\n" +
-                "[Option 1] Select python interpreter using the ms-python.python.\r\n" +
-                `[Option 2] Set an interpreter using "${serverId}.interpreter" setting.\r\n` +
-                "Please use Python 3.8 or greater."
-        )
+    const channel = vscode.window.createOutputChannel("TCL LSP Server", "log")
+    const run: Executable = {
+        command: serverCommand,
+        options: { env: process.env }
+    }
+    const serverOptions: ServerOptions = {
+        run,
+        debug: run
    }

-    // Serialize server (re)starts. Overlapping triggers (interpreter change,
-    // config change, restart command, initial activation) would otherwise each
-    // read the stale module-level `client`, start a new server and leave the
-    // previous one running orphaned -> hints/hover shown multiple times.
-    let runServerQueue: Promise<void> = Promise.resolve()
-    const runServer = () => {
-        runServerQueue = runServerQueue.catch(() => undefined).then(() => runServerImpl())
-        return runServerQueue
+    const initializationOptions: InitializationOptions = {
+        perFileParser: {
+            tcl: "tcl"
+        }
    }

-    if (!pythonDebugMode) {
-        context.subscriptions.push(
-            onDidChangePythonInterpreter(async () => {
-                await runServer()
-            })
-        )
+    const clientOptions: LanguageClientOptions = {
+        documentSelector: [{ language: "tcl" }],
+        synchronize: {
+            fileEvents: vscode.workspace.createFileSystemWatcher("**/*.tcl")
+        },
+        outputChannel: channel,
+        initializationOptions
    }

-    context.subscriptions.push(
-        onDidChangeConfiguration(async (e: vscode.ConfigurationChangeEvent) => {
-            if (checkIfConfigurationChanged(e, serverId)) {
-                await runServer()
-            }
-        }),
-        registerCommand(`${serverId}.restart`, async () => {
-            await runServer()
-        })
-    )
+    client = new LanguageClient("lspClient", "LSP Client", serverOptions, clientOptions)

-    setImmediate(async () => {
-        if (pythonDebugMode) {
-            // A debugpy listen session is attached to exactly one process. Do not
-            // subscribe to interpreter changes during startup, as the Python
-            // extension can emit a duplicate event and restart that process.
-            traceLog("Python debug mode: starting one stable server session")
-            await runServer()
-            return
-        }
-
-        const interpreter = getInterpreterFromSetting(serverId)
-        if (interpreter === undefined || interpreter.length === 0) {
-            traceLog(`Python extension loading`)
-            await initializePython(context.subscriptions)
-            traceLog(`Python extension loaded`)
-        } else {
-            await runServer()
-        }
-    })
-
-    // Folding ranges for TCL are provided by the language server
-    // (folding_range_provider in lsp_server.py). No client-side provider here to
-    // avoid duplicate folding regions.
+    try {
+        await client.start()
+    } catch (error) {
+        client.error(`Start failed`, error, "force")
+    }

    //
    const formatCdlProvider = vscode.languages.registerDocumentFormattingEditProvider(
@@ -193,16 +117,6 @@ export async function activate(context: vscode.ExtensionContext) {
    )
    context.subscriptions.push(hoverCdlProvider)

-    const definitionCdlEventProvider = vscode.languages.registerDefinitionProvider(
-        { scheme: "file", language: "cdl" },
-        {
-            provideDefinition(document, position, token) {
-                return definitionCdlEventHandler(document, position, token)
-            }
-        }
-    )
-    context.subscriptions.push(definitionCdlEventProvider)
-
    const formatDefProvider = vscode.languages.registerDocumentFormattingEditProvider(
        { scheme: "file", language: "def" },
        {
@@ -247,33 +161,31 @@ export async function activate(context: vscode.ExtensionContext) {
    context.subscriptions.push(diagnosticCollectionCdl, diagnosticCollectionDef)

    // Check if the first line of the CDL file contains "MACHINE"
-    context.subscriptions.push(
-        vscode.workspace.onDidOpenTextDocument((document) => {
-            if (document.languageId === "cdl" || document.languageId === "def") {
-                if (document.languageId === "cdl") {
-                    diagnosticCollectionCdl.set(document.uri, diagnosticHandler(document))
-                } else if (document.languageId === "def") {
-                    diagnosticCollectionDef.set(document.uri, diagnosticHandler(document))
-                }
+    vscode.workspace.onDidOpenTextDocument((document) => {
+        if (document.languageId === "cdl" || document.languageId === "def") {
+            if (document.languageId === "cdl") {
+                diagnosticCollectionCdl.set(document.uri, diagnosticHandler(document))
+            } else if (document.languageId === "def") {
+                diagnosticCollectionDef.set(document.uri, diagnosticHandler(document))
            }
-        }),
-        vscode.workspace.onDidChangeTextDocument((event) => {
-            const document = event.document
-            if (document.languageId === "cdl" || document.languageId === "def") {
-                if (document.languageId === "cdl") {
-                    diagnosticCollectionCdl.set(document.uri, diagnosticHandler(document))
-                } else if (document.languageId === "def") {
-                    diagnosticCollectionDef.set(document.uri, diagnosticHandler(document))
-                }
+        }
+    })
+
+    vscode.workspace.onDidChangeTextDocument((event) => {
+        const document = event.document
+        if (document.languageId === "cdl" || document.languageId === "def") {
+            if (document.languageId === "cdl") {
+                diagnosticCollectionCdl.set(document.uri, diagnosticHandler(document))
+            } else if (document.languageId === "def") {
+                diagnosticCollectionDef.set(document.uri, diagnosticHandler(document))
            }
-        })
-    )
+        }
+    })
 }

 export function deactivate(): Thenable<void> | undefined {
    if (!client) {
-        disposeServerResources()
        return undefined
    }
-    return client.stop().finally(disposeServerResources)
+    return client.stop()
 }
@@ -1,12 +1,21 @@
 {
    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2019",
-        "lib": ["ES2019"],
+        "rootDir": "./src",
+        "skipLibCheck": true,
+        "lib": ["ES2024", "webworker"],
+        "types": ["vscode"],
+        "module": "Node16",
+        "moduleResolution": "Node16",
        "outDir": "./out",
-        "rootDir": "src",
-        "sourceMap": true
-    },
-    "include": ["src"],
-    "exclude": ["node_modules", ".vscode-test"]
+        "strict": true,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "declaration": true,
+        "stripInternal": true,
+        "sourceMap": true,
+        "declarationMap": true,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false
+    }
 }
@@ -0,0 +1 @@
+{"root":["./src/extension.ts","./src/common/handlers.ts","./src/common/log/logging.ts"],"version":"5.7.2"}
@@ -1,21 +1,19 @@
 const esbuild = require("esbuild")
-const path = require("path")

 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")

 async function main() {
    const ctx = await esbuild.context({
-        absWorkingDir: __dirname,
        entryPoints: ["client/src/extension.ts"],
        bundle: true,
        format: "cjs",
        minify: production,
        sourcemap: !production,
-        sourcesContent: !production,
+        sourcesContent: false,
        platform: "node",
        // outdir: "out",
-        outfile: path.join(__dirname, "dist", "extension.js"),
+        outfile: "./dist/extension.js",
        external: ["vscode"],
        logLevel: "silent",
        plugins: [
@@ -1,35 +1,28 @@
 {
-    "comments": {
-        // symbol used for single line comment. Remove this entry if your language does not support line comments
-        "lineComment": "#"
-    },
-    "indentationRules": {
-        // Ignore pure comment lines so they don't terminate folds inside Tcl brace blocks.
-        "unIndentedLinePattern": "^\\s*#.*$",
-        // Opening braces on their own line are common in NX Tcl.
-        "increaseIndentPattern": "^((?!#).)*(\\{[^}\"']*)$",
-        "decreaseIndentPattern": "^\\s*[\\}\\]\\)].*$"
-    },
-    // symbols used as brackets
-    "brackets": [
-        ["{", "}"],
-        ["[", "]"],
-        ["(", ")"]
-    ],
-    // symbols that are auto closed when typing
-    "autoClosingPairs": [
-        ["{", "}"],
-        ["[", "]"],
-        ["(", ")"],
-        ["\"", "\""],
-        ["'", "'"]
-    ],
-    // symbols that can be used to surround a selection
-    "surroundingPairs": [
-        ["{", "}"],
-        ["[", "]"],
-        ["(", ")"],
-        ["\"", "\""],
-        ["'", "'"]
-    ]
+  "comments": {
+    // symbol used for single line comment. Remove this entry if your language does not support line comments
+    "lineComment": "#"
+  },
+  // symbols used as brackets
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  // symbols that are auto closed when typing
+  "autoClosingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["'", "'"]
+  ],
+  // symbols that can be used to surround a selection
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["'", "'"]
+  ]
 }
@@ -1,12 +1,12 @@
 {
  "name": "nx-post-support",
-  "version": "2025.9.200",
+  "version": "0.3.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "nx-post-support",
-      "version": "2025.9.200",
+      "version": "0.3.0",
      "devDependencies": {
        "@types/vscode": "^1.96.0",
        "@vscode/vsce": "^3.2.1",
@@ -2,12 +2,9 @@
  "name": "nx-post-support",
  "displayName": "NX Postprocessor Support",
  "description": "VS Code extension for NX CAM postprocessor development with syntax highlighting, formatting, linting, and auto-completion for CDL, TCL, and DEF files",
-  "version": "2026.6.201",
+  "version": "2025.9.100",
  "publisher": "Christoph",
  "icon": "images/nx-1.png",
-  "extensionDependencies": [
-    "ms-python.python"
-  ],
  "serverInfo": {
    "name": "NX Postprocessor Support",
    "module": "nx-post-support"
@@ -16,7 +13,7 @@
    "type": "git",
    "url": "https://git.cbsk-tech.de/Christoph/nx_post_support.git"
  },
-  "main": "./dist/extension.js",
+  "main": "./client/out/extension",
  "keywords": [
    "cdl",
    "NX CDL",
@@ -123,10 +120,12 @@
    }
  },
  "scripts": {
-    "compile": "node esbuild.js --production",
-    "compile:debug": "node esbuild.js",
-    "watch": "node esbuild.js --watch",
-    "package": "node esbuild.js --production"
+    "postinstall": "cd client && npm install && cd ..",
+    "vscode:prepublish": "npm run build",
+    "debug": "cd client && npm run compile",
+    "build": "cd client && npm run compile && cd ../server && npm run build && cd ..",
+    "lint": "cd client && npm run lint && cd ..",
+    "esbuild": "node ./bin/esbuild.js"
  },
  "devDependencies": {
    "@types/vscode": "^1.96.0",
@@ -136,4 +135,4 @@
    "prettier": "^3.4.2",
    "typescript": "^5.7.2"
  }
-}
+}
@@ -0,0 +1,843 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "analysis"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "lsp-types",
+ "serde",
+ "serde_json",
+ "tree-sitter",
+ "tree-sitter-tcl",
+]
+
+[[package]]
+name = "analysis-tests"
+version = "0.1.0"
+dependencies = [
+ "analysis",
+ "tree-sitter",
+ "tree-sitter-tcl",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cc"
+version = "1.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "590f9024a68a8c40351881787f1934dc11afd69090f5edb6831464694d836ea3"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "features"
+version = "0.1.0"
+dependencies = [
+ "analysis",
+ "anyhow",
+ "lsp-types",
+ "text",
+ "url",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e178e4fba8a2726903f6ba98a6d221e76f9c12c650d5dc0e6afdc50677b49650"
+
+[[package]]
+name = "fluent-uri"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2481980430f9f78649238835720ddccc57e52df14ffce1c6f37391d61b563e9"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jiff"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "lsp-main"
+version = "0.1.0"
+dependencies = [
+ "analysis",
+ "anyhow",
+ "env_logger",
+ "features",
+ "log",
+ "lsp-server",
+ "lsp-types",
+ "serde",
+ "serde_json",
+ "text",
+]
+
+[[package]]
+name = "lsp-server"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d6ada348dbc2703cbe7637b2dda05cff84d3da2819c24abcb305dd613e0ba2e"
+dependencies = [
+ "crossbeam-channel",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "lsp-types"
+version = "0.97.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53353550a17c04ac46c585feb189c2db82154fc84b79c7a66c96c2c644f66071"
+dependencies = [
+ "bitflags",
+ "fluent-uri",
+ "serde",
+ "serde_json",
+ "serde_repr",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.143"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d401abef1d108fbd9cbaebc3e46611f4b1021f714a0597a71f41ee463f5f4a5a"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520"
+
+[[package]]
+name = "syn"
+version = "2.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "text"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "lsp-types",
+ "tree-sitter",
+ "tree-sitter-tcl",
+ "url",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tree-sitter"
+version = "0.25.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d7b8994f367f16e6fa14b5aebbcb350de5d7cbea82dc5b00ae997dd71680dd2"
+dependencies = [
+ "cc",
+ "regex",
+ "regex-syntax",
+ "serde_json",
+ "streaming-iterator",
+ "tree-sitter-language",
+]
+
+[[package]]
+name = "tree-sitter-language"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4013970217383f67b18aef68f6fb2e8d409bc5755227092d32efb0422ba24b8"
+
+[[package]]
+name = "tree-sitter-tcl"
+version = "1.1.0"
+source = "git+https://github.com/tree-sitter-grammars/tree-sitter-tcl#8f11ac7206a54ed11210491cee1e0657e2962c47"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "writeable"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
@@ -0,0 +1,25 @@
+[workspace]
+members = [
+  "crates/lsp-main",
+  "crates/text",
+  "crates/analysis",
+  "crates/features",
+  "tests/analysis-tests",
+]
+resolver = "2"
+
+[workspace.package]
+edition = "2021"
+resolver = "2"
+
+[workspace.dependencies]
+anyhow = "1"
+env_logger = "0.11"
+log = "0.4.28"
+lsp-server = "0.7"
+lsp-types = "0.97"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tree-sitter = "0.25.8"
+tree-sitter-tcl = { git = "https://github.com/tree-sitter-grammars/tree-sitter-tcl" }
+url = "2"
@@ -0,0 +1,13 @@
+[package]
+name = "analysis"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+lsp-types = { workspace = true }
+tree-sitter = { workspace = true }
+tree-sitter-tcl = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+
@@ -0,0 +1,22 @@
+use tree_sitter::Parser;
+use analysis::collect_procs;
+
+fn main() {
+    let src = r#"namespace eval foo {
+  proc bar {x y} { return $x }
+}
+proc top {} {}
+"#;
+    let mut parser = Parser::new();
+    parser
+        .set_language(&tree_sitter_tcl::LANGUAGE.into())
+        .expect("load tcl grammar");
+    let tree = parser.parse(src, None).expect("parse");
+    println!("tree: {}", tree.root_node().to_sexp());
+    let procs = collect_procs(&tree, src);
+    println!("found {} procs via collect_procs", procs.len());
+    for p in procs {
+        println!("- {} {:?}", p.name, p.params);
+    }
+}
+
@@ -0,0 +1,99 @@
+use serde::{ Deserialize, Serialize };
+use std::collections::HashMap;
+use tree_sitter::{ Node, Tree };
+use lsp_types as lsp;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProcDef {
+    pub name: String,
+    pub params: Vec<String>,
+    pub byte_start: usize,
+    pub byte_end: usize,
+}
+
+#[derive(Default)]
+pub struct ProcIndex {
+    by_uri: HashMap<lsp::Uri, Vec<ProcDef>>,
+}
+
+impl ProcIndex {
+    pub fn insert(&mut self, uri: lsp::Uri, procs: Vec<ProcDef>) {
+        self.by_uri.insert(uri, procs);
+    }
+    pub fn get(&self, uri: &lsp::Uri) -> Option<&[ProcDef]> {
+        self.by_uri.get(uri).map(|v| v.as_slice())
+    }
+    pub fn remove(&mut self, uri: &lsp::Uri) {
+        self.by_uri.remove(uri);
+    }
+}
+
+pub fn collect_procs(tree: &Tree, source: &str) -> Vec<ProcDef> {
+    let root = tree.root_node();
+    let mut out = Vec::new();
+    collect_from_node(root, source.as_bytes(), &mut out);
+    out
+}
+
+fn collect_from_node(node: Node, src: &[u8], out: &mut Vec<ProcDef>) {
+    let mut stack = vec![node];
+    let mut cursor = node.walk();
+
+    while let Some(n) = stack.pop() {
+        if n.kind() == "command" {
+            if let Some(p) = try_extract_proc(n, src) {
+                out.push(p);
+            }
+        }
+        let mut it = n.children(&mut cursor);
+        while let Some(c) = it.next() {
+            stack.push(c);
+        }
+    }
+}
+
+fn try_extract_proc(cmd: Node, src: &[u8]) -> Option<ProcDef> {
+    // Gather word-like named children
+    let mut cursor = cmd.walk();
+    let mut words: Vec<(Node, String)> = Vec::new();
+    for ch in cmd.named_children(&mut cursor) {
+        match ch.kind() {
+            "word" | "braced_word" | "quoted_word" => {
+                if let Ok(t) = ch.utf8_text(src) {
+                    words.push((ch, t.to_string()));
+                }
+            }
+            _ => {}
+        }
+    }
+    if words.len() < 2 {
+        return None;
+    }
+    if words[0].1 != "proc" {
+        return None;
+    }
+
+    let name = words[1].1.trim().to_string();
+    let params = if words.len() >= 3 { parse_params(&words[2].0, &words[2].1) } else { vec![] };
+
+    Some(ProcDef {
+        name,
+        params,
+        byte_start: cmd.start_byte(),
+        byte_end: cmd.end_byte(),
+    })
+}
+
+fn parse_params(node: &Node, text: &str) -> Vec<String> {
+    // naive split; good enough for a starter
+    let is_braced =
+        node.kind() == "braced_word" &&
+        text.starts_with('{') &&
+        text.ends_with('}') &&
+        text.len() >= 2;
+    let inner = if is_braced { &text[1..text.len() - 1] } else { text };
+    inner
+        .split_whitespace()
+        .map(|s| s.to_string())
+        .collect()
+}
@@ -0,0 +1,11 @@
+[package]
+name = "features"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+lsp-types = { workspace = true }
+analysis = { path = "../analysis" }
+text = { path = "../text" }
+url = { workspace = true }
@@ -0,0 +1,31 @@
+use anyhow::Result;
+use analysis::ProcIndex;
+use lsp_types as lsp;
+use text::DocumentStore;
+
+pub fn completion(
+    docs: &DocumentStore,
+    index: &ProcIndex,
+    params: &lsp::CompletionParams
+) -> Result<Option<lsp::CompletionResponse>> {
+    let uri = &params.text_document_position.text_document.uri;
+    let Some(_doc) = docs.get(uri) else {
+        return Ok(None);
+    };
+    let Some(procs) = index.get(uri) else {
+        return Ok(None);
+    };
+
+    let items: Vec<lsp::CompletionItem> = procs
+        .iter()
+        .map(|p| lsp::CompletionItem {
+            label: p.name.clone(),
+            kind: Some(lsp::CompletionItemKind::FUNCTION),
+            detail: Some(format!("proc {}", p.params.join(" "))),
+            insert_text: Some(p.name.clone()),
+            ..Default::default()
+        })
+        .collect();
+
+    Ok(Some(lsp::CompletionResponse::Array(items)))
+}
@@ -0,0 +1,33 @@
+use anyhow::Result;
+use analysis::ProcIndex;
+use lsp_types as lsp;
+use text::DocumentStore;
+
+pub fn definition(
+    docs: &DocumentStore,
+    index: &ProcIndex,
+    params: &lsp::GotoDefinitionParams
+) -> Result<Option<lsp::GotoDefinitionResponse>> {
+    let uri = &params.text_document_position_params.text_document.uri;
+    let pos = params.text_document_position_params.position;
+    let Some(doc) = docs.get(uri) else {
+        return Ok(None);
+    };
+    let Some((word, _range)) = doc.word_under_position(pos) else {
+        return Ok(None);
+    };
+
+    let Some(procs) = index.get(uri) else {
+        return Ok(None);
+    };
+
+    if let Some(p) = procs.iter().find(|p| p.name == word) {
+        let loc = lsp::Location {
+            uri: uri.clone(),
+            range: doc.byte_range_to_lsp_range(p.byte_start, p.byte_end),
+        };
+        return Ok(Some(lsp::GotoDefinitionResponse::Scalar(loc)));
+    }
+
+    Ok(None)
+}
@@ -0,0 +1,34 @@
+use anyhow::Result;
+use analysis::ProcIndex;
+use lsp_types as lsp;
+use text::DocumentStore;
+
+pub fn document_symbol(
+    docs: &DocumentStore,
+    index: &ProcIndex,
+    uri: &lsp::Uri
+) -> Result<Option<lsp::DocumentSymbolResponse>> {
+    let Some(doc) = docs.get(uri) else {
+        return Ok(None);
+    };
+    let Some(procs) = index.get(uri) else {
+        return Ok(None);
+    };
+
+    let mut symbols = Vec::new();
+    for p in procs {
+        let range = doc.byte_range_to_lsp_range(p.byte_start, p.byte_end);
+        symbols.push(lsp::DocumentSymbol {
+            name: p.name.clone(),
+            detail: Some(format!("proc {}", p.params.join(" "))),
+            kind: lsp::SymbolKind::FUNCTION,
+            range,
+            selection_range: range,
+            children: None,
+            tags: None,
+            deprecated: None,
+        });
+    }
+
+    Ok(Some(lsp::DocumentSymbolResponse::Nested(symbols)))
+}
@@ -0,0 +1,7 @@
+mod document_symbol;
+mod definition;
+mod completion;
+
+pub use document_symbol::document_symbol;
+pub use definition::definition;
+pub use completion::completion;
@@ -0,0 +1,16 @@
+[package]
+name = "lsp-main"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+env_logger = { workspace = true }
+log = { workspace = true }
+lsp-server = { workspace = true }
+lsp-types = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+analysis = { path = "../analysis" }
+features = { path = "../features" }
+text = { path = "../text" }
@@ -0,0 +1,13 @@
+use anyhow::Result;
+use env_logger::Env;
+use lsp_server::Connection;
+
+mod server;
+
+fn main() -> Result<()> {
+    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
+    let (connection, io_threads) = Connection::stdio();
+    server::Server::new(connection).run()?;
+    io_threads.join()?;
+    Ok(())
+}
@@ -0,0 +1,177 @@
+use anyhow::Result;
+use log;
+use lsp_server::{ Connection, Message, Response };
+use lsp_server::Notification as ServerNotification;
+use lsp_server::Request as ServerRequest;
+use lsp_types as lsp;
+use lsp_types::notification::{
+    DidChangeTextDocument,
+    DidCloseTextDocument,
+    DidOpenTextDocument,
+    LogMessage,
+    Notification as LspNotification,
+};
+use lsp_types::request::{
+    Completion,
+    DocumentSymbolRequest,
+    GotoDefinition,
+    Request as LspRequest,
+};
+use serde_json::Value;
+
+use analysis::{ collect_procs, ProcIndex };
+use features::{ completion, definition, document_symbol };
+use text::DocumentStore;
+
+pub struct Server {
+    conn: Connection,
+    docs: DocumentStore,
+    procs: ProcIndex,
+}
+
+impl Server {
+    pub fn new(conn: Connection) -> Self {
+        Self {
+            conn,
+            docs: DocumentStore::default(),
+            procs: ProcIndex::default(),
+        }
+    }
+
+    pub fn run(mut self) -> Result<()> {
+        // Initialize handshake
+        let (id, _params) = self.conn.initialize_start()?;
+        let result = lsp::InitializeResult {
+            capabilities: server_capabilities(),
+            server_info: Some(lsp::ServerInfo {
+                name: "tcl-lsp".into(),
+                version: Some(env!("CARGO_PKG_VERSION").into()),
+            }),
+        };
+        self.conn.initialize_finish(id, serde_json::to_value(result)?)?;
+
+        let _ = self.log("tcl-lsp ready");
+
+        let receiver = self.conn.receiver.clone();
+
+        // main loop
+        for msg in receiver.iter() {
+            match msg {
+                lsp_server::Message::Request(req) => {
+                    if self.conn.handle_shutdown(&req)? {
+                        break;
+                    }
+                    if let Err(e) = self.on_request(req) {
+                        log::error!("request error: {e:#}");
+                    }
+                }
+                lsp_server::Message::Notification(n) => {
+                    if let Err(e) = self.on_notification(n) {
+                        log::error!("notification error: {e:#}");
+                    }
+                }
+                lsp_server::Message::Response(_) => {}
+            }
+        }
+
+        let _ = self.log("tcl-lsp stopped");
+        Ok(())
+    }
+
+    fn on_notification(&mut self, n: ServerNotification) -> Result<()> {
+        match n.method.as_str() {
+            DidOpenTextDocument::METHOD => {
+                let params: lsp::DidOpenTextDocumentParams = serde_json::from_value(n.params)?;
+                let uri = params.text_document.uri.clone();
+                self.docs.open(params.text_document)?;
+                self.reindex(&uri)?;
+                self.log(&format!("Opened {:?}", uri))?;
+            }
+            DidChangeTextDocument::METHOD => {
+                let params: lsp::DidChangeTextDocumentParams = serde_json::from_value(n.params)?;
+                let uri = params.text_document.uri.clone();
+                // FULL sync: we expect one change with whole text
+                self.docs.apply_full_change(&uri, &params.content_changes)?;
+                self.reindex(&uri)?;
+            }
+            DidCloseTextDocument::METHOD => {
+                let params: lsp::DidCloseTextDocumentParams = serde_json::from_value(n.params)?;
+                self.procs.remove(&params.text_document.uri);
+                self.docs.close(&params.text_document.uri);
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn on_request(&mut self, req: ServerRequest) -> Result<()> {
+        match req.method.as_str() {
+            DocumentSymbolRequest::METHOD => {
+                let params: lsp::DocumentSymbolParams = serde_json::from_value(req.params)?;
+                let uri = params.text_document.uri;
+                let result = document_symbol(&self.docs, &self.procs, &uri)?;
+                send_ok(&self.conn, req.id, result)?;
+            }
+            GotoDefinition::METHOD => {
+                let params: lsp::GotoDefinitionParams = serde_json::from_value(req.params)?;
+                let result = definition(&self.docs, &self.procs, &params)?;
+                send_ok(&self.conn, req.id, result)?;
+            }
+            Completion::METHOD => {
+                let params: lsp::CompletionParams = serde_json::from_value(req.params)?;
+                let _ = self.log("Completion");
+                let result = completion(&self.docs, &self.procs, &params)?;
+                send_ok(&self.conn, req.id, result)?;
+            }
+            other => {
+                let resp = Response::new_err(
+                    req.id,
+                    lsp::error_codes::REQUEST_FAILED as i32,
+                    format!("Unknown method: {other}")
+                );
+                self.conn.sender.send(Message::Response(resp))?;
+            }
+        }
+        Ok(())
+    }
+
+    fn reindex(&mut self, uri: &lsp::Uri) -> Result<()> {
+        if let Some(doc) = self.docs.get(uri) {
+            if let Some(tree) = doc.tree() {
+                let text = doc.text();
+                let procs = collect_procs(tree, &text);
+                self.procs.insert(uri.clone(), procs);
+            }
+        }
+        Ok(())
+    }
+
+    fn log(&self, message: &str) -> Result<()> {
+        let notif = LogMessage::METHOD.to_string();
+        let params = lsp::LogMessageParams {
+            typ: lsp::MessageType::INFO,
+            message: message.to_string(),
+        };
+        self.conn.sender.send(Message::Notification(ServerNotification::new(notif, params)))?;
+        Ok(())
+    }
+}
+
+fn send_ok<T: serde::Serialize>(
+    conn: &Connection,
+    id: lsp_server::RequestId,
+    result: T
+) -> Result<()> {
+    let v: Value = serde_json::to_value(result)?;
+    conn.sender.send(Message::Response(Response::new_ok(id, v)))?;
+    Ok(())
+}
+
+fn server_capabilities() -> lsp::ServerCapabilities {
+    lsp::ServerCapabilities {
+        completion_provider: Some(lsp::CompletionOptions {
+            ..Default::default()
+        }),
+        ..Default::default()
+    }
+}
@@ -0,0 +1,11 @@
+[package]
+name = "text"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+lsp-types = { workspace = true }
+tree-sitter = { workspace = true }
+tree-sitter-tcl = { workspace = true }
+url = { workspace = true }
@@ -0,0 +1,179 @@
+use anyhow::{ bail, Context, Result };
+use lsp_types as lsp;
+use std::collections::HashMap;
+use tree_sitter::{ Parser, Tree };
+
+#[derive(Default)]
+pub struct DocumentStore {
+    docs: HashMap<lsp::Uri, Document>,
+}
+
+impl DocumentStore {
+    pub fn open(&mut self, item: lsp::TextDocumentItem) -> Result<()> {
+        let uri = item.uri.clone();
+        let doc = Document::open(item.text)?;
+        self.docs.insert(uri, doc);
+        Ok(())
+    }
+
+    pub fn apply_full_change(
+        &mut self,
+        uri: &lsp::Uri,
+        changes: &[lsp::TextDocumentContentChangeEvent]
+    ) -> Result<()> {
+        let Some(doc) = self.docs.get_mut(uri) else {
+            bail!("no such document: {:?}", uri);
+        };
+        // FULL sync: assume single change with whole text
+        let new_text = changes.last().context("empty changes for full sync")?.text.clone();
+        doc.reparse(&new_text)?;
+        Ok(())
+    }
+
+    pub fn close(&mut self, uri: &lsp::Uri) {
+        self.docs.remove(uri);
+    }
+
+    pub fn get(&self, uri: &lsp::Uri) -> Option<&Document> {
+        self.docs.get(uri)
+    }
+}
+
+pub struct Document {
+    text: String,
+    parser: Parser,
+    tree: Option<Tree>,
+}
+
+impl Document {
+    pub fn open(text: String) -> Result<Self> {
+        let mut parser = Parser::new();
+        parser.set_language(&tree_sitter_tcl::LANGUAGE.into()).context("load tcl grammar")?;
+        let tree = parser.parse(&text, None);
+        Ok(Self { text, parser, tree })
+    }
+
+    pub fn reparse(&mut self, new_text: &str) -> Result<()> {
+        self.text.clear();
+        self.text.push_str(new_text);
+        self.tree = self.parser.parse(&self.text, None);
+        Ok(())
+    }
+
+    pub fn text(&self) -> String {
+        self.text.clone()
+    }
+
+    pub fn tree(&self) -> Option<&Tree> {
+        self.tree.as_ref()
+    }
+
+    /// Convert a byte range (UTF-8) into an LSP Range (UTF-16 columns).
+    pub fn byte_range_to_lsp_range(&self, start: usize, end: usize) -> lsp::Range {
+        fn byte_to_line_col_utf16(s: &str, byte: usize) -> (u32, u32) {
+            let clamped = byte.min(s.len());
+            let slice = &s[..clamped];
+            let mut line = 0u32;
+            let mut col_u16 = 0u32;
+            let mut last_nl = 0usize;
+
+            for (i, b) in slice.bytes().enumerate() {
+                if b == b'\n' {
+                    line += 1;
+                    last_nl = i + 1;
+                }
+            }
+            // compute utf16 col from last newline to clamped
+            let seg = &slice[last_nl..];
+            col_u16 = seg.encode_utf16().count() as u32;
+            (line, col_u16)
+        }
+
+        let (sl, sc) = byte_to_line_col_utf16(&self.text, start);
+        let (el, ec) = byte_to_line_col_utf16(&self.text, end);
+        lsp::Range {
+            start: lsp::Position {
+                line: sl,
+                character: sc,
+            },
+            end: lsp::Position {
+                line: el,
+                character: ec,
+            },
+        }
+    }
+
+    /// Get the UTF-8 byte offset of the "word" under a UTF-16 position (very naive).
+    pub fn word_under_position(
+        &self,
+        pos: lsp::Position
+    ) -> Option<(String, std::ops::Range<usize>)> {
+        // Convert UTF-16 (LSP) position -> UTF-8 byte offset in self.text
+        fn line_col_utf16_to_byte(s: &str, line: u32, col_u16: u32) -> usize {
+            // Find start byte of the requested line
+            let mut cur_line: u32 = 0;
+            let mut line_start_byte: usize = 0;
+
+            if line == 0 {
+                line_start_byte = 0;
+            } else {
+                for (i, b) in s.bytes().enumerate() {
+                    if b == b'\n' {
+                        cur_line += 1;
+                        if cur_line == line {
+                            line_start_byte = i + 1;
+                            break;
+                        }
+                    }
+                }
+                // If line beyond EOF, clamp to end
+                if cur_line < line {
+                    return s.len();
+                }
+            }
+
+            // Advance by UTF-16 code units from line_start_byte
+            let mut remaining = col_u16 as isize;
+            let tail = &s[line_start_byte..];
+            for (off, ch) in tail.char_indices() {
+                if remaining <= 0 {
+                    return line_start_byte + off;
+                }
+                // subtract the number of UTF-16 code units this char occupies (1 for BMP, 2 for surrogates)
+                let mut buf = [0u16; 2];
+                remaining -= ch.encode_utf16(&mut buf).len() as isize;
+            }
+            // If column beyond EOL, clamp to end
+            s.len()
+        }
+
+        let bytes = self.text.as_bytes();
+        let byte = line_col_utf16_to_byte(&self.text, pos.line, pos.character);
+        if byte > self.text.len() {
+            return None;
+        }
+
+        // Expand to simple Tcl-ish identifier characters: letters/digits/_ : / . -
+        fn is_ident(c: u8) -> bool {
+            c.is_ascii_alphanumeric() || matches!(c, b'_' | b':' | b'/' | b'.' | b'-')
+        }
+
+        // Walk backward to start
+        let mut start = byte;
+        while start > 0 && is_ident(bytes[start - 1]) {
+            start -= 1;
+        }
+        // Walk forward to end
+        let mut end = byte;
+        while end < bytes.len() && is_ident(bytes[end]) {
+            end += 1;
+        }
+
+        if start >= end {
+            return None;
+        }
+
+        let text = self.text[start..end].to_string();
+        Some((text, start..end)) // <-- no semicolon here, this is the tail expression
+    }
+}
@@ -1,104 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Classes Without Boilerplate
-"""
-
-from functools import partial
-from typing import Callable, Literal, Protocol
-
-from . import converters, exceptions, filters, setters, validators
-from ._cmp import cmp_using
-from ._config import get_run_validators, set_run_validators
-from ._funcs import asdict, assoc, astuple, has, resolve_types
-from ._make import (
-    NOTHING,
-    Attribute,
-    Converter,
-    Factory,
-    _Nothing,
-    attrib,
-    attrs,
-    evolve,
-    fields,
-    fields_dict,
-    make_class,
-    validate,
-)
-from ._next_gen import define, field, frozen, mutable
-from ._version_info import VersionInfo
-
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
-
-
-class AttrsInstance(Protocol):
-    pass
-
-
-NothingType = Literal[_Nothing.NOTHING]
-
-__all__ = [
-    "NOTHING",
-    "Attribute",
-    "AttrsInstance",
-    "Converter",
-    "Factory",
-    "NothingType",
-    "asdict",
-    "assoc",
-    "astuple",
-    "attr",
-    "attrib",
-    "attributes",
-    "attrs",
-    "cmp_using",
-    "converters",
-    "define",
-    "evolve",
-    "exceptions",
-    "field",
-    "fields",
-    "fields_dict",
-    "filters",
-    "frozen",
-    "get_run_validators",
-    "has",
-    "ib",
-    "make_class",
-    "mutable",
-    "resolve_types",
-    "s",
-    "set_run_validators",
-    "setters",
-    "validate",
-    "validators",
-]
-
-
-def _make_getattr(mod_name: str) -> Callable:
-    """
-    Create a metadata proxy for packaging information that uses *mod_name* in
-    its warnings and errors.
-    """
-
-    def __getattr__(name: str) -> str:
-        if name not in ("__version__", "__version_info__"):
-            msg = f"module {mod_name} has no attribute {name}"
-            raise AttributeError(msg)
-
-        from importlib.metadata import metadata
-
-        meta = metadata("attrs")
-
-        if name == "__version_info__":
-            return VersionInfo._from_version_string(meta["version"])
-
-        return meta["version"]
-
-    return __getattr__
-
-
-__getattr__ = _make_getattr(__name__)
@@ -1,389 +0,0 @@
-import enum
-import sys
-
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Literal,
-    Mapping,
-    Protocol,
-    Sequence,
-    TypeVar,
-    overload,
-)
-
-# `import X as X` is required to make these public
-from . import converters as converters
-from . import exceptions as exceptions
-from . import filters as filters
-from . import setters as setters
-from . import validators as validators
-from ._cmp import cmp_using as cmp_using
-from ._typing_compat import AttrsInstance_
-from ._version_info import VersionInfo
-from attrs import (
-    define as define,
-    field as field,
-    mutable as mutable,
-    frozen as frozen,
-    _EqOrderType,
-    _ValidatorType,
-    _ConverterType,
-    _ReprArgType,
-    _OnSetAttrType,
-    _OnSetAttrArgType,
-    _FieldTransformer,
-    _ValidatorArgType,
-)
-
-if sys.version_info >= (3, 10):
-    from typing import TypeGuard, TypeAlias
-else:
-    from typing_extensions import TypeGuard, TypeAlias
-
-if sys.version_info >= (3, 11):
-    from typing import dataclass_transform
-else:
-    from typing_extensions import dataclass_transform
-
-__version__: str
-__version_info__: VersionInfo
-__title__: str
-__description__: str
-__url__: str
-__uri__: str
-__author__: str
-__email__: str
-__license__: str
-__copyright__: str
-
-_T = TypeVar("_T")
-_C = TypeVar("_C", bound=type)
-
-_FilterType = Callable[["Attribute[_T]", _T], bool]
-
-# We subclass this here to keep the protocol's qualified name clean.
-class AttrsInstance(AttrsInstance_, Protocol):
-    pass
-
-_A = TypeVar("_A", bound=type[AttrsInstance])
-
-class _Nothing(enum.Enum):
-    NOTHING = enum.auto()
-
-NOTHING = _Nothing.NOTHING
-NothingType: TypeAlias = Literal[_Nothing.NOTHING]
-
-# NOTE: Factory lies about its return type to make this possible:
-# `x: List[int] # = Factory(list)`
-# Work around mypy issue #4554 in the common case by using an overload.
-
-@overload
-def Factory(factory: Callable[[], _T]) -> _T: ...
-@overload
-def Factory(
-    factory: Callable[[Any], _T],
-    takes_self: Literal[True],
-) -> _T: ...
-@overload
-def Factory(
-    factory: Callable[[], _T],
-    takes_self: Literal[False],
-) -> _T: ...
-
-In = TypeVar("In")
-Out = TypeVar("Out")
-
-class Converter(Generic[In, Out]):
-    @overload
-    def __init__(self, converter: Callable[[In], Out]) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, AttrsInstance, Attribute], Out],
-        *,
-        takes_self: Literal[True],
-        takes_field: Literal[True],
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, Attribute], Out],
-        *,
-        takes_field: Literal[True],
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        converter: Callable[[In, AttrsInstance], Out],
-        *,
-        takes_self: Literal[True],
-    ) -> None: ...
-
-class Attribute(Generic[_T]):
-    name: str
-    default: _T | None
-    validator: _ValidatorType[_T] | None
-    repr: _ReprArgType
-    cmp: _EqOrderType
-    eq: _EqOrderType
-    order: _EqOrderType
-    hash: bool | None
-    init: bool
-    converter: Converter | None
-    metadata: dict[Any, Any]
-    type: type[_T] | None
-    kw_only: bool
-    on_setattr: _OnSetAttrType
-    alias: str | None
-
-    def evolve(self, **changes: Any) -> "Attribute[Any]": ...
-
-# NOTE: We had several choices for the annotation to use for type arg:
-# 1) Type[_T]
-#   - Pros: Handles simple cases correctly
-#   - Cons: Might produce less informative errors in the case of conflicting
-#     TypeVars e.g. `attr.ib(default='bad', type=int)`
-# 2) Callable[..., _T]
-#   - Pros: Better error messages than #1 for conflicting TypeVars
-#   - Cons: Terrible error messages for validator checks.
-#   e.g. attr.ib(type=int, validator=validate_str)
-#        -> error: Cannot infer function type argument
-# 3) type (and do all of the work in the mypy plugin)
-#   - Pros: Simple here, and we could customize the plugin with our own errors.
-#   - Cons: Would need to write mypy plugin code to handle all the cases.
-# We chose option #1.
-
-# `attr` lies about its return type to make the following possible:
-#     attr()    -> Any
-#     attr(8)   -> int
-#     attr(validator=<some callable>)  -> Whatever the callable expects.
-# This makes this type of assignments possible:
-#     x: int = attr(8)
-#
-# This form catches explicit None or no default but with no other arguments
-# returns Any.
-@overload
-def attrib(
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: None = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def attrib(
-    default: None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: type[_T] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def attrib(
-    default: _T,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: type[_T] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def attrib(
-    default: _T | None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    type: object = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-) -> Any: ...
-@overload
-@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
-def attrs(
-    maybe_cls: _C,
-    these: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-    unsafe_hash: bool | None = ...,
-) -> _C: ...
-@overload
-@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
-def attrs(
-    maybe_cls: None = ...,
-    these: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-    unsafe_hash: bool | None = ...,
-) -> Callable[[_C], _C]: ...
-def fields(cls: type[AttrsInstance] | AttrsInstance) -> Any: ...
-def fields_dict(cls: type[AttrsInstance]) -> dict[str, Attribute[Any]]: ...
-def validate(inst: AttrsInstance) -> None: ...
-def resolve_types(
-    cls: _A,
-    globalns: dict[str, Any] | None = ...,
-    localns: dict[str, Any] | None = ...,
-    attribs: list[Attribute[Any]] | None = ...,
-    include_extras: bool = ...,
-) -> _A: ...
-
-# TODO: add support for returning a proper attrs class from the mypy plugin
-# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
-# [attr.ib()])` is valid
-def make_class(
-    name: str,
-    attrs: list[str] | tuple[str, ...] | dict[str, Any],
-    bases: tuple[type, ...] = ...,
-    class_body: dict[str, Any] | None = ...,
-    repr_ns: str | None = ...,
-    repr: bool = ...,
-    cmp: _EqOrderType | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    collect_by_mro: bool = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-) -> type: ...
-
-# _funcs --
-
-# TODO: add support for returning TypedDict from the mypy plugin
-# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
-# these:
-# https://github.com/python/mypy/issues/4236
-# https://github.com/python/typing/issues/253
-# XXX: remember to fix attrs.asdict/astuple too!
-def asdict(
-    inst: AttrsInstance,
-    recurse: bool = ...,
-    filter: _FilterType[Any] | None = ...,
-    dict_factory: type[Mapping[Any, Any]] = ...,
-    retain_collection_types: bool = ...,
-    value_serializer: Callable[[type, Attribute[Any], Any], Any] | None = ...,
-    tuple_keys: bool | None = ...,
-) -> dict[str, Any]: ...
-
-# TODO: add support for returning NamedTuple from the mypy plugin
-def astuple(
-    inst: AttrsInstance,
-    recurse: bool = ...,
-    filter: _FilterType[Any] | None = ...,
-    tuple_factory: type[Sequence[Any]] = ...,
-    retain_collection_types: bool = ...,
-) -> tuple[Any, ...]: ...
-def has(cls: type) -> TypeGuard[type[AttrsInstance]]: ...
-def assoc(inst: _T, **changes: Any) -> _T: ...
-def evolve(inst: _T, **changes: Any) -> _T: ...
-
-# _config --
-
-def set_run_validators(run: bool) -> None: ...
-def get_run_validators() -> bool: ...
-
-# aliases --
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)
@@ -1,160 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-
-import functools
-import types
-
-from ._make import __ne__
-
-
-_operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}
-
-
-def cmp_using(
-    eq=None,
-    lt=None,
-    le=None,
-    gt=None,
-    ge=None,
-    require_same_type=True,
-    class_name="Comparable",
-):
-    """
-    Create a class that can be passed into `attrs.field`'s ``eq``, ``order``,
-    and ``cmp`` arguments to customize field comparison.
-
-    The resulting class will have a full set of ordering methods if at least
-    one of ``{lt, le, gt, ge}`` and ``eq``  are provided.
-
-    Args:
-        eq (typing.Callable | None):
-            Callable used to evaluate equality of two objects.
-
-        lt (typing.Callable | None):
-            Callable used to evaluate whether one object is less than another
-            object.
-
-        le (typing.Callable | None):
-            Callable used to evaluate whether one object is less than or equal
-            to another object.
-
-        gt (typing.Callable | None):
-            Callable used to evaluate whether one object is greater than
-            another object.
-
-        ge (typing.Callable | None):
-            Callable used to evaluate whether one object is greater than or
-            equal to another object.
-
-        require_same_type (bool):
-            When `True`, equality and ordering methods will return
-            `NotImplemented` if objects are not of the same type.
-
-        class_name (str | None): Name of class. Defaults to "Comparable".
-
-    See `comparison` for more details.
-
-    .. versionadded:: 21.1.0
-    """
-
-    body = {
-        "__slots__": ["value"],
-        "__init__": _make_init(),
-        "_requirements": [],
-        "_is_comparable_to": _is_comparable_to,
-    }
-
-    # Add operations.
-    num_order_functions = 0
-    has_eq_function = False
-
-    if eq is not None:
-        has_eq_function = True
-        body["__eq__"] = _make_operator("eq", eq)
-        body["__ne__"] = __ne__
-
-    if lt is not None:
-        num_order_functions += 1
-        body["__lt__"] = _make_operator("lt", lt)
-
-    if le is not None:
-        num_order_functions += 1
-        body["__le__"] = _make_operator("le", le)
-
-    if gt is not None:
-        num_order_functions += 1
-        body["__gt__"] = _make_operator("gt", gt)
-
-    if ge is not None:
-        num_order_functions += 1
-        body["__ge__"] = _make_operator("ge", ge)
-
-    type_ = types.new_class(
-        class_name, (object,), {}, lambda ns: ns.update(body)
-    )
-
-    # Add same type requirement.
-    if require_same_type:
-        type_._requirements.append(_check_same_type)
-
-    # Add total ordering if at least one operation was defined.
-    if 0 < num_order_functions < 4:
-        if not has_eq_function:
-            # functools.total_ordering requires __eq__ to be defined,
-            # so raise early error here to keep a nice stack.
-            msg = "eq must be define is order to complete ordering from lt, le, gt, ge."
-            raise ValueError(msg)
-        type_ = functools.total_ordering(type_)
-
-    return type_
-
-
-def _make_init():
-    """
-    Create __init__ method.
-    """
-
-    def __init__(self, value):
-        """
-        Initialize object with *value*.
-        """
-        self.value = value
-
-    return __init__
-
-
-def _make_operator(name, func):
-    """
-    Create operator method.
-    """
-
-    def method(self, other):
-        if not self._is_comparable_to(other):
-            return NotImplemented
-
-        result = func(self.value, other.value)
-        if result is NotImplemented:
-            return NotImplemented
-
-        return result
-
-    method.__name__ = f"__{name}__"
-    method.__doc__ = (
-        f"Return a {_operation_names[name]} b.  Computed by attrs."
-    )
-
-    return method
-
-
-def _is_comparable_to(self, other):
-    """
-    Check whether `other` is comparable to `self`.
-    """
-    return all(func(self, other) for func in self._requirements)
-
-
-def _check_same_type(self, other):
-    """
-    Return True if *self* and *other* are of the same type, False otherwise.
-    """
-    return other.value.__class__ is self.value.__class__
@@ -1,13 +0,0 @@
-from typing import Any, Callable
-
-_CompareWithType = Callable[[Any, Any], bool]
-
-def cmp_using(
-    eq: _CompareWithType | None = ...,
-    lt: _CompareWithType | None = ...,
-    le: _CompareWithType | None = ...,
-    gt: _CompareWithType | None = ...,
-    ge: _CompareWithType | None = ...,
-    require_same_type: bool = ...,
-    class_name: str = ...,
-) -> type: ...
@@ -1,99 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-import inspect
-import platform
-import sys
-import threading
-
-from collections.abc import Mapping, Sequence  # noqa: F401
-from typing import _GenericAlias
-
-
-PYPY = platform.python_implementation() == "PyPy"
-PY_3_10_PLUS = sys.version_info[:2] >= (3, 10)
-PY_3_11_PLUS = sys.version_info[:2] >= (3, 11)
-PY_3_12_PLUS = sys.version_info[:2] >= (3, 12)
-PY_3_13_PLUS = sys.version_info[:2] >= (3, 13)
-PY_3_14_PLUS = sys.version_info[:2] >= (3, 14)
-
-
-if PY_3_14_PLUS:
-    import annotationlib
-
-    # We request forward-ref annotations to not break in the presence of
-    # forward references.
-
-    def _get_annotations(cls):
-        return annotationlib.get_annotations(
-            cls, format=annotationlib.Format.FORWARDREF
-        )
-
-else:
-
-    def _get_annotations(cls):
-        """
-        Get annotations for *cls*.
-        """
-        return cls.__dict__.get("__annotations__", {})
-
-
-class _AnnotationExtractor:
-    """
-    Extract type annotations from a callable, returning None whenever there
-    is none.
-    """
-
-    __slots__ = ["sig"]
-
-    def __init__(self, callable):
-        try:
-            self.sig = inspect.signature(callable)
-        except (ValueError, TypeError):  # inspect failed
-            self.sig = None
-
-    def get_first_param_type(self):
-        """
-        Return the type annotation of the first argument if it's not empty.
-        """
-        if not self.sig:
-            return None
-
-        params = list(self.sig.parameters.values())
-        if params and params[0].annotation is not inspect.Parameter.empty:
-            return params[0].annotation
-
-        return None
-
-    def get_return_type(self):
-        """
-        Return the return type if it's not empty.
-        """
-        if (
-            self.sig
-            and self.sig.return_annotation is not inspect.Signature.empty
-        ):
-            return self.sig.return_annotation
-
-        return None
-
-
-# Thread-local global to track attrs instances which are already being repr'd.
-# This is needed because there is no other (thread-safe) way to pass info
-# about the instances that are already being repr'd through the call stack
-# in order to ensure we don't perform infinite recursion.
-#
-# For instance, if an instance contains a dict which contains that instance,
-# we need to know that we're already repr'ing the outside instance from within
-# the dict's repr() call.
-#
-# This lives here rather than in _make.py so that the functions in _make.py
-# don't have a direct reference to the thread-local in their globals dict.
-# If they have such a reference, it breaks cloudpickle.
-repr_context = threading.local()
-
-
-def get_generic_base(cl):
-    """If this is a generic class (A[str]), return the generic base for it."""
-    if cl.__class__ is _GenericAlias:
-        return cl.__origin__
-    return None
@@ -1,31 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-__all__ = ["get_run_validators", "set_run_validators"]
-
-_run_validators = True
-
-
-def set_run_validators(run):
-    """
-    Set whether or not validators are run.  By default, they are run.
-
-    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
-        moved to new ``attrs`` namespace. Use `attrs.validators.set_disabled()`
-        instead.
-    """
-    if not isinstance(run, bool):
-        msg = "'run' must be bool."
-        raise TypeError(msg)
-    global _run_validators
-    _run_validators = run
-
-
-def get_run_validators():
-    """
-    Return whether or not validators are run.
-
-    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
-        moved to new ``attrs`` namespace. Use `attrs.validators.get_disabled()`
-        instead.
-    """
-    return _run_validators
@@ -1,497 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-
-import copy
-
-from ._compat import get_generic_base
-from ._make import _OBJ_SETATTR, NOTHING, fields
-from .exceptions import AttrsAttributeNotFoundError
-
-
-_ATOMIC_TYPES = frozenset(
-    {
-        type(None),
-        bool,
-        int,
-        float,
-        str,
-        complex,
-        bytes,
-        type(...),
-        type,
-        range,
-        property,
-    }
-)
-
-
-def asdict(
-    inst,
-    recurse=True,
-    filter=None,
-    dict_factory=dict,
-    retain_collection_types=False,
-    value_serializer=None,
-):
-    """
-    Return the *attrs* attribute values of *inst* as a dict.
-
-    Optionally recurse into other *attrs*-decorated classes.
-
-    Args:
-        inst: Instance of an *attrs*-decorated class.
-
-        recurse (bool): Recurse into classes that are also *attrs*-decorated.
-
-        filter (~typing.Callable):
-            A callable whose return code determines whether an attribute or
-            element is included (`True`) or dropped (`False`).  Is called with
-            the `attrs.Attribute` as the first argument and the value as the
-            second argument.
-
-        dict_factory (~typing.Callable):
-            A callable to produce dictionaries from.  For example, to produce
-            ordered dictionaries instead of normal Python dictionaries, pass in
-            ``collections.OrderedDict``.
-
-        retain_collection_types (bool):
-            Do not convert to `list` when encountering an attribute whose type
-            is `tuple` or `set`.  Only meaningful if *recurse* is `True`.
-
-        value_serializer (typing.Callable | None):
-            A hook that is called for every attribute or dict key/value.  It
-            receives the current instance, field and value and must return the
-            (updated) value.  The hook is run *after* the optional *filter* has
-            been applied.
-
-    Returns:
-        Return type of *dict_factory*.
-
-    Raises:
-        attrs.exceptions.NotAnAttrsClassError:
-            If *cls* is not an *attrs* class.
-
-    ..  versionadded:: 16.0.0 *dict_factory*
-    ..  versionadded:: 16.1.0 *retain_collection_types*
-    ..  versionadded:: 20.3.0 *value_serializer*
-    ..  versionadded:: 21.3.0
-        If a dict has a collection for a key, it is serialized as a tuple.
-    """
-    attrs = fields(inst.__class__)
-    rv = dict_factory()
-    for a in attrs:
-        v = getattr(inst, a.name)
-        if filter is not None and not filter(a, v):
-            continue
-
-        if value_serializer is not None:
-            v = value_serializer(inst, a, v)
-
-        if recurse is True:
-            value_type = type(v)
-            if value_type in _ATOMIC_TYPES:
-                rv[a.name] = v
-            elif has(value_type):
-                rv[a.name] = asdict(
-                    v,
-                    recurse=True,
-                    filter=filter,
-                    dict_factory=dict_factory,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                )
-            elif issubclass(value_type, (tuple, list, set, frozenset)):
-                cf = value_type if retain_collection_types is True else list
-                items = [
-                    _asdict_anything(
-                        i,
-                        is_key=False,
-                        filter=filter,
-                        dict_factory=dict_factory,
-                        retain_collection_types=retain_collection_types,
-                        value_serializer=value_serializer,
-                    )
-                    for i in v
-                ]
-                try:
-                    rv[a.name] = cf(items)
-                except TypeError:
-                    if not issubclass(cf, tuple):
-                        raise
-                    # Workaround for TypeError: cf.__new__() missing 1 required
-                    # positional argument (which appears, for a namedturle)
-                    rv[a.name] = cf(*items)
-            elif issubclass(value_type, dict):
-                df = dict_factory
-                rv[a.name] = df(
-                    (
-                        _asdict_anything(
-                            kk,
-                            is_key=True,
-                            filter=filter,
-                            dict_factory=df,
-                            retain_collection_types=retain_collection_types,
-                            value_serializer=value_serializer,
-                        ),
-                        _asdict_anything(
-                            vv,
-                            is_key=False,
-                            filter=filter,
-                            dict_factory=df,
-                            retain_collection_types=retain_collection_types,
-                            value_serializer=value_serializer,
-                        ),
-                    )
-                    for kk, vv in v.items()
-                )
-            else:
-                rv[a.name] = v
-        else:
-            rv[a.name] = v
-    return rv
-
-
-def _asdict_anything(
-    val,
-    is_key,
-    filter,
-    dict_factory,
-    retain_collection_types,
-    value_serializer,
-):
-    """
-    ``asdict`` only works on attrs instances, this works on anything.
-    """
-    val_type = type(val)
-    if val_type in _ATOMIC_TYPES:
-        rv = val
-        if value_serializer is not None:
-            rv = value_serializer(None, None, rv)
-    elif getattr(val_type, "__attrs_attrs__", None) is not None:
-        # Attrs class.
-        rv = asdict(
-            val,
-            recurse=True,
-            filter=filter,
-            dict_factory=dict_factory,
-            retain_collection_types=retain_collection_types,
-            value_serializer=value_serializer,
-        )
-    elif issubclass(val_type, (tuple, list, set, frozenset)):
-        if retain_collection_types is True:
-            cf = val.__class__
-        elif is_key:
-            cf = tuple
-        else:
-            cf = list
-
-        rv = cf(
-            [
-                _asdict_anything(
-                    i,
-                    is_key=False,
-                    filter=filter,
-                    dict_factory=dict_factory,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                )
-                for i in val
-            ]
-        )
-    elif issubclass(val_type, dict):
-        df = dict_factory
-        rv = df(
-            (
-                _asdict_anything(
-                    kk,
-                    is_key=True,
-                    filter=filter,
-                    dict_factory=df,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                ),
-                _asdict_anything(
-                    vv,
-                    is_key=False,
-                    filter=filter,
-                    dict_factory=df,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                ),
-            )
-            for kk, vv in val.items()
-        )
-    else:
-        rv = val
-        if value_serializer is not None:
-            rv = value_serializer(None, None, rv)
-
-    return rv
-
-
-def astuple(
-    inst,
-    recurse=True,
-    filter=None,
-    tuple_factory=tuple,
-    retain_collection_types=False,
-):
-    """
-    Return the *attrs* attribute values of *inst* as a tuple.
-
-    Optionally recurse into other *attrs*-decorated classes.
-
-    Args:
-        inst: Instance of an *attrs*-decorated class.
-
-        recurse (bool):
-            Recurse into classes that are also *attrs*-decorated.
-
-        filter (~typing.Callable):
-            A callable whose return code determines whether an attribute or
-            element is included (`True`) or dropped (`False`).  Is called with
-            the `attrs.Attribute` as the first argument and the value as the
-            second argument.
-
-        tuple_factory (~typing.Callable):
-            A callable to produce tuples from. For example, to produce lists
-            instead of tuples.
-
-        retain_collection_types (bool):
-            Do not convert to `list` or `dict` when encountering an attribute
-            which type is `tuple`, `dict` or `set`. Only meaningful if
-            *recurse* is `True`.
-
-    Returns:
-        Return type of *tuple_factory*
-
-    Raises:
-        attrs.exceptions.NotAnAttrsClassError:
-            If *cls* is not an *attrs* class.
-
-    ..  versionadded:: 16.2.0
-    """
-    attrs = fields(inst.__class__)
-    rv = []
-    retain = retain_collection_types  # Very long. :/
-    for a in attrs:
-        v = getattr(inst, a.name)
-        if filter is not None and not filter(a, v):
-            continue
-        value_type = type(v)
-        if recurse is True:
-            if value_type in _ATOMIC_TYPES:
-                rv.append(v)
-            elif has(value_type):
-                rv.append(
-                    astuple(
-                        v,
-                        recurse=True,
-                        filter=filter,
-                        tuple_factory=tuple_factory,
-                        retain_collection_types=retain,
-                    )
-                )
-            elif issubclass(value_type, (tuple, list, set, frozenset)):
-                cf = v.__class__ if retain is True else list
-                items = [
-                    (
-                        astuple(
-                            j,
-                            recurse=True,
-                            filter=filter,
-                            tuple_factory=tuple_factory,
-                            retain_collection_types=retain,
-                        )
-                        if has(j.__class__)
-                        else j
-                    )
-                    for j in v
-                ]
-                try:
-                    rv.append(cf(items))
-                except TypeError:
-                    if not issubclass(cf, tuple):
-                        raise
-                    # Workaround for TypeError: cf.__new__() missing 1 required
-                    # positional argument (which appears, for a namedturle)
-                    rv.append(cf(*items))
-            elif issubclass(value_type, dict):
-                df = value_type if retain is True else dict
-                rv.append(
-                    df(
-                        (
-                            (
-                                astuple(
-                                    kk,
-                                    tuple_factory=tuple_factory,
-                                    retain_collection_types=retain,
-                                )
-                                if has(kk.__class__)
-                                else kk
-                            ),
-                            (
-                                astuple(
-                                    vv,
-                                    tuple_factory=tuple_factory,
-                                    retain_collection_types=retain,
-                                )
-                                if has(vv.__class__)
-                                else vv
-                            ),
-                        )
-                        for kk, vv in v.items()
-                    )
-                )
-            else:
-                rv.append(v)
-        else:
-            rv.append(v)
-
-    return rv if tuple_factory is list else tuple_factory(rv)
-
-
-def has(cls):
-    """
-    Check whether *cls* is a class with *attrs* attributes.
-
-    Args:
-        cls (type): Class to introspect.
-
-    Raises:
-        TypeError: If *cls* is not a class.
-
-    Returns:
-        bool:
-    """
-    attrs = getattr(cls, "__attrs_attrs__", None)
-    if attrs is not None:
-        return True
-
-    # No attrs, maybe it's a specialized generic (A[str])?
-    generic_base = get_generic_base(cls)
-    if generic_base is not None:
-        generic_attrs = getattr(generic_base, "__attrs_attrs__", None)
-        if generic_attrs is not None:
-            # Stick it on here for speed next time.
-            cls.__attrs_attrs__ = generic_attrs
-        return generic_attrs is not None
-    return False
-
-
-def assoc(inst, **changes):
-    """
-    Copy *inst* and apply *changes*.
-
-    This is different from `evolve` that applies the changes to the arguments
-    that create the new instance.
-
-    `evolve`'s behavior is preferable, but there are `edge cases`_ where it
-    doesn't work. Therefore `assoc` is deprecated, but will not be removed.
-
-    .. _`edge cases`: https://github.com/python-attrs/attrs/issues/251
-
-    Args:
-        inst: Instance of a class with *attrs* attributes.
-
-        changes: Keyword changes in the new copy.
-
-    Returns:
-        A copy of inst with *changes* incorporated.
-
-    Raises:
-        attrs.exceptions.AttrsAttributeNotFoundError:
-            If *attr_name* couldn't be found on *cls*.
-
-        attrs.exceptions.NotAnAttrsClassError:
-            If *cls* is not an *attrs* class.
-
-    ..  deprecated:: 17.1.0
-        Use `attrs.evolve` instead if you can. This function will not be
-        removed du to the slightly different approach compared to
-        `attrs.evolve`, though.
-    """
-    new = copy.copy(inst)
-    attrs = fields(inst.__class__)
-    for k, v in changes.items():
-        a = getattr(attrs, k, NOTHING)
-        if a is NOTHING:
-            msg = f"{k} is not an attrs attribute on {new.__class__}."
-            raise AttrsAttributeNotFoundError(msg)
-        _OBJ_SETATTR(new, k, v)
-    return new
-
-
-def resolve_types(
-    cls, globalns=None, localns=None, attribs=None, include_extras=True
-):
-    """
-    Resolve any strings and forward annotations in type annotations.
-
-    This is only required if you need concrete types in :class:`Attribute`'s
-    *type* field. In other words, you don't need to resolve your types if you
-    only use them for static type checking.
-
-    With no arguments, names will be looked up in the module in which the class
-    was created. If this is not what you want, for example, if the name only
-    exists inside a method, you may pass *globalns* or *localns* to specify
-    other dictionaries in which to look up these names. See the docs of
-    `typing.get_type_hints` for more details.
-
-    Args:
-        cls (type): Class to resolve.
-
-        globalns (dict | None): Dictionary containing global variables.
-
-        localns (dict | None): Dictionary containing local variables.
-
-        attribs (list | None):
-            List of attribs for the given class. This is necessary when calling
-            from inside a ``field_transformer`` since *cls* is not an *attrs*
-            class yet.
-
-        include_extras (bool):
-            Resolve more accurately, if possible. Pass ``include_extras`` to
-            ``typing.get_hints``, if supported by the typing module. On
-            supported Python versions (3.9+), this resolves the types more
-            accurately.
-
-    Raises:
-        TypeError: If *cls* is not a class.
-
-        attrs.exceptions.NotAnAttrsClassError:
-            If *cls* is not an *attrs* class and you didn't pass any attribs.
-
-        NameError: If types cannot be resolved because of missing variables.
-
-    Returns:
-        *cls* so you can use this function also as a class decorator. Please
-        note that you have to apply it **after** `attrs.define`. That means the
-        decorator has to come in the line **before** `attrs.define`.
-
-    ..  versionadded:: 20.1.0
-    ..  versionadded:: 21.1.0 *attribs*
-    ..  versionadded:: 23.1.0 *include_extras*
-    """
-    # Since calling get_type_hints is expensive we cache whether we've
-    # done it already.
-    if getattr(cls, "__attrs_types_resolved__", None) != cls:
-        import typing
-
-        kwargs = {
-            "globalns": globalns,
-            "localns": localns,
-            "include_extras": include_extras,
-        }
-
-        hints = typing.get_type_hints(cls, **kwargs)
-        for field in fields(cls) if attribs is None else attribs:
-            if field.name in hints:
-                # Since fields have been frozen we must work around it.
-                _OBJ_SETATTR(field, "type", hints[field.name])
-        # We store the class we resolved so that subclasses know they haven't
-        # been resolved.
-        cls.__attrs_types_resolved__ = cls
-
-    # Return the class so you can use it as a decorator too.
-    return cls
@@ -1,674 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-These are keyword-only APIs that call `attr.s` and `attr.ib` with different
-default values.
-"""
-
-from functools import partial
-
-from . import setters
-from ._funcs import asdict as _asdict
-from ._funcs import astuple as _astuple
-from ._make import (
-    _DEFAULT_ON_SETATTR,
-    NOTHING,
-    _frozen_setattrs,
-    attrib,
-    attrs,
-)
-from .exceptions import NotAnAttrsClassError, UnannotatedAttributeError
-
-
-def define(
-    maybe_cls=None,
-    *,
-    these=None,
-    repr=None,
-    unsafe_hash=None,
-    hash=None,
-    init=None,
-    slots=True,
-    frozen=False,
-    weakref_slot=True,
-    str=False,
-    auto_attribs=None,
-    kw_only=False,
-    cache_hash=False,
-    auto_exc=True,
-    eq=None,
-    order=False,
-    auto_detect=True,
-    getstate_setstate=None,
-    on_setattr=None,
-    field_transformer=None,
-    match_args=True,
-    force_kw_only=False,
-):
-    r"""
-    A class decorator that adds :term:`dunder methods` according to
-    :term:`fields <field>` specified using :doc:`type annotations <types>`,
-    `field()` calls, or the *these* argument.
-
-    Since *attrs* patches or replaces an existing class, you cannot use
-    `object.__init_subclass__` with *attrs* classes, because it runs too early.
-    As a replacement, you can define ``__attrs_init_subclass__`` on your class.
-    It will be called by *attrs* classes that subclass it after they're
-    created. See also :ref:`init-subclass`.
-
-    Args:
-        slots (bool):
-            Create a :term:`slotted class <slotted classes>` that's more
-            memory-efficient. Slotted classes are generally superior to the
-            default dict classes, but have some gotchas you should know about,
-            so we encourage you to read the :term:`glossary entry <slotted
-            classes>`.
-
-        auto_detect (bool):
-            Instead of setting the *init*, *repr*, *eq*, and *hash* arguments
-            explicitly, assume they are set to True **unless any** of the
-            involved methods for one of the arguments is implemented in the
-            *current* class (meaning, it is *not* inherited from some base
-            class).
-
-            So, for example by implementing ``__eq__`` on a class yourself,
-            *attrs* will deduce ``eq=False`` and will create *neither*
-            ``__eq__`` *nor* ``__ne__`` (but Python classes come with a
-            sensible ``__ne__`` by default, so it *should* be enough to only
-            implement ``__eq__`` in most cases).
-
-            Passing :data:`True` or :data:`False` to *init*, *repr*, *eq*, or *hash*
-            overrides whatever *auto_detect* would determine.
-
-        auto_exc (bool):
-            If the class subclasses `BaseException` (which implicitly includes
-            any subclass of any exception), the following happens to behave
-            like a well-behaved Python exception class:
-
-            - the values for *eq*, *order*, and *hash* are ignored and the
-              instances compare and hash by the instance's ids [#]_ ,
-            - all attributes that are either passed into ``__init__`` or have a
-              default value are additionally available as a tuple in the
-              ``args`` attribute,
-            - the value of *str* is ignored leaving ``__str__`` to base
-              classes.
-
-            .. [#]
-               Note that *attrs* will *not* remove existing implementations of
-               ``__hash__`` or the equality methods. It just won't add own
-               ones.
-
-        on_setattr (~typing.Callable | list[~typing.Callable] | None | ~typing.Literal[attrs.setters.NO_OP]):
-            A callable that is run whenever the user attempts to set an
-            attribute (either by assignment like ``i.x = 42`` or by using
-            `setattr` like ``setattr(i, "x", 42)``). It receives the same
-            arguments as validators: the instance, the attribute that is being
-            modified, and the new value.
-
-            If no exception is raised, the attribute is set to the return value
-            of the callable.
-
-            If a list of callables is passed, they're automatically wrapped in
-            an `attrs.setters.pipe`.
-
-            If left None, the default behavior is to run converters and
-            validators whenever an attribute is set.
-
-        init (bool):
-            Create a ``__init__`` method that initializes the *attrs*
-            attributes. Leading underscores are stripped for the argument name,
-            unless an alias is set on the attribute.
-
-            .. seealso::
-                `init` shows advanced ways to customize the generated
-                ``__init__`` method, including executing code before and after.
-
-        repr(bool):
-            Create a ``__repr__`` method with a human readable representation
-            of *attrs* attributes.
-
-        str (bool):
-            Create a ``__str__`` method that is identical to ``__repr__``. This
-            is usually not necessary except for `Exception`\ s.
-
-        eq (bool | None):
-            If True or None (default), add ``__eq__`` and ``__ne__`` methods
-            that check two instances for equality.
-
-            .. seealso::
-                `comparison` describes how to customize the comparison behavior
-                going as far comparing NumPy arrays.
-
-        order (bool | None):
-            If True, add ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__``
-            methods that behave like *eq* above and allow instances to be
-            ordered.
-
-            They compare the instances as if they were tuples of their *attrs*
-            attributes if and only if the types of both classes are
-            *identical*.
-
-            If `None` mirror value of *eq*.
-
-            .. seealso:: `comparison`
-
-        unsafe_hash (bool | None):
-            If None (default), the ``__hash__`` method is generated according
-            how *eq* and *frozen* are set.
-
-            1. If *both* are True, *attrs* will generate a ``__hash__`` for
-               you.
-            2. If *eq* is True and *frozen* is False, ``__hash__`` will be set
-               to None, marking it unhashable (which it is).
-            3. If *eq* is False, ``__hash__`` will be left untouched meaning
-               the ``__hash__`` method of the base class will be used. If the
-               base class is `object`, this means it will fall back to id-based
-               hashing.
-
-            Although not recommended, you can decide for yourself and force
-            *attrs* to create one (for example, if the class is immutable even
-            though you didn't freeze it programmatically) by passing True or
-            not.  Both of these cases are rather special and should be used
-            carefully.
-
-            .. seealso::
-
-                - Our documentation on `hashing`,
-                - Python's documentation on `object.__hash__`,
-                - and the `GitHub issue that led to the default \ behavior
-                  <https://github.com/python-attrs/attrs/issues/136>`_ for more
-                  details.
-
-        hash (bool | None):
-            Deprecated alias for *unsafe_hash*. *unsafe_hash* takes precedence.
-
-        cache_hash (bool):
-            Ensure that the object's hash code is computed only once and stored
-            on the object.  If this is set to True, hashing must be either
-            explicitly or implicitly enabled for this class.  If the hash code
-            is cached, avoid any reassignments of fields involved in hash code
-            computation or mutations of the objects those fields point to after
-            object creation.  If such changes occur, the behavior of the
-            object's hash code is undefined.
-
-        frozen (bool):
-            Make instances immutable after initialization.  If someone attempts
-            to modify a frozen instance, `attrs.exceptions.FrozenInstanceError`
-            is raised.
-
-            .. note::
-
-                1. This is achieved by installing a custom ``__setattr__``
-                   method on your class, so you can't implement your own.
-
-                2. True immutability is impossible in Python.
-
-                3. This *does* have a minor a runtime performance `impact
-                   <how-frozen>` when initializing new instances.  In other
-                   words: ``__init__`` is slightly slower with ``frozen=True``.
-
-                4. If a class is frozen, you cannot modify ``self`` in
-                   ``__attrs_post_init__`` or a self-written ``__init__``. You
-                   can circumvent that limitation by using
-                   ``object.__setattr__(self, "attribute_name", value)``.
-
-                5. Subclasses of a frozen class are frozen too.
-
-        kw_only (bool):
-            Make attributes keyword-only in the generated ``__init__`` (if
-            *init* is False, this parameter is ignored).  Attributes that
-            explicitly set ``kw_only=False`` are not affected; base class
-            attributes are also not affected.
-
-            Also see *force_kw_only*.
-
-        weakref_slot (bool):
-            Make instances weak-referenceable.  This has no effect unless
-            *slots* is True.
-
-        field_transformer (~typing.Callable | None):
-            A function that is called with the original class object and all
-            fields right before *attrs* finalizes the class.  You can use this,
-            for example, to automatically add converters or validators to
-            fields based on their types.
-
-            .. seealso:: `transform-fields`
-
-        match_args (bool):
-            If True (default), set ``__match_args__`` on the class to support
-            :pep:`634` (*Structural Pattern Matching*). It is a tuple of all
-            non-keyword-only ``__init__`` parameter names on Python 3.10 and
-            later. Ignored on older Python versions.
-
-        collect_by_mro (bool):
-            If True, *attrs* collects attributes from base classes correctly
-            according to the `method resolution order
-            <https://docs.python.org/3/howto/mro.html>`_. If False, *attrs*
-            will mimic the (wrong) behavior of `dataclasses` and :pep:`681`.
-
-            See also `issue #428
-            <https://github.com/python-attrs/attrs/issues/428>`_.
-
-        force_kw_only (bool):
-            A back-compat flag for restoring pre-25.4.0 behavior.  If True and
-            ``kw_only=True``, all attributes are made keyword-only, including
-            base class attributes, and those set to ``kw_only=False`` at the
-            attribute level.  Defaults to False.
-
-            See also `issue #980
-            <https://github.com/python-attrs/attrs/issues/980>`_.
-
-        getstate_setstate (bool | None):
-            .. note::
-
-                This is usually only interesting for slotted classes and you
-                should probably just set *auto_detect* to True.
-
-            If True, ``__getstate__`` and ``__setstate__`` are generated and
-            attached to the class. This is necessary for slotted classes to be
-            pickleable. If left None, it's True by default for slotted classes
-            and False for dict classes.
-
-            If *auto_detect* is True, and *getstate_setstate* is left None, and
-            **either** ``__getstate__`` or ``__setstate__`` is detected
-            directly on the class (meaning: not inherited), it is set to False
-            (this is usually what you want).
-
-        auto_attribs (bool | None):
-            If True, look at type annotations to determine which attributes to
-            use, like `dataclasses`. If False, it will only look for explicit
-            :func:`field` class attributes, like classic *attrs*.
-
-            If left None, it will guess:
-
-            1. If any attributes are annotated and no unannotated
-               `attrs.field`\ s are found, it assumes *auto_attribs=True*.
-            2. Otherwise it assumes *auto_attribs=False* and tries to collect
-               `attrs.field`\ s.
-
-            If *attrs* decides to look at type annotations, **all** fields
-            **must** be annotated. If *attrs* encounters a field that is set to
-            a :func:`field` / `attr.ib` but lacks a type annotation, an
-            `attrs.exceptions.UnannotatedAttributeError` is raised.  Use
-            ``field_name: typing.Any = field(...)`` if you don't want to set a
-            type.
-
-            .. warning::
-
-                For features that use the attribute name to create decorators
-                (for example, :ref:`validators <validators>`), you still *must*
-                assign :func:`field` / `attr.ib` to them. Otherwise Python will
-                either not find the name or try to use the default value to
-                call, for example, ``validator`` on it.
-
-            Attributes annotated as `typing.ClassVar`, and attributes that are
-            neither annotated nor set to an `field()` are **ignored**.
-
-        these (dict[str, object]):
-            A dictionary of name to the (private) return value of `field()`
-            mappings. This is useful to avoid the definition of your attributes
-            within the class body because you can't (for example, if you want
-            to add ``__repr__`` methods to Django models) or don't want to.
-
-            If *these* is not `None`, *attrs* will *not* search the class body
-            for attributes and will *not* remove any attributes from it.
-
-            The order is deduced from the order of the attributes inside
-            *these*.
-
-            Arguably, this is a rather obscure feature.
-
-    .. versionadded:: 20.1.0
-    .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``.
-    .. versionadded:: 22.2.0
-       *unsafe_hash* as an alias for *hash* (for :pep:`681` compliance).
-    .. versionchanged:: 24.1.0
-       Instances are not compared as tuples of attributes anymore, but using a
-       big ``and`` condition. This is faster and has more correct behavior for
-       uncomparable values like `math.nan`.
-    .. versionadded:: 24.1.0
-       If a class has an *inherited* classmethod called
-       ``__attrs_init_subclass__``, it is executed after the class is created.
-    .. deprecated:: 24.1.0 *hash* is deprecated in favor of *unsafe_hash*.
-    .. versionadded:: 24.3.0
-       Unless already present, a ``__replace__`` method is automatically
-       created for `copy.replace` (Python 3.13+ only).
-    .. versionchanged:: 25.4.0
-       *kw_only* now only applies to attributes defined in the current class,
-       and respects attribute-level ``kw_only=False`` settings.
-    .. versionadded:: 25.4.0
-       Added *force_kw_only* to go back to the previous *kw_only* behavior.
-
-    .. note::
-
-        The main differences to the classic `attr.s` are:
-
-        - Automatically detect whether or not *auto_attribs* should be `True`
-          (c.f. *auto_attribs* parameter).
-        - Converters and validators run when attributes are set by default --
-          if *frozen* is `False`.
-        - *slots=True*
-
-          Usually, this has only upsides and few visible effects in everyday
-          programming. But it *can* lead to some surprising behaviors, so
-          please make sure to read :term:`slotted classes`.
-
-        - *auto_exc=True*
-        - *auto_detect=True*
-        - *order=False*
-        - *force_kw_only=False*
-        - Some options that were only relevant on Python 2 or were kept around
-          for backwards-compatibility have been removed.
-
-    """
-
-    def do_it(cls, auto_attribs):
-        return attrs(
-            maybe_cls=cls,
-            these=these,
-            repr=repr,
-            hash=hash,
-            unsafe_hash=unsafe_hash,
-            init=init,
-            slots=slots,
-            frozen=frozen,
-            weakref_slot=weakref_slot,
-            str=str,
-            auto_attribs=auto_attribs,
-            kw_only=kw_only,
-            cache_hash=cache_hash,
-            auto_exc=auto_exc,
-            eq=eq,
-            order=order,
-            auto_detect=auto_detect,
-            collect_by_mro=True,
-            getstate_setstate=getstate_setstate,
-            on_setattr=on_setattr,
-            field_transformer=field_transformer,
-            match_args=match_args,
-            force_kw_only=force_kw_only,
-        )
-
-    def wrap(cls):
-        """
-        Making this a wrapper ensures this code runs during class creation.
-
-        We also ensure that frozen-ness of classes is inherited.
-        """
-        nonlocal frozen, on_setattr
-
-        had_on_setattr = on_setattr not in (None, setters.NO_OP)
-
-        # By default, mutable classes convert & validate on setattr.
-        if frozen is False and on_setattr is None:
-            on_setattr = _DEFAULT_ON_SETATTR
-
-        # However, if we subclass a frozen class, we inherit the immutability
-        # and disable on_setattr.
-        for base_cls in cls.__bases__:
-            if base_cls.__setattr__ is _frozen_setattrs:
-                if had_on_setattr:
-                    msg = "Frozen classes can't use on_setattr (frozen-ness was inherited)."
-                    raise ValueError(msg)
-
-                on_setattr = setters.NO_OP
-                break
-
-        if auto_attribs is not None:
-            return do_it(cls, auto_attribs)
-
-        try:
-            return do_it(cls, True)
-        except UnannotatedAttributeError:
-            return do_it(cls, False)
-
-    # maybe_cls's type depends on the usage of the decorator.  It's a class
-    # if it's used as `@attrs` but `None` if used as `@attrs()`.
-    if maybe_cls is None:
-        return wrap
-
-    return wrap(maybe_cls)
-
-
-mutable = define
-frozen = partial(define, frozen=True, on_setattr=None)
-
-
-def field(
-    *,
-    default=NOTHING,
-    validator=None,
-    repr=True,
-    hash=None,
-    init=True,
-    metadata=None,
-    type=None,
-    converter=None,
-    factory=None,
-    kw_only=None,
-    eq=None,
-    order=None,
-    on_setattr=None,
-    alias=None,
-):
-    """
-    Create a new :term:`field` / :term:`attribute` on a class.
-
-    ..  warning::
-
-        Does **nothing** unless the class is also decorated with
-        `attrs.define` (or similar)!
-
-    Args:
-        default:
-            A value that is used if an *attrs*-generated ``__init__`` is used
-            and no value is passed while instantiating or the attribute is
-            excluded using ``init=False``.
-
-            If the value is an instance of `attrs.Factory`, its callable will
-            be used to construct a new value (useful for mutable data types
-            like lists or dicts).
-
-            If a default is not set (or set manually to `attrs.NOTHING`), a
-            value *must* be supplied when instantiating; otherwise a
-            `TypeError` will be raised.
-
-            .. seealso:: `defaults`
-
-        factory (~typing.Callable):
-            Syntactic sugar for ``default=attr.Factory(factory)``.
-
-        validator (~typing.Callable | list[~typing.Callable]):
-            Callable that is called by *attrs*-generated ``__init__`` methods
-            after the instance has been initialized.  They receive the
-            initialized instance, the :func:`~attrs.Attribute`, and the passed
-            value.
-
-            The return value is *not* inspected so the validator has to throw
-            an exception itself.
-
-            If a `list` is passed, its items are treated as validators and must
-            all pass.
-
-            Validators can be globally disabled and re-enabled using
-            `attrs.validators.get_disabled` / `attrs.validators.set_disabled`.
-
-            The validator can also be set using decorator notation as shown
-            below.
-
-            .. seealso:: :ref:`validators`
-
-        repr (bool | ~typing.Callable):
-            Include this attribute in the generated ``__repr__`` method. If
-            True, include the attribute; if False, omit it. By default, the
-            built-in ``repr()`` function is used. To override how the attribute
-            value is formatted, pass a ``callable`` that takes a single value
-            and returns a string. Note that the resulting string is used as-is,
-            which means it will be used directly *instead* of calling
-            ``repr()`` (the default).
-
-        eq (bool | ~typing.Callable):
-            If True (default), include this attribute in the generated
-            ``__eq__`` and ``__ne__`` methods that check two instances for
-            equality. To override how the attribute value is compared, pass a
-            callable that takes a single value and returns the value to be
-            compared.
-
-            .. seealso:: `comparison`
-
-        order (bool | ~typing.Callable):
-            If True (default), include this attributes in the generated
-            ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods. To
-            override how the attribute value is ordered, pass a callable that
-            takes a single value and returns the value to be ordered.
-
-            .. seealso:: `comparison`
-
-        hash (bool | None):
-            Include this attribute in the generated ``__hash__`` method.  If
-            None (default), mirror *eq*'s value.  This is the correct behavior
-            according the Python spec.  Setting this value to anything else
-            than None is *discouraged*.
-
-            .. seealso:: `hashing`
-
-        init (bool):
-            Include this attribute in the generated ``__init__`` method.
-
-            It is possible to set this to False and set a default value. In
-            that case this attributed is unconditionally initialized with the
-            specified default value or factory.
-
-            .. seealso:: `init`
-
-        converter (typing.Callable | Converter):
-            A callable that is called by *attrs*-generated ``__init__`` methods
-            to convert attribute's value to the desired format.
-
-            If a vanilla callable is passed, it is given the passed-in value as
-            the only positional argument. It is possible to receive additional
-            arguments by wrapping the callable in a `Converter`.
-
-            Either way, the returned value will be used as the new value of the
-            attribute.  The value is converted before being passed to the
-            validator, if any.
-
-            .. seealso:: :ref:`converters`
-
-        metadata (dict | None):
-            An arbitrary mapping, to be used by third-party code.
-
-            .. seealso:: `extending-metadata`.
-
-        type (type):
-            The type of the attribute. Nowadays, the preferred method to
-            specify the type is using a variable annotation (see :pep:`526`).
-            This argument is provided for backwards-compatibility and for usage
-            with `make_class`. Regardless of the approach used, the type will
-            be stored on ``Attribute.type``.
-
-            Please note that *attrs* doesn't do anything with this metadata by
-            itself. You can use it as part of your own code or for `static type
-            checking <types>`.
-
-        kw_only (bool | None):
-            Make this attribute keyword-only in the generated ``__init__`` (if
-            *init* is False, this parameter is ignored).  If None (default),
-            mirror the setting from `attrs.define`.
-
-        on_setattr (~typing.Callable | list[~typing.Callable] | None | ~typing.Literal[attrs.setters.NO_OP]):
-            Allows to overwrite the *on_setattr* setting from `attr.s`. If left
-            None, the *on_setattr* value from `attr.s` is used. Set to
-            `attrs.setters.NO_OP` to run **no** `setattr` hooks for this
-            attribute -- regardless of the setting in `define()`.
-
-        alias (str | None):
-            Override this attribute's parameter name in the generated
-            ``__init__`` method. If left None, default to ``name`` stripped
-            of leading underscores. See `private-attributes`.
-
-    .. versionadded:: 20.1.0
-    .. versionchanged:: 21.1.0
-       *eq*, *order*, and *cmp* also accept a custom callable
-    .. versionadded:: 22.2.0 *alias*
-    .. versionadded:: 23.1.0
-       The *type* parameter has been re-added; mostly for `attrs.make_class`.
-       Please note that type checkers ignore this metadata.
-    .. versionchanged:: 25.4.0
-       *kw_only* can now be None, and its default is also changed from False to
-       None.
-
-    .. seealso::
-
-       `attr.ib`
-    """
-    return attrib(
-        default=default,
-        validator=validator,
-        repr=repr,
-        hash=hash,
-        init=init,
-        metadata=metadata,
-        type=type,
-        converter=converter,
-        factory=factory,
-        kw_only=kw_only,
-        eq=eq,
-        order=order,
-        on_setattr=on_setattr,
-        alias=alias,
-    )
-
-
-def asdict(inst, *, recurse=True, filter=None, value_serializer=None):
-    """
-    Same as `attr.asdict`, except that collections types are always retained
-    and dict is always used as *dict_factory*.
-
-    .. versionadded:: 21.3.0
-    """
-    return _asdict(
-        inst=inst,
-        recurse=recurse,
-        filter=filter,
-        value_serializer=value_serializer,
-        retain_collection_types=True,
-    )
-
-
-def astuple(inst, *, recurse=True, filter=None):
-    """
-    Same as `attr.astuple`, except that collections types are always retained
-    and `tuple` is always used as the *tuple_factory*.
-
-    .. versionadded:: 21.3.0
-    """
-    return _astuple(
-        inst=inst, recurse=recurse, filter=filter, retain_collection_types=True
-    )
-
-
-def inspect(cls):
-    """
-    Inspect the class and return its effective build parameters.
-
-    Warning:
-        This feature is currently **experimental** and is not covered by our
-        strict backwards-compatibility guarantees.
-
-    Args:
-        cls: The *attrs*-decorated class to inspect.
-
-    Returns:
-        The effective build parameters of the class.
-
-    Raises:
-        NotAnAttrsClassError: If the class is not an *attrs*-decorated class.
-
-    .. versionadded:: 25.4.0
-    """
-    try:
-        return cls.__dict__["__attrs_props__"]
-    except KeyError:
-        msg = f"{cls!r} is not an attrs-decorated class."
-        raise NotAnAttrsClassError(msg) from None
@@ -1,15 +0,0 @@
-from typing import Any, ClassVar, Protocol
-
-# MYPY is a special constant in mypy which works the same way as `TYPE_CHECKING`.
-MYPY = False
-
-if MYPY:
-    # A protocol to be able to statically accept an attrs class.
-    class AttrsInstance_(Protocol):
-        __attrs_attrs__: ClassVar[Any]
-
-else:
-    # For type checkers without plug-in support use an empty protocol that
-    # will (hopefully) be combined into a union.
-    class AttrsInstance_(Protocol):
-        pass
@@ -1,89 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-
-from functools import total_ordering
-
-from ._funcs import astuple
-from ._make import attrib, attrs
-
-
-@total_ordering
-@attrs(eq=False, order=False, slots=True, frozen=True)
-class VersionInfo:
-    """
-    A version object that can be compared to tuple of length 1--4:
-
-    >>> attr.VersionInfo(19, 1, 0, "final")  <= (19, 2)
-    True
-    >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1)
-    True
-    >>> vi = attr.VersionInfo(19, 2, 0, "final")
-    >>> vi < (19, 1, 1)
-    False
-    >>> vi < (19,)
-    False
-    >>> vi == (19, 2,)
-    True
-    >>> vi == (19, 2, 1)
-    False
-
-    .. versionadded:: 19.2
-    """
-
-    year = attrib(type=int)
-    minor = attrib(type=int)
-    micro = attrib(type=int)
-    releaselevel = attrib(type=str)
-
-    @classmethod
-    def _from_version_string(cls, s):
-        """
-        Parse *s* and return a _VersionInfo.
-        """
-        v = s.split(".")
-        if len(v) == 3:
-            v.append("final")
-
-        return cls(
-            year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3]
-        )
-
-    def _ensure_tuple(self, other):
-        """
-        Ensure *other* is a tuple of a valid length.
-
-        Returns a possibly transformed *other* and ourselves as a tuple of
-        the same length as *other*.
-        """
-
-        if self.__class__ is other.__class__:
-            other = astuple(other)
-
-        if not isinstance(other, tuple):
-            raise NotImplementedError
-
-        if not (1 <= len(other) <= 4):
-            raise NotImplementedError
-
-        return astuple(self)[: len(other)], other
-
-    def __eq__(self, other):
-        try:
-            us, them = self._ensure_tuple(other)
-        except NotImplementedError:
-            return NotImplemented
-
-        return us == them
-
-    def __lt__(self, other):
-        try:
-            us, them = self._ensure_tuple(other)
-        except NotImplementedError:
-            return NotImplemented
-
-        # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't
-        # have to do anything special with releaselevel for now.
-        return us < them
-
-    def __hash__(self):
-        return hash((self.year, self.minor, self.micro, self.releaselevel))
@@ -1,9 +0,0 @@
-class VersionInfo:
-    @property
-    def year(self) -> int: ...
-    @property
-    def minor(self) -> int: ...
-    @property
-    def micro(self) -> int: ...
-    @property
-    def releaselevel(self) -> str: ...
@@ -1,162 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful converters.
-"""
-
-import typing
-
-from ._compat import _AnnotationExtractor
-from ._make import NOTHING, Converter, Factory, pipe
-
-
-__all__ = [
-    "default_if_none",
-    "optional",
-    "pipe",
-    "to_bool",
-]
-
-
-def optional(converter):
-    """
-    A converter that allows an attribute to be optional. An optional attribute
-    is one which can be set to `None`.
-
-    Type annotations will be inferred from the wrapped converter's, if it has
-    any.
-
-    Args:
-        converter (typing.Callable):
-            the converter that is used for non-`None` values.
-
-    .. versionadded:: 17.1.0
-    """
-
-    if isinstance(converter, Converter):
-
-        def optional_converter(val, inst, field):
-            if val is None:
-                return None
-            return converter(val, inst, field)
-
-    else:
-
-        def optional_converter(val):
-            if val is None:
-                return None
-            return converter(val)
-
-    xtr = _AnnotationExtractor(converter)
-
-    t = xtr.get_first_param_type()
-    if t:
-        optional_converter.__annotations__["val"] = typing.Optional[t]
-
-    rt = xtr.get_return_type()
-    if rt:
-        optional_converter.__annotations__["return"] = typing.Optional[rt]
-
-    if isinstance(converter, Converter):
-        return Converter(optional_converter, takes_self=True, takes_field=True)
-
-    return optional_converter
-
-
-def default_if_none(default=NOTHING, factory=None):
-    """
-    A converter that allows to replace `None` values by *default* or the result
-    of *factory*.
-
-    Args:
-        default:
-            Value to be used if `None` is passed. Passing an instance of
-            `attrs.Factory` is supported, however the ``takes_self`` option is
-            *not*.
-
-        factory (typing.Callable):
-            A callable that takes no parameters whose result is used if `None`
-            is passed.
-
-    Raises:
-        TypeError: If **neither** *default* or *factory* is passed.
-
-        TypeError: If **both** *default* and *factory* are passed.
-
-        ValueError:
-            If an instance of `attrs.Factory` is passed with
-            ``takes_self=True``.
-
-    .. versionadded:: 18.2.0
-    """
-    if default is NOTHING and factory is None:
-        msg = "Must pass either `default` or `factory`."
-        raise TypeError(msg)
-
-    if default is not NOTHING and factory is not None:
-        msg = "Must pass either `default` or `factory` but not both."
-        raise TypeError(msg)
-
-    if factory is not None:
-        default = Factory(factory)
-
-    if isinstance(default, Factory):
-        if default.takes_self:
-            msg = "`takes_self` is not supported by default_if_none."
-            raise ValueError(msg)
-
-        def default_if_none_converter(val):
-            if val is not None:
-                return val
-
-            return default.factory()
-
-    else:
-
-        def default_if_none_converter(val):
-            if val is not None:
-                return val
-
-            return default
-
-    return default_if_none_converter
-
-
-def to_bool(val):
-    """
-    Convert "boolean" strings (for example, from environment variables) to real
-    booleans.
-
-    Values mapping to `True`:
-
-    - ``True``
-    - ``"true"`` / ``"t"``
-    - ``"yes"`` / ``"y"``
-    - ``"on"``
-    - ``"1"``
-    - ``1``
-
-    Values mapping to `False`:
-
-    - ``False``
-    - ``"false"`` / ``"f"``
-    - ``"no"`` / ``"n"``
-    - ``"off"``
-    - ``"0"``
-    - ``0``
-
-    Raises:
-        ValueError: For any other value.
-
-    .. versionadded:: 21.3.0
-    """
-    if isinstance(val, str):
-        val = val.lower()
-
-    if val in (True, "true", "t", "yes", "y", "on", "1", 1):
-        return True
-    if val in (False, "false", "f", "no", "n", "off", "0", 0):
-        return False
-
-    msg = f"Cannot convert value to bool: {val!r}"
-    raise ValueError(msg)
@@ -1,19 +0,0 @@
-from typing import Callable, Any, overload
-
-from attrs import _ConverterType, _CallableConverterType
-
-@overload
-def pipe(*validators: _CallableConverterType) -> _CallableConverterType: ...
-@overload
-def pipe(*validators: _ConverterType) -> _ConverterType: ...
-@overload
-def optional(converter: _CallableConverterType) -> _CallableConverterType: ...
-@overload
-def optional(converter: _ConverterType) -> _ConverterType: ...
-@overload
-def default_if_none(default: Any) -> _CallableConverterType: ...
-@overload
-def default_if_none(
-    *, factory: Callable[[], Any]
-) -> _CallableConverterType: ...
-def to_bool(val: str | int | bool) -> bool: ...
@@ -1,95 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import annotations
-
-
-class FrozenError(AttributeError):
-    """
-    A frozen/immutable instance or attribute have been attempted to be
-    modified.
-
-    It mirrors the behavior of ``namedtuples`` by using the same error message
-    and subclassing `AttributeError`.
-
-    .. versionadded:: 20.1.0
-    """
-
-    def __init__(self):
-        msg = "can't set attribute"
-        super().__init__(msg)
-        self.msg = msg
-
-
-class FrozenInstanceError(FrozenError):
-    """
-    A frozen instance has been attempted to be modified.
-
-    .. versionadded:: 16.1.0
-    """
-
-
-class FrozenAttributeError(FrozenError):
-    """
-    A frozen attribute has been attempted to be modified.
-
-    .. versionadded:: 20.1.0
-    """
-
-
-class AttrsAttributeNotFoundError(ValueError):
-    """
-    An *attrs* function couldn't find an attribute that the user asked for.
-
-    .. versionadded:: 16.2.0
-    """
-
-
-class NotAnAttrsClassError(ValueError):
-    """
-    A non-*attrs* class has been passed into an *attrs* function.
-
-    .. versionadded:: 16.2.0
-    """
-
-
-class DefaultAlreadySetError(RuntimeError):
-    """
-    A default has been set when defining the field and is attempted to be reset
-    using the decorator.
-
-    .. versionadded:: 17.1.0
-    """
-
-
-class UnannotatedAttributeError(RuntimeError):
-    """
-    A class with ``auto_attribs=True`` has a field without a type annotation.
-
-    .. versionadded:: 17.3.0
-    """
-
-
-class PythonTooOldError(RuntimeError):
-    """
-    It was attempted to use an *attrs* feature that requires a newer Python
-    version.
-
-    .. versionadded:: 18.2.0
-    """
-
-
-class NotCallableError(TypeError):
-    """
-    A field requiring a callable has been set with a value that is not
-    callable.
-
-    .. versionadded:: 19.2.0
-    """
-
-    def __init__(self, msg, value):
-        super(TypeError, self).__init__(msg, value)
-        self.msg = msg
-        self.value = value
-
-    def __str__(self):
-        return str(self.msg)
@@ -1,17 +0,0 @@
-from typing import Any
-
-class FrozenError(AttributeError):
-    msg: str = ...
-
-class FrozenInstanceError(FrozenError): ...
-class FrozenAttributeError(FrozenError): ...
-class AttrsAttributeNotFoundError(ValueError): ...
-class NotAnAttrsClassError(ValueError): ...
-class DefaultAlreadySetError(RuntimeError): ...
-class UnannotatedAttributeError(RuntimeError): ...
-class PythonTooOldError(RuntimeError): ...
-
-class NotCallableError(TypeError):
-    msg: str = ...
-    value: Any = ...
-    def __init__(self, msg: str, value: Any) -> None: ...
@@ -1,72 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful filters for `attrs.asdict` and `attrs.astuple`.
-"""
-
-from ._make import Attribute
-
-
-def _split_what(what):
-    """
-    Returns a tuple of `frozenset`s of classes and attributes.
-    """
-    return (
-        frozenset(cls for cls in what if isinstance(cls, type)),
-        frozenset(cls for cls in what if isinstance(cls, str)),
-        frozenset(cls for cls in what if isinstance(cls, Attribute)),
-    )
-
-
-def include(*what):
-    """
-    Create a filter that only allows *what*.
-
-    Args:
-        what (list[type, str, attrs.Attribute]):
-            What to include. Can be a type, a name, or an attribute.
-
-    Returns:
-        Callable:
-            A callable that can be passed to `attrs.asdict`'s and
-            `attrs.astuple`'s *filter* argument.
-
-    .. versionchanged:: 23.1.0 Accept strings with field names.
-    """
-    cls, names, attrs = _split_what(what)
-
-    def include_(attribute, value):
-        return (
-            value.__class__ in cls
-            or attribute.name in names
-            or attribute in attrs
-        )
-
-    return include_
-
-
-def exclude(*what):
-    """
-    Create a filter that does **not** allow *what*.
-
-    Args:
-        what (list[type, str, attrs.Attribute]):
-            What to exclude. Can be a type, a name, or an attribute.
-
-    Returns:
-        Callable:
-            A callable that can be passed to `attrs.asdict`'s and
-            `attrs.astuple`'s *filter* argument.
-
-    .. versionchanged:: 23.3.0 Accept field name string as input argument
-    """
-    cls, names, attrs = _split_what(what)
-
-    def exclude_(attribute, value):
-        return not (
-            value.__class__ in cls
-            or attribute.name in names
-            or attribute in attrs
-        )
-
-    return exclude_
@@ -1,6 +0,0 @@
-from typing import Any
-
-from . import Attribute, _FilterType
-
-def include(*what: type | str | Attribute[Any]) -> _FilterType[Any]: ...
-def exclude(*what: type | str | Attribute[Any]) -> _FilterType[Any]: ...
@@ -1,79 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly used hooks for on_setattr.
-"""
-
-from . import _config
-from .exceptions import FrozenAttributeError
-
-
-def pipe(*setters):
-    """
-    Run all *setters* and return the return value of the last one.
-
-    .. versionadded:: 20.1.0
-    """
-
-    def wrapped_pipe(instance, attrib, new_value):
-        rv = new_value
-
-        for setter in setters:
-            rv = setter(instance, attrib, rv)
-
-        return rv
-
-    return wrapped_pipe
-
-
-def frozen(_, __, ___):
-    """
-    Prevent an attribute to be modified.
-
-    .. versionadded:: 20.1.0
-    """
-    raise FrozenAttributeError
-
-
-def validate(instance, attrib, new_value):
-    """
-    Run *attrib*'s validator on *new_value* if it has one.
-
-    .. versionadded:: 20.1.0
-    """
-    if _config._run_validators is False:
-        return new_value
-
-    v = attrib.validator
-    if not v:
-        return new_value
-
-    v(instance, attrib, new_value)
-
-    return new_value
-
-
-def convert(instance, attrib, new_value):
-    """
-    Run *attrib*'s converter -- if it has one -- on *new_value* and return the
-    result.
-
-    .. versionadded:: 20.1.0
-    """
-    c = attrib.converter
-    if c:
-        # This can be removed once we drop 3.8 and use attrs.Converter instead.
-        from ._make import Converter
-
-        if not isinstance(c, Converter):
-            return c(new_value)
-
-        return c(new_value, instance, attrib)
-
-    return new_value
-
-
-# Sentinel for disabling class-wide *on_setattr* hooks for certain attributes.
-# Sphinx's autodata stopped working, so the docstring is inlined in the API
-# docs.
-NO_OP = object()
@@ -1,20 +0,0 @@
-from typing import Any, NewType, NoReturn, TypeVar
-
-from . import Attribute
-from attrs import _OnSetAttrType
-
-_T = TypeVar("_T")
-
-def frozen(
-    instance: Any, attribute: Attribute[Any], new_value: Any
-) -> NoReturn: ...
-def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ...
-def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ...
-
-# convert is allowed to return Any, because they can be chained using pipe.
-def convert(
-    instance: Any, attribute: Attribute[Any], new_value: Any
-) -> Any: ...
-
-_NoOpType = NewType("_NoOpType", object)
-NO_OP: _NoOpType
@@ -1,750 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful validators.
-"""
-
-import operator
-import re
-
-from contextlib import contextmanager
-from re import Pattern
-
-from ._config import get_run_validators, set_run_validators
-from ._make import _AndValidator, and_, attrib, attrs
-from .converters import default_if_none
-from .exceptions import NotCallableError
-
-
-__all__ = [
-    "and_",
-    "deep_iterable",
-    "deep_mapping",
-    "disabled",
-    "ge",
-    "get_disabled",
-    "gt",
-    "in_",
-    "instance_of",
-    "is_callable",
-    "le",
-    "lt",
-    "matches_re",
-    "max_len",
-    "min_len",
-    "not_",
-    "optional",
-    "or_",
-    "set_disabled",
-]
-
-
-def set_disabled(disabled):
-    """
-    Globally disable or enable running validators.
-
-    By default, they are run.
-
-    Args:
-        disabled (bool): If `True`, disable running all validators.
-
-    .. warning::
-
-        This function is not thread-safe!
-
-    .. versionadded:: 21.3.0
-    """
-    set_run_validators(not disabled)
-
-
-def get_disabled():
-    """
-    Return a bool indicating whether validators are currently disabled or not.
-
-    Returns:
-        bool:`True` if validators are currently disabled.
-
-    .. versionadded:: 21.3.0
-    """
-    return not get_run_validators()
-
-
-@contextmanager
-def disabled():
-    """
-    Context manager that disables running validators within its context.
-
-    .. warning::
-
-        This context manager is not thread-safe!
-
-    .. versionadded:: 21.3.0
-    .. versionchanged:: 26.1.0 The contextmanager is nestable.
-    """
-    prev = get_run_validators()
-    set_run_validators(False)
-    try:
-        yield
-    finally:
-        set_run_validators(prev)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _InstanceOfValidator:
-    type = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not isinstance(value, self.type):
-            msg = f"'{attr.name}' must be {self.type!r} (got {value!r} that is a {value.__class__!r})."
-            raise TypeError(
-                msg,
-                attr,
-                self.type,
-                value,
-            )
-
-    def __repr__(self):
-        return f"<instance_of validator for type {self.type!r}>"
-
-
-def instance_of(type):
-    """
-    A validator that raises a `TypeError` if the initializer is called with a
-    wrong type for this particular attribute (checks are performed using
-    `isinstance` therefore it's also valid to pass a tuple of types).
-
-    Args:
-        type (type | tuple[type]): The type to check for.
-
-    Raises:
-        TypeError:
-            With a human readable error message, the attribute (of type
-            `attrs.Attribute`), the expected type, and the value it got.
-    """
-    return _InstanceOfValidator(type)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MatchesReValidator:
-    pattern = attrib()
-    match_func = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not self.match_func(value):
-            msg = f"'{attr.name}' must match regex {self.pattern.pattern!r} ({value!r} doesn't)"
-            raise ValueError(
-                msg,
-                attr,
-                self.pattern,
-                value,
-            )
-
-    def __repr__(self):
-        return f"<matches_re validator for pattern {self.pattern!r}>"
-
-
-def matches_re(regex, flags=0, func=None):
-    r"""
-    A validator that raises `ValueError` if the initializer is called with a
-    string that doesn't match *regex*.
-
-    Args:
-        regex (str, re.Pattern):
-            A regex string or precompiled pattern to match against
-
-        flags (int):
-            Flags that will be passed to the underlying re function (default 0)
-
-        func (typing.Callable):
-            Which underlying `re` function to call. Valid options are
-            `re.fullmatch`, `re.search`, and `re.match`; the default `None`
-            means `re.fullmatch`. For performance reasons, the pattern is
-            always precompiled using `re.compile`.
-
-    .. versionadded:: 19.2.0
-    .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern.
-    """
-    valid_funcs = (re.fullmatch, None, re.search, re.match)
-    if func not in valid_funcs:
-        msg = "'func' must be one of {}.".format(
-            ", ".join(
-                sorted((e and e.__name__) or "None" for e in set(valid_funcs))
-            )
-        )
-        raise ValueError(msg)
-
-    if isinstance(regex, Pattern):
-        if flags:
-            msg = "'flags' can only be used with a string pattern; pass flags to re.compile() instead"
-            raise TypeError(msg)
-        pattern = regex
-    else:
-        pattern = re.compile(regex, flags)
-
-    if func is re.match:
-        match_func = pattern.match
-    elif func is re.search:
-        match_func = pattern.search
-    else:
-        match_func = pattern.fullmatch
-
-    return _MatchesReValidator(pattern, match_func)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _OptionalValidator:
-    validator = attrib()
-
-    def __call__(self, inst, attr, value):
-        if value is None:
-            return
-
-        self.validator(inst, attr, value)
-
-    def __repr__(self):
-        return f"<optional validator for {self.validator!r} or None>"
-
-
-def optional(validator):
-    """
-    A validator that makes an attribute optional.  An optional attribute is one
-    which can be set to `None` in addition to satisfying the requirements of
-    the sub-validator.
-
-    Args:
-        validator
-            (typing.Callable | tuple[typing.Callable] | list[typing.Callable]):
-            A validator (or validators) that is used for non-`None` values.
-
-    .. versionadded:: 15.1.0
-    .. versionchanged:: 17.1.0 *validator* can be a list of validators.
-    .. versionchanged:: 23.1.0 *validator* can also be a tuple of validators.
-    """
-    if isinstance(validator, (list, tuple)):
-        return _OptionalValidator(_AndValidator(validator))
-
-    return _OptionalValidator(validator)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _InValidator:
-    options = attrib()
-    _original_options = attrib(hash=False)
-
-    def __call__(self, inst, attr, value):
-        try:
-            in_options = value in self.options
-        except TypeError:  # e.g. `1 in "abc"`
-            in_options = False
-
-        if not in_options:
-            msg = f"'{attr.name}' must be in {self._original_options!r} (got {value!r})"
-            raise ValueError(
-                msg,
-                attr,
-                self._original_options,
-                value,
-            )
-
-    def __repr__(self):
-        return f"<in_ validator with options {self._original_options!r}>"
-
-
-def in_(options):
-    """
-    A validator that raises a `ValueError` if the initializer is called with a
-    value that does not belong in the *options* provided.
-
-    The check is performed using ``value in options``, so *options* has to
-    support that operation.
-
-    To keep the validator hashable, dicts, lists, and sets are transparently
-    transformed into a `tuple`.
-
-    Args:
-        options: Allowed options.
-
-    Raises:
-        ValueError:
-            With a human readable error message, the attribute (of type
-            `attrs.Attribute`), the expected options, and the value it got.
-
-    .. versionadded:: 17.1.0
-    .. versionchanged:: 22.1.0
-       The ValueError was incomplete until now and only contained the human
-       readable error message. Now it contains all the information that has
-       been promised since 17.1.0.
-    .. versionchanged:: 24.1.0
-       *options* that are a list, dict, or a set are now transformed into a
-       tuple to keep the validator hashable.
-    """
-    repr_options = options
-    if isinstance(options, (list, dict, set)):
-        options = tuple(options)
-
-    return _InValidator(options, repr_options)
-
-
-@attrs(repr=False, slots=False, unsafe_hash=True)
-class _IsCallableValidator:
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not callable(value):
-            message = (
-                "'{name}' must be callable "
-                "(got {value!r} that is a {actual!r})."
-            )
-            raise NotCallableError(
-                msg=message.format(
-                    name=attr.name, value=value, actual=value.__class__
-                ),
-                value=value,
-            )
-
-    def __repr__(self):
-        return "<is_callable validator>"
-
-
-def is_callable():
-    """
-    A validator that raises a `attrs.exceptions.NotCallableError` if the
-    initializer is called with a value for this particular attribute that is
-    not callable.
-
-    .. versionadded:: 19.1.0
-
-    Raises:
-        attrs.exceptions.NotCallableError:
-            With a human readable error message containing the attribute
-            (`attrs.Attribute`) name, and the value it got.
-    """
-    return _IsCallableValidator()
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _DeepIterable:
-    member_validator = attrib(validator=is_callable())
-    iterable_validator = attrib(
-        default=None, validator=optional(is_callable())
-    )
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if self.iterable_validator is not None:
-            self.iterable_validator(inst, attr, value)
-
-        for member in value:
-            self.member_validator(inst, attr, member)
-
-    def __repr__(self):
-        iterable_identifier = (
-            ""
-            if self.iterable_validator is None
-            else f" {self.iterable_validator!r}"
-        )
-        return (
-            f"<deep_iterable validator for{iterable_identifier}"
-            f" iterables of {self.member_validator!r}>"
-        )
-
-
-def deep_iterable(member_validator, iterable_validator=None):
-    """
-    A validator that performs deep validation of an iterable.
-
-    Args:
-        member_validator: Validator(s) to apply to iterable members.
-
-        iterable_validator:
-            Validator(s) to apply to iterable itself (optional).
-
-    Raises
-        TypeError: if any sub-validators fail
-
-    .. versionadded:: 19.1.0
-
-    .. versionchanged:: 25.4.0
-       *member_validator* and *iterable_validator* can now be a list or tuple
-       of validators.
-    """
-    if isinstance(member_validator, (list, tuple)):
-        member_validator = and_(*member_validator)
-    if isinstance(iterable_validator, (list, tuple)):
-        iterable_validator = and_(*iterable_validator)
-    return _DeepIterable(member_validator, iterable_validator)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _DeepMapping:
-    key_validator = attrib(validator=optional(is_callable()))
-    value_validator = attrib(validator=optional(is_callable()))
-    mapping_validator = attrib(validator=optional(is_callable()))
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if self.mapping_validator is not None:
-            self.mapping_validator(inst, attr, value)
-
-        for key in value:
-            if self.key_validator is not None:
-                self.key_validator(inst, attr, key)
-            if self.value_validator is not None:
-                self.value_validator(inst, attr, value[key])
-
-    def __repr__(self):
-        return f"<deep_mapping validator for objects mapping {self.key_validator!r} to {self.value_validator!r}>"
-
-
-def deep_mapping(
-    key_validator=None, value_validator=None, mapping_validator=None
-):
-    """
-    A validator that performs deep validation of a dictionary.
-
-    All validators are optional, but at least one of *key_validator* or
-    *value_validator* must be provided.
-
-    Args:
-        key_validator: Validator(s) to apply to dictionary keys.
-
-        value_validator: Validator(s) to apply to dictionary values.
-
-        mapping_validator:
-            Validator(s) to apply to top-level mapping attribute.
-
-    .. versionadded:: 19.1.0
-
-    .. versionchanged:: 25.4.0
-       *key_validator* and *value_validator* are now optional, but at least one
-       of them must be provided.
-
-    .. versionchanged:: 25.4.0
-       *key_validator*, *value_validator*, and *mapping_validator* can now be a
-       list or tuple of validators.
-
-    Raises:
-        TypeError: If any sub-validator fails on validation.
-
-        ValueError:
-            If neither *key_validator* nor *value_validator* is provided on
-            instantiation.
-    """
-    if key_validator is None and value_validator is None:
-        msg = (
-            "At least one of key_validator or value_validator must be provided"
-        )
-        raise ValueError(msg)
-
-    if isinstance(key_validator, (list, tuple)):
-        key_validator = and_(*key_validator)
-    if isinstance(value_validator, (list, tuple)):
-        value_validator = and_(*value_validator)
-    if isinstance(mapping_validator, (list, tuple)):
-        mapping_validator = and_(*mapping_validator)
-
-    return _DeepMapping(key_validator, value_validator, mapping_validator)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _NumberValidator:
-    bound = attrib()
-    compare_op = attrib()
-    compare_func = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not self.compare_func(value, self.bound):
-            msg = f"'{attr.name}' must be {self.compare_op} {self.bound}: {value}"
-            raise ValueError(msg)
-
-    def __repr__(self):
-        return f"<Validator for x {self.compare_op} {self.bound}>"
-
-
-def lt(val):
-    """
-    A validator that raises `ValueError` if the initializer is called with a
-    number larger or equal to *val*.
-
-    The validator uses `operator.lt` to compare the values.
-
-    Args:
-        val: Exclusive upper bound for values.
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, "<", operator.lt)
-
-
-def le(val):
-    """
-    A validator that raises `ValueError` if the initializer is called with a
-    number greater than *val*.
-
-    The validator uses `operator.le` to compare the values.
-
-    Args:
-        val: Inclusive upper bound for values.
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, "<=", operator.le)
-
-
-def ge(val):
-    """
-    A validator that raises `ValueError` if the initializer is called with a
-    number smaller than *val*.
-
-    The validator uses `operator.ge` to compare the values.
-
-    Args:
-        val: Inclusive lower bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, ">=", operator.ge)
-
-
-def gt(val):
-    """
-    A validator that raises `ValueError` if the initializer is called with a
-    number smaller or equal to *val*.
-
-    The validator uses `operator.gt` to compare the values.
-
-    Args:
-       val: Exclusive lower bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, ">", operator.gt)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MaxLengthValidator:
-    max_length = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if len(value) > self.max_length:
-            msg = f"Length of '{attr.name}' must be <= {self.max_length}: {len(value)}"
-            raise ValueError(msg)
-
-    def __repr__(self):
-        return f"<max_len validator for {self.max_length}>"
-
-
-def max_len(length):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a string or iterable that is longer than *length*.
-
-    Args:
-        length (int): Maximum length of the string or iterable
-
-    .. versionadded:: 21.3.0
-    """
-    return _MaxLengthValidator(length)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MinLengthValidator:
-    min_length = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if len(value) < self.min_length:
-            msg = f"Length of '{attr.name}' must be >= {self.min_length}: {len(value)}"
-            raise ValueError(msg)
-
-    def __repr__(self):
-        return f"<min_len validator for {self.min_length}>"
-
-
-def min_len(length):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a string or iterable that is shorter than *length*.
-
-    Args:
-        length (int): Minimum length of the string or iterable
-
-    .. versionadded:: 22.1.0
-    """
-    return _MinLengthValidator(length)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _SubclassOfValidator:
-    type = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not issubclass(value, self.type):
-            msg = f"'{attr.name}' must be a subclass of {self.type!r} (got {value!r})."
-            raise TypeError(
-                msg,
-                attr,
-                self.type,
-                value,
-            )
-
-    def __repr__(self):
-        return f"<subclass_of validator for type {self.type!r}>"
-
-
-def _subclass_of(type):
-    """
-    A validator that raises a `TypeError` if the initializer is called with a
-    wrong type for this particular attribute (checks are performed using
-    `issubclass` therefore it's also valid to pass a tuple of types).
-
-    Args:
-        type (type | tuple[type, ...]): The type(s) to check for.
-
-    Raises:
-        TypeError:
-            With a human readable error message, the attribute (of type
-            `attrs.Attribute`), the expected type, and the value it got.
-    """
-    return _SubclassOfValidator(type)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _NotValidator:
-    validator = attrib()
-    msg = attrib(
-        converter=default_if_none(
-            "not_ validator child '{validator!r}' "
-            "did not raise a captured error"
-        )
-    )
-    exc_types = attrib(
-        validator=deep_iterable(
-            member_validator=_subclass_of(Exception),
-            iterable_validator=instance_of(tuple),
-        ),
-    )
-
-    def __call__(self, inst, attr, value):
-        try:
-            self.validator(inst, attr, value)
-        except self.exc_types:
-            pass  # suppress error to invert validity
-        else:
-            raise ValueError(
-                self.msg.format(
-                    validator=self.validator,
-                    exc_types=self.exc_types,
-                ),
-                attr,
-                self.validator,
-                value,
-                self.exc_types,
-            )
-
-    def __repr__(self):
-        return f"<not_ validator wrapping {self.validator!r}, capturing {self.exc_types!r}>"
-
-
-def not_(validator, *, msg=None, exc_types=(ValueError, TypeError)):
-    """
-    A validator that wraps and logically 'inverts' the validator passed to it.
-    It will raise a `ValueError` if the provided validator *doesn't* raise a
-    `ValueError` or `TypeError` (by default), and will suppress the exception
-    if the provided validator *does*.
-
-    Intended to be used with existing validators to compose logic without
-    needing to create inverted variants, for example, ``not_(in_(...))``.
-
-    Args:
-        validator: A validator to be logically inverted.
-
-        msg (str):
-            Message to raise if validator fails. Formatted with keys
-            ``exc_types`` and ``validator``.
-
-        exc_types (tuple[type, ...]):
-            Exception type(s) to capture. Other types raised by child
-            validators will not be intercepted and pass through.
-
-    Raises:
-        ValueError:
-            With a human readable error message, the attribute (of type
-            `attrs.Attribute`), the validator that failed to raise an
-            exception, the value it got, and the expected exception types.
-
-    .. versionadded:: 22.2.0
-    """
-    try:
-        exc_types = tuple(exc_types)
-    except TypeError:
-        exc_types = (exc_types,)
-    return _NotValidator(validator, msg, exc_types)
-
-
-@attrs(repr=False, slots=True, unsafe_hash=True)
-class _OrValidator:
-    validators = attrib()
-
-    def __call__(self, inst, attr, value):
-        for v in self.validators:
-            try:
-                v(inst, attr, value)
-            except Exception:  # noqa: BLE001, PERF203, S112
-                continue
-            else:
-                return
-
-        msg = f"None of {self.validators!r} satisfied for value {value!r}"
-        raise ValueError(msg)
-
-    def __repr__(self):
-        return f"<or validator wrapping {self.validators!r}>"
-
-
-def or_(*validators):
-    """
-    A validator that composes multiple validators into one.
-
-    When called on a value, it runs all wrapped validators until one of them is
-    satisfied.
-
-    Args:
-        validators (~collections.abc.Iterable[typing.Callable]):
-            Arbitrary number of validators.
-
-    Raises:
-        ValueError:
-            If no validator is satisfied. Raised with a human-readable error
-            message listing all the wrapped validators and the value that
-            failed all of them.
-
-    .. versionadded:: 24.1.0
-    """
-    vals = []
-    for v in validators:
-        vals.extend(v.validators if isinstance(v, _OrValidator) else [v])
-
-    return _OrValidator(tuple(vals))
@@ -1,140 +0,0 @@
-from types import UnionType
-from typing import (
-    Any,
-    AnyStr,
-    Callable,
-    Container,
-    ContextManager,
-    Iterable,
-    Mapping,
-    Match,
-    Pattern,
-    TypeVar,
-    overload,
-)
-
-from attrs import _ValidatorType
-from attrs import _ValidatorArgType
-
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-_T6 = TypeVar("_T6")
-_I = TypeVar("_I", bound=Iterable)
-_K = TypeVar("_K")
-_V = TypeVar("_V")
-_M = TypeVar("_M", bound=Mapping)
-
-def set_disabled(run: bool) -> None: ...
-def get_disabled() -> bool: ...
-def disabled() -> ContextManager[None]: ...
-
-# To be more precise on instance_of use some overloads.
-# If there are more than 3 items in the tuple then we fall back to Any
-@overload
-def instance_of(type: type[_T]) -> _ValidatorType[_T]: ...
-@overload
-def instance_of(type: tuple[type[_T]]) -> _ValidatorType[_T]: ...
-@overload
-def instance_of(
-    type: tuple[type[_T1], type[_T2]],
-) -> _ValidatorType[_T1 | _T2]: ...
-@overload
-def instance_of(
-    type: tuple[type[_T1], type[_T2], type[_T3]],
-) -> _ValidatorType[_T1 | _T2 | _T3]: ...
-@overload
-def instance_of(type: tuple[type, ...]) -> _ValidatorType[Any]: ...
-@overload
-def instance_of(type: UnionType) -> _ValidatorType[Any]: ...
-def optional(
-    validator: (
-        _ValidatorType[_T]
-        | list[_ValidatorType[_T]]
-        | tuple[_ValidatorType[_T], ...]
-    ),
-) -> _ValidatorType[_T | None]: ...
-def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
-def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
-def matches_re(
-    regex: Pattern[AnyStr] | AnyStr,
-    flags: int = ...,
-    func: Callable[[AnyStr, AnyStr, int], Match[AnyStr] | None] | None = ...,
-) -> _ValidatorType[AnyStr]: ...
-def deep_iterable(
-    member_validator: _ValidatorArgType[_T],
-    iterable_validator: _ValidatorArgType[_I] | None = ...,
-) -> _ValidatorType[_I]: ...
-@overload
-def deep_mapping(
-    key_validator: _ValidatorArgType[_K],
-    value_validator: _ValidatorArgType[_V] | None = ...,
-    mapping_validator: _ValidatorArgType[_M] | None = ...,
-) -> _ValidatorType[_M]: ...
-@overload
-def deep_mapping(
-    key_validator: _ValidatorArgType[_K] | None = ...,
-    value_validator: _ValidatorArgType[_V] = ...,
-    mapping_validator: _ValidatorArgType[_M] | None = ...,
-) -> _ValidatorType[_M]: ...
-def is_callable() -> _ValidatorType[_T]: ...
-def lt(val: _T) -> _ValidatorType[_T]: ...
-def le(val: _T) -> _ValidatorType[_T]: ...
-def ge(val: _T) -> _ValidatorType[_T]: ...
-def gt(val: _T) -> _ValidatorType[_T]: ...
-def max_len(length: int) -> _ValidatorType[_T]: ...
-def min_len(length: int) -> _ValidatorType[_T]: ...
-def not_(
-    validator: _ValidatorType[_T],
-    *,
-    msg: str | None = None,
-    exc_types: type[Exception] | Iterable[type[Exception]] = ...,
-) -> _ValidatorType[_T]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[_T1],
-    __v2: _ValidatorType[_T2],
-) -> _ValidatorType[_T1 | _T2]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[_T1],
-    __v2: _ValidatorType[_T2],
-    __v3: _ValidatorType[_T3],
-) -> _ValidatorType[_T1 | _T2 | _T3]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[_T1],
-    __v2: _ValidatorType[_T2],
-    __v3: _ValidatorType[_T3],
-    __v4: _ValidatorType[_T4],
-) -> _ValidatorType[_T1 | _T2 | _T3 | _T4]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[_T1],
-    __v2: _ValidatorType[_T2],
-    __v3: _ValidatorType[_T3],
-    __v4: _ValidatorType[_T4],
-    __v5: _ValidatorType[_T5],
-) -> _ValidatorType[_T1 | _T2 | _T3 | _T4 | _T5]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[_T1],
-    __v2: _ValidatorType[_T2],
-    __v3: _ValidatorType[_T3],
-    __v4: _ValidatorType[_T4],
-    __v5: _ValidatorType[_T5],
-    __v6: _ValidatorType[_T6],
-) -> _ValidatorType[_T1 | _T2 | _T3 | _T4 | _T5 | _T6]: ...
-@overload
-def or_(
-    __v1: _ValidatorType[Any],
-    __v2: _ValidatorType[Any],
-    __v3: _ValidatorType[Any],
-    __v4: _ValidatorType[Any],
-    __v5: _ValidatorType[Any],
-    __v6: _ValidatorType[Any],
-    *validators: _ValidatorType[Any],
-) -> _ValidatorType[Any]: ...
@@ -1 +0,0 @@
-uv
@@ -1,199 +0,0 @@
-Metadata-Version: 2.4
-Name: attrs
-Version: 26.1.0
-Summary: Classes Without Boilerplate
-Project-URL: Documentation, https://www.attrs.org/
-Project-URL: Changelog, https://www.attrs.org/en/stable/changelog.html
-Project-URL: GitHub, https://github.com/python-attrs/attrs
-Project-URL: Funding, https://github.com/sponsors/hynek
-Project-URL: Tidelift, https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=pypi
-Author-email: Hynek Schlawack <hs@ox.cx>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: attribute,boilerplate,class
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Typing :: Typed
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-<p align="center">
-  <a href="https://www.attrs.org/">
-    <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/docs/_static/attrs_logo.svg" width="35%" alt="attrs" />
-  </a>
-</p>
-
-
-*attrs* is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka [dunder methods](https://www.attrs.org/en/latest/glossary.html#term-dunder-methods)).
-Trusted by NASA for [Mars missions since 2020](https://github.com/readme/featured/nasa-ingenuity-helicopter)!
-
-Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
-
-
-## Sponsors
-
-*attrs* would not be possible without our [amazing sponsors](https://github.com/sponsors/hynek).
-Especially those generously supporting us at the *The Organization* tier and higher:
-
-<!-- sponsor-break-begin -->
-
-<p align="center">
-
-<!-- [[[cog
-import pathlib, tomllib
-
-for sponsor in tomllib.loads(pathlib.Path("pyproject.toml").read_text())["tool"]["sponcon"]["sponsors"]:
-      print(f'<a href="{sponsor["url"]}"><img title="{sponsor["title"]}" src="https://www.attrs.org/en/26.1.0/_static/sponsors/{sponsor["img"]}" width="190" /></a>')
-]]] -->
-<a href="https://www.variomedia.de/"><img title="Variomedia AG" src="https://www.attrs.org/en/26.1.0/_static/sponsors/Variomedia.svg" width="190" /></a>
-<a href="https://tidelift.com/?utm_source=lifter&utm_medium=referral&utm_campaign=hynek"><img title="Tidelift" src="https://www.attrs.org/en/26.1.0/_static/sponsors/Tidelift.svg" width="190" /></a>
-<a href="https://kraken.tech/"><img title="Kraken Tech" src="https://www.attrs.org/en/26.1.0/_static/sponsors/Kraken.svg" width="190" /></a>
-<a href="https://privacy-solutions.org/"><img title="Privacy Solutions" src="https://www.attrs.org/en/26.1.0/_static/sponsors/Privacy-Solutions.svg" width="190" /></a>
-<a href="https://filepreviews.io/"><img title="FilePreviews" src="https://www.attrs.org/en/26.1.0/_static/sponsors/FilePreviews.svg" width="190" /></a>
-<a href="https://www.testmuai.com/?utm_medium=sponsor&utm_source=structlog"><img title="TestMu AI" src="https://www.attrs.org/en/26.1.0/_static/sponsors/TestMu-AI.svg" width="190" /></a>
-<a href="https://polar.sh/"><img title="Polar" src="https://www.attrs.org/en/26.1.0/_static/sponsors/Polar.svg" width="190" /></a>
-<!-- [[[end]]] -->
-
-</p>
-
-<!-- sponsor-break-end -->
-
-<p align="center">
-   <strong>Please consider <a href="https://github.com/sponsors/hynek">joining them</a> to help make <em>attrs</em>’s maintenance more sustainable!</strong>
-</p>
-
-<!-- teaser-end -->
-
-## Example
-
-*attrs* gives you a class decorator and a way to declaratively define the attributes on that class:
-
-<!-- code-begin -->
-
-```pycon
->>> from attrs import asdict, define, make_class, Factory
-
->>> @define
-... class SomeClass:
-...     a_number: int = 42
-...     list_of_numbers: list[int] = Factory(list)
-...
-...     def hard_math(self, another_number):
-...         return self.a_number + sum(self.list_of_numbers) * another_number
-
-
->>> sc = SomeClass(1, [1, 2, 3])
->>> sc
-SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
-
->>> sc.hard_math(3)
-19
->>> sc == SomeClass(1, [1, 2, 3])
-True
->>> sc != SomeClass(2, [3, 2, 1])
-True
-
->>> asdict(sc)
-{'a_number': 1, 'list_of_numbers': [1, 2, 3]}
-
->>> SomeClass()
-SomeClass(a_number=42, list_of_numbers=[])
-
->>> C = make_class("C", ["a", "b"])
->>> C("foo", "bar")
-C(a='foo', b='bar')
-```
-
-After *declaring* your attributes, *attrs* gives you:
-
- a concise and explicit overview of the class's attributes,
- a nice human-readable `__repr__`,
- equality-checking methods,
- an initializer,
- and much more,
-
-*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
-
---
-
-This example uses *attrs*'s modern APIs that have been introduced in version 20.1.0, and the *attrs* package import name that has been added in version 21.3.0.
-The classic APIs (`@attr.s`, `attr.ib`, plus their serious-business aliases) and the `attr` package import name will remain **indefinitely**.
-
-Check out [*On The Core API Names*](https://www.attrs.org/en/latest/names.html) for an in-depth explanation!
-
-
-### Hate Type Annotations!?
-
-No problem!
-Types are entirely **optional** with *attrs*.
-Simply assign `attrs.field()` to the attributes instead of annotating them with types:
-
-```python
-from attrs import define, field
-
-@define
-class SomeClass:
-    a_number = field(default=42)
-    list_of_numbers = field(factory=list)
-```
-
-
-## Data Classes
-
-On the tin, *attrs* might remind you of `dataclasses` (and indeed, `dataclasses` [are a descendant](https://hynek.me/articles/import-attrs/) of *attrs*).
-In practice it does a lot more and is more flexible.
-For instance, it allows you to define [special handling of NumPy arrays for equality checks](https://www.attrs.org/en/stable/comparison.html#customization), allows more ways to [plug into the initialization process](https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization), has a replacement for `__init_subclass__`, and allows for stepping through the generated methods using a debugger.
-
-For more details, please refer to our [comparison page](https://www.attrs.org/en/stable/why.html#data-classes), but generally speaking, we are more likely to commit crimes against nature to make things work that one would expect to work, but that are quite complicated in practice.
-
-
-## Project Information
-
- [**Changelog**](https://www.attrs.org/en/stable/changelog.html)
- [**Documentation**](https://www.attrs.org/)
- [**PyPI**](https://pypi.org/project/attrs/)
- [**Source Code**](https://github.com/python-attrs/attrs)
- [**Contributing**](https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md)
- [**Third-party Extensions**](https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs)
- **Get Help**: use the `python-attrs` tag on [Stack Overflow](https://stackoverflow.com/questions/tagged/python-attrs)
-
-
-### *attrs* for Enterprise
-
-Available as part of the [Tidelift Subscription](https://tidelift.com/?utm_source=lifter&utm_medium=referral&utm_campaign=hynek).
-
-The maintainers of *attrs* and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
-Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
-
-## Release Information
-
-### Backwards-incompatible Changes
-
- Field aliases are now resolved *before* calling `field_transformer`, so transformers receive fully populated `Attribute` objects with usable `alias` values instead of `None`.
-  The new `Attribute.alias_is_default` flag indicates whether the alias was auto-generated (`True`) or explicitly set by the user (`False`).
-  [#1509](https://github.com/python-attrs/attrs/issues/1509)
-
-
-### Changes
-
- Fix type annotations for `attrs.validators.optional()`, so it no longer rejects tuples with more than one validator.
-  [#1496](https://github.com/python-attrs/attrs/issues/1496)
- The `attrs.validators.disabled()` contextmanager can now be nested.
-  [#1513](https://github.com/python-attrs/attrs/issues/1513)
- Frozen classes can set `on_setattr=attrs.setters.NO_OP` in addition to `None`.
-  [#1515](https://github.com/python-attrs/attrs/issues/1515)
- It's now possible to pass *attrs* **instances** in addition to *attrs* **classes** to `attrs.fields()`.
-  [#1529](https://github.com/python-attrs/attrs/issues/1529)
-
-
-
---
-
-[Full changelog →](https://www.attrs.org/en/stable/changelog.html)
@@ -1,37 +0,0 @@
-attr/__init__.py,sha256=fOYIvt1eGSqQre4uCS3sJWKZ0mwAuC8UD6qba5OS9_U,2057
-attr/__init__.pyi,sha256=pVGImAUVovq2_TYl_r_HIYnGlyOaoCuEhxo-EvsnnSc,11325
-attr/_cmp.py,sha256=3Nn1TjxllUYiX_nJoVnEkXoDk0hM1DYKj5DE7GZe4i0,4117
-attr/_cmp.pyi,sha256=U-_RU_UZOyPUEQzXE6RMYQQcjkZRY25wTH99sN0s7MM,368
-attr/_compat.py,sha256=x0g7iEUOnBVJC72zyFCgb1eKqyxS-7f2LGnNyZ_r95s,2829
-attr/_config.py,sha256=dGq3xR6fgZEF6UBt_L0T-eUHIB4i43kRmH0P28sJVw8,843
-attr/_funcs.py,sha256=Ix5IETTfz5F01F-12MF_CSFomIn2h8b67EVVz2gCtBE,16479
-attr/_make.py,sha256=H7OH2eWS5CnBzLUjNFE1WymfPrmF1r8fv2RPdt9MuYA,106129
-attr/_next_gen.py,sha256=BQtCUlzwg2gWHTYXBQvrEYBnzBUrDvO57u0Py6UCPhc,26274
-attr/_typing_compat.pyi,sha256=XDP54TUn-ZKhD62TOQebmzrwFyomhUCoGRpclb6alRA,469
-attr/_version_info.py,sha256=w4R-FYC3NK_kMkGUWJlYP4cVAlH9HRaC-um3fcjYkHM,2222
-attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209
-attr/converters.py,sha256=GlDeOzPeTFgeBBLbj9G57Ez5lAk68uhSALRYJ_exe84,3861
-attr/converters.pyi,sha256=orU2bff-VjQa2kMDyvnMQV73oJT2WRyQuw4ZR1ym1bE,643
-attr/exceptions.py,sha256=b4vMbnoQ3VpwWZhqrYi_ssXVCK8o2c4HQSS09cSUM9o,1990
-attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539
-attr/filters.py,sha256=ZBiKWLp3R0LfCZsq7X11pn9WX8NslS2wXM4jsnLOGc8,1795
-attr/filters.pyi,sha256=3J5BG-dTxltBk1_-RuNRUHrv2qu1v8v4aDNAQ7_mifA,208
-attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-attr/setters.py,sha256=5-dcT63GQK35ONEzSgfXCkbB7pPkaR-qv15mm4PVSzQ,1617
-attr/setters.pyi,sha256=NnVkaFU1BB4JB8E4JuXyrzTUgvtMpj8p3wBdJY7uix4,584
-attr/validators.py,sha256=m3QRzZTANr4f2C4eVdUoFg11NgXWak8Wat4qQTGhvcs,21553
-attr/validators.pyi,sha256=gM1ZmHaBckyYWI2EirpRNzqm3B19cw5Iq6B4Kno9YCM,4087
-attrs-26.1.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
-attrs-26.1.0.dist-info/METADATA,sha256=TNQOaQ8jvzfLytNO_WdY4GLfHfB8hoM_fjzpW_H6OMw,8754
-attrs-26.1.0.dist-info/RECORD,,
-attrs-26.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-attrs-26.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-attrs-26.1.0.dist-info/licenses/LICENSE,sha256=iCEVyV38KvHutnFPjsbVy8q_Znyv-HKfQkINpj9xTp8,1109
-attrs/__init__.py,sha256=RxaAZNwYiEh-fcvHLZNpQ_DWKni73M_jxEPEftiq1Zc,1183
-attrs/__init__.pyi,sha256=2gV79g9UxJppGSM48hAZJ6h_MHb70dZoJL31ZNJeZYI,9416
-attrs/converters.py,sha256=8kQljrVwfSTRu8INwEk8SI0eGrzmWftsT7rM0EqyohM,76
-attrs/exceptions.py,sha256=ACCCmg19-vDFaDPY9vFl199SPXCQMN_bENs4DALjzms,76
-attrs/filters.py,sha256=VOUMZug9uEU6dUuA0dF1jInUK0PL3fLgP0VBS5d-CDE,73
-attrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-attrs/setters.py,sha256=eL1YidYQV3T2h9_SYIZSZR1FAcHGb1TuCTy0E0Lv2SU,73
-attrs/validators.py,sha256=xcy6wD5TtTkdCG1f4XWbocPSO0faBjk5IfVJfP6SUj0,76
@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: hatchling 1.29.0
-Root-Is-Purelib: true
-Tag: py3-none-any
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Hynek Schlawack and the attrs contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
@@ -1,72 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr import (
-    NOTHING,
-    Attribute,
-    AttrsInstance,
-    Converter,
-    Factory,
-    NothingType,
-    _make_getattr,
-    assoc,
-    cmp_using,
-    define,
-    evolve,
-    field,
-    fields,
-    fields_dict,
-    frozen,
-    has,
-    make_class,
-    mutable,
-    resolve_types,
-    validate,
-)
-from attr._make import ClassProps
-from attr._next_gen import asdict, astuple, inspect
-
-from . import converters, exceptions, filters, setters, validators
-
-
-__all__ = [
-    "NOTHING",
-    "Attribute",
-    "AttrsInstance",
-    "ClassProps",
-    "Converter",
-    "Factory",
-    "NothingType",
-    "__author__",
-    "__copyright__",
-    "__description__",
-    "__doc__",
-    "__email__",
-    "__license__",
-    "__title__",
-    "__url__",
-    "__version__",
-    "__version_info__",
-    "asdict",
-    "assoc",
-    "astuple",
-    "cmp_using",
-    "converters",
-    "define",
-    "evolve",
-    "exceptions",
-    "field",
-    "fields",
-    "fields_dict",
-    "filters",
-    "frozen",
-    "has",
-    "inspect",
-    "make_class",
-    "mutable",
-    "resolve_types",
-    "setters",
-    "validate",
-    "validators",
-]
-
-__getattr__ = _make_getattr(__name__)
@@ -1,314 +0,0 @@
-import sys
-
-from typing import (
-    Any,
-    Callable,
-    Mapping,
-    Sequence,
-    overload,
-    TypeVar,
-)
-
-# Because we need to type our own stuff, we have to make everything from
-# attr explicitly public too.
-from attr import __author__ as __author__
-from attr import __copyright__ as __copyright__
-from attr import __description__ as __description__
-from attr import __email__ as __email__
-from attr import __license__ as __license__
-from attr import __title__ as __title__
-from attr import __url__ as __url__
-from attr import __version__ as __version__
-from attr import __version_info__ as __version_info__
-from attr import assoc as assoc
-from attr import Attribute as Attribute
-from attr import AttrsInstance as AttrsInstance
-from attr import cmp_using as cmp_using
-from attr import converters as converters
-from attr import Converter as Converter
-from attr import evolve as evolve
-from attr import exceptions as exceptions
-from attr import Factory as Factory
-from attr import fields as fields
-from attr import fields_dict as fields_dict
-from attr import filters as filters
-from attr import has as has
-from attr import make_class as make_class
-from attr import NOTHING as NOTHING
-from attr import resolve_types as resolve_types
-from attr import setters as setters
-from attr import validate as validate
-from attr import validators as validators
-from attr import attrib, asdict as asdict, astuple as astuple
-from attr import NothingType as NothingType
-
-if sys.version_info >= (3, 11):
-    from typing import dataclass_transform
-else:
-    from typing_extensions import dataclass_transform
-
-_T = TypeVar("_T")
-_C = TypeVar("_C", bound=type)
-
-_EqOrderType = bool | Callable[[Any], Any]
-_ValidatorType = Callable[[Any, "Attribute[_T]", _T], Any]
-_CallableConverterType = Callable[[Any], Any]
-_ConverterType = _CallableConverterType | Converter[Any, Any]
-_ReprType = Callable[[Any], str]
-_ReprArgType = bool | _ReprType
-_OnSetAttrType = Callable[[Any, "Attribute[Any]", Any], Any]
-_OnSetAttrArgType = _OnSetAttrType | list[_OnSetAttrType] | setters._NoOpType
-_FieldTransformer = Callable[
-    [type, list["Attribute[Any]"]], list["Attribute[Any]"]
-]
-# FIXME: in reality, if multiple validators are passed they must be in a list
-# or tuple, but those are invariant and so would prevent subtypes of
-# _ValidatorType from working when passed in a list or tuple.
-_ValidatorArgType = _ValidatorType[_T] | Sequence[_ValidatorType[_T]]
-
-@overload
-def field(
-    *,
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool | None = ...,
-    eq: bool | None = ...,
-    order: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-    type: type | None = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def field(
-    *,
-    default: None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType, ...]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-    type: type | None = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def field(
-    *,
-    default: _T,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType, ...]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-    type: type | None = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def field(
-    *,
-    default: _T | None = ...,
-    validator: _ValidatorArgType[_T] | None = ...,
-    repr: _ReprArgType = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    metadata: Mapping[Any, Any] | None = ...,
-    converter: _ConverterType
-    | list[_ConverterType]
-    | tuple[_ConverterType, ...]
-    | None = ...,
-    factory: Callable[[], _T] | None = ...,
-    kw_only: bool | None = ...,
-    eq: _EqOrderType | None = ...,
-    order: _EqOrderType | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    alias: str | None = ...,
-    type: type | None = ...,
-) -> Any: ...
-@overload
-@dataclass_transform(field_specifiers=(attrib, field))
-def define(
-    maybe_cls: _C,
-    *,
-    these: dict[str, Any] | None = ...,
-    repr: bool = ...,
-    unsafe_hash: bool | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: bool | None = ...,
-    order: bool | None = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-) -> _C: ...
-@overload
-@dataclass_transform(field_specifiers=(attrib, field))
-def define(
-    maybe_cls: None = ...,
-    *,
-    these: dict[str, Any] | None = ...,
-    repr: bool = ...,
-    unsafe_hash: bool | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: bool | None = ...,
-    order: bool | None = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-) -> Callable[[_C], _C]: ...
-
-mutable = define
-
-@overload
-@dataclass_transform(frozen_default=True, field_specifiers=(attrib, field))
-def frozen(
-    maybe_cls: _C,
-    *,
-    these: dict[str, Any] | None = ...,
-    repr: bool = ...,
-    unsafe_hash: bool | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: bool | None = ...,
-    order: bool | None = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-) -> _C: ...
-@overload
-@dataclass_transform(frozen_default=True, field_specifiers=(attrib, field))
-def frozen(
-    maybe_cls: None = ...,
-    *,
-    these: dict[str, Any] | None = ...,
-    repr: bool = ...,
-    unsafe_hash: bool | None = ...,
-    hash: bool | None = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: bool | None = ...,
-    order: bool | None = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: bool | None = ...,
-    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: _FieldTransformer | None = ...,
-    match_args: bool = ...,
-) -> Callable[[_C], _C]: ...
-
-class ClassProps:
-    # XXX: somehow when defining/using enums Mypy starts looking at our own
-    # (untyped) code and causes tons of errors.
-    Hashability: Any
-    KeywordOnly: Any
-
-    is_exception: bool
-    is_slotted: bool
-    has_weakref_slot: bool
-    is_frozen: bool
-    # kw_only: ClassProps.KeywordOnly
-    kw_only: Any
-    collected_fields_by_mro: bool
-    added_init: bool
-    added_repr: bool
-    added_eq: bool
-    added_ordering: bool
-    # hashability: ClassProps.Hashability
-    hashability: Any
-    added_match_args: bool
-    added_str: bool
-    added_pickling: bool
-    on_setattr_hook: _OnSetAttrType | None
-    field_transformer: Callable[[Attribute[Any]], Attribute[Any]] | None
-
-    def __init__(
-        self,
-        is_exception: bool,
-        is_slotted: bool,
-        has_weakref_slot: bool,
-        is_frozen: bool,
-        # kw_only: ClassProps.KeywordOnly
-        kw_only: Any,
-        collected_fields_by_mro: bool,
-        added_init: bool,
-        added_repr: bool,
-        added_eq: bool,
-        added_ordering: bool,
-        # hashability: ClassProps.Hashability
-        hashability: Any,
-        added_match_args: bool,
-        added_str: bool,
-        added_pickling: bool,
-        on_setattr_hook: _OnSetAttrType,
-        field_transformer: Callable[[Attribute[Any]], Attribute[Any]],
-    ) -> None: ...
-    @property
-    def is_hashable(self) -> bool: ...
-
-def inspect(cls: type) -> ClassProps: ...
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.converters import *  # noqa: F403
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.exceptions import *  # noqa: F403
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.filters import *  # noqa: F403
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.setters import *  # noqa: F403
@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.validators import *  # noqa: F403
@@ -1,25 +0,0 @@
-from .converters import BaseConverter, Converter, GenConverter, UnstructureStrategy
-from .gen import override
-
-__all__ = (
-    "BaseConverter",
-    "Converter",
-    "GenConverter",
-    "UnstructureStrategy",
-    "global_converter",
-    "override",
-    "structure",
-    "structure_attrs_fromdict",
-    "structure_attrs_fromtuple",
-    "unstructure",
-)
-from cattrs import global_converter
-
-unstructure = global_converter.unstructure
-structure = global_converter.structure
-structure_attrs_fromtuple = global_converter.structure_attrs_fromtuple
-structure_attrs_fromdict = global_converter.structure_attrs_fromdict
-register_structure_hook = global_converter.register_structure_hook
-register_structure_hook_func = global_converter.register_structure_hook_func
-register_unstructure_hook = global_converter.register_unstructure_hook
-register_unstructure_hook_func = global_converter.register_unstructure_hook_func
@@ -1,8 +0,0 @@
-from cattrs.converters import (
-    BaseConverter,
-    Converter,
-    GenConverter,
-    UnstructureStrategy,
-)
-
-__all__ = ["BaseConverter", "Converter", "GenConverter", "UnstructureStrategy"]
@@ -1,3 +0,0 @@
-from cattrs.disambiguators import create_uniq_field_dis_func
-
-__all__ = ["create_uniq_field_dis_func"]
@@ -1,3 +0,0 @@
-from cattrs.dispatch import FunctionDispatch, MultiStrategyDispatch
-
-__all__ = ["FunctionDispatch", "MultiStrategyDispatch"]
@@ -1,15 +0,0 @@
-from cattrs.errors import (
-    BaseValidationError,
-    ClassValidationError,
-    ForbiddenExtraKeysError,
-    IterableValidationError,
-    StructureHandlerNotFoundError,
-)
-
-__all__ = [
-    "BaseValidationError",
-    "ClassValidationError",
-    "ForbiddenExtraKeysError",
-    "IterableValidationError",
-    "StructureHandlerNotFoundError",
-]
@@ -1,21 +0,0 @@
-from cattrs.cols import iterable_unstructure_factory as make_iterable_unstructure_fn
-from cattrs.gen import (
-    make_dict_structure_fn,
-    make_dict_unstructure_fn,
-    make_hetero_tuple_unstructure_fn,
-    make_mapping_structure_fn,
-    make_mapping_unstructure_fn,
-    override,
-)
-from cattrs.gen._consts import AttributeOverride
-
-__all__ = [
-    "AttributeOverride",
-    "make_dict_structure_fn",
-    "make_dict_unstructure_fn",
-    "make_hetero_tuple_unstructure_fn",
-    "make_iterable_unstructure_fn",
-    "make_mapping_structure_fn",
-    "make_mapping_unstructure_fn",
-    "override",
-]
@@ -1,3 +0,0 @@
-from cattrs.preconf import validate_datetime
-
-__all__ = ["validate_datetime"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for bson."""
-
-from cattrs.preconf.bson import BsonConverter, configure_converter, make_converter
-
-__all__ = ["BsonConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for the stdlib json."""
-
-from cattrs.preconf.json import JsonConverter, configure_converter, make_converter
-
-__all__ = ["JsonConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for msgpack."""
-
-from cattrs.preconf.msgpack import MsgpackConverter, configure_converter, make_converter
-
-__all__ = ["MsgpackConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for orjson."""
-
-from cattrs.preconf.orjson import OrjsonConverter, configure_converter, make_converter
-
-__all__ = ["OrjsonConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for pyyaml."""
-
-from cattrs.preconf.pyyaml import PyyamlConverter, configure_converter, make_converter
-
-__all__ = ["PyyamlConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for tomlkit."""
-
-from cattrs.preconf.tomlkit import TomlkitConverter, configure_converter, make_converter
-
-__all__ = ["TomlkitConverter", "configure_converter", "make_converter"]
@@ -1,5 +0,0 @@
-"""Preconfigured converters for ujson."""
-
-from cattrs.preconf.ujson import UjsonConverter, configure_converter, make_converter
-
-__all__ = ["UjsonConverter", "configure_converter", "make_converter"]
@@ -1 +0,0 @@
-uv
@@ -1,164 +0,0 @@
-Metadata-Version: 2.4
-Name: cattrs
-Version: 26.1.0
-Summary: Composable complex class support for attrs and dataclasses.
-Project-URL: Homepage, https://catt.rs
-Project-URL: Changelog, https://catt.rs/en/latest/history.html
-Project-URL: Bug Tracker, https://github.com/python-attrs/cattrs/issues
-Project-URL: Repository, https://github.com/python-attrs/cattrs
-Project-URL: Documentation, https://catt.rs/en/stable/
-Author-email: Tin Tvrtkovic <tinchester@gmail.com>
-License: MIT
-License-File: LICENSE
-Keywords: attrs,dataclasses,serialization
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Requires-Dist: attrs>=25.4.0
-Requires-Dist: exceptiongroup>=1.1.1; python_version < '3.11'
-Requires-Dist: typing-extensions>=4.14.0
-Provides-Extra: bson
-Requires-Dist: pymongo>=4.4.0; extra == 'bson'
-Provides-Extra: cbor2
-Requires-Dist: cbor2>=5.4.6; extra == 'cbor2'
-Provides-Extra: msgpack
-Requires-Dist: msgpack>=1.0.5; extra == 'msgpack'
-Provides-Extra: msgspec
-Requires-Dist: msgspec>=0.19.0; (implementation_name == 'cpython') and extra == 'msgspec'
-Provides-Extra: orjson
-Requires-Dist: orjson>=3.11.3; (implementation_name == 'cpython') and extra == 'orjson'
-Provides-Extra: pyyaml
-Requires-Dist: pyyaml>=6.0; extra == 'pyyaml'
-Provides-Extra: tomlkit
-Requires-Dist: tomlkit>=0.11.8; extra == 'tomlkit'
-Provides-Extra: tomllib
-Requires-Dist: tomli-w>=1.1.0; extra == 'tomllib'
-Requires-Dist: tomli>=1.1.0; (python_version < '3.11') and extra == 'tomllib'
-Provides-Extra: ujson
-Requires-Dist: ujson>=5.10.0; extra == 'ujson'
-Description-Content-Type: text/markdown
-
-# *cattrs*: Flexible Object Serialization and Validation
-
-*Because validation belongs to the edges.*
-
-[![Documentation](https://img.shields.io/badge/Docs-Read%20The%20Docs-black)](https://catt.rs/)
-[![License: MIT](https://img.shields.io/badge/license-MIT-C06524)](https://github.com/hynek/stamina/blob/main/LICENSE)
-[![PyPI](https://img.shields.io/pypi/v/cattrs.svg)](https://pypi.python.org/pypi/cattrs)
-[![Supported Python Versions](https://img.shields.io/pypi/pyversions/cattrs.svg)](https://github.com/python-attrs/cattrs)
-[![Downloads](https://static.pepy.tech/badge/cattrs/month)](https://pepy.tech/project/cattrs)
-[![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Tinche/22405310d6a663164d894a2beab4d44d/raw/covbadge.json)](https://github.com/python-attrs/cattrs/actions/workflows/main.yml)
-
---
-
-<!-- begin-teaser -->
-
-**cattrs** is a Swiss Army knife for (un)structuring and validating data in Python.
-In practice, that means it converts **unstructured dictionaries** into **proper classes** and back, while **validating** their contents.
-
-<!-- end-teaser -->
-
-
-## Example
-
-<!-- begin-example -->
-
-_cattrs_ works best with [_attrs_](https://www.attrs.org/) classes, and [dataclasses](https://docs.python.org/3/library/dataclasses.html) where simple (un-)structuring works out of the box, even for nested data, without polluting your data model with serialization details:
-
-```python
->>> from attrs import define
->>> from cattrs import structure, unstructure
->>> @define
-... class C:
-...     a: int
-...     b: list[str]
->>> instance = structure({'a': 1, 'b': ['x', 'y']}, C)
->>> instance
-C(a=1, b=['x', 'y'])
->>> unstructure(instance)
-{'a': 1, 'b': ['x', 'y']}
-```
-
-<!-- end-teaser -->
-<!-- end-example -->
-
-Have a look at [*Why *cattrs*?*](https://catt.rs/en/latest/why.html) for more examples!
-
-<!-- begin-why -->
-
-## Features
-
-### Recursive Unstructuring
-
- _attrs_ classes and dataclasses are converted into dictionaries in a way similar to `attrs.asdict()`, or into tuples in a way similar to `attrs.astuple()`.
- Enumeration instances are converted to their values.
- Other types are let through without conversion. This includes types such as integers, dictionaries, lists and instances of non-_attrs_ classes.
- Custom converters for any type can be registered using `register_unstructure_hook`.
-
-
-### Recursive Structuring
-
-Converts unstructured data into structured data, recursively, according to your specification given as a type.
-The following types are supported:
-
- `typing.Optional[T]` and its 3.10+ form, `T | None`.
- `list[T]`, `typing.List[T]`, `typing.MutableSequence[T]`, `typing.Sequence[T]` convert to lists.
- `tuple` and `typing.Tuple` (both variants, `tuple[T, ...]` and `tuple[X, Y, Z]`).
- `set[T]`, `typing.MutableSet[T]`, and `typing.Set[T]` convert to sets.
- `frozenset[T]`, and `typing.FrozenSet[T]` convert to frozensets.
- `dict[K, V]`, `typing.Dict[K, V]`, `typing.MutableMapping[K, V]`, and `typing.Mapping[K, V]` convert to dictionaries.
- [`typing.TypedDict`](https://docs.python.org/3/library/typing.html#typing.TypedDict), both ordinary and generic.
- [`typing.NewType`](https://docs.python.org/3/library/typing.html#newtype)
- [PEP 695 type aliases](https://docs.python.org/3/library/typing.html#type-aliases) on 3.12+
- _attrs_ classes with simple attributes and the usual `__init__`[^simple].
- All _attrs_ classes and dataclasses with the usual `__init__`, if their complex attributes have type metadata.
- Unions of supported _attrs_ classes, given that all of the classes have a unique field.
- Unions of anything, if you provide a disambiguation function for it.
- Custom converters for any type can be registered using `register_structure_hook`.
-
-[^simple]: Simple attributes are attributes that can be assigned unstructured data, like numbers, strings, and collections of unstructured data.
-
-
-### Batteries Included
-
-_cattrs_ comes with pre-configured converters for a number of serialization libraries, including JSON (standard library, [_orjson_](https://pypi.org/project/orjson/), [UltraJSON](https://pypi.org/project/ujson/)), [_msgpack_](https://pypi.org/project/msgpack/), [_cbor2_](https://pypi.org/project/cbor2/), [_bson_](https://pypi.org/project/bson/), [PyYAML](https://pypi.org/project/PyYAML/), [_tomlkit_](https://pypi.org/project/tomlkit/) and [_msgspec_](https://pypi.org/project/msgspec/) (supports only JSON at this time).
-
-For details, see the [cattrs.preconf package](https://catt.rs/en/stable/preconf.html).
-
-
-## Design Decisions
-
-_cattrs_ is based on a few fundamental design decisions:
-
- Un/structuring rules are separate from the models.
-  This allows models to have a one-to-many relationship with un/structuring rules, and to create un/structuring rules for models which you do not own and you cannot change.
-  (_cattrs_ can be configured to use un/structuring rules from models using the [`use_class_methods` strategy](https://catt.rs/en/latest/strategies.html#using-class-specific-structure-and-unstructure-methods).)
- Invent as little as possible; reuse existing ordinary Python instead.
-  For example, _cattrs_ did not have a custom exception type to group exceptions until the sanctioned Python [`exceptiongroups`](https://docs.python.org/3/library/exceptions.html#ExceptionGroup).
-  A side-effect of this design decision is that, in a lot of cases, when you're solving _cattrs_ problems you're actually learning Python instead of learning _cattrs_.
- Resist the temptation to guess.
-  If there are two ways of solving a problem, _cattrs_ should refuse to guess and let the user configure it themselves.
-
-A foolish consistency is the hobgoblin of little minds, so these decisions can and are sometimes broken, but they have proven to be a good foundation.
-
-
-<!-- end-why -->
-
-## Credits
-
-Major credits to Hynek Schlawack for creating [attrs](https://attrs.org) and its predecessor, [characteristic](https://github.com/hynek/characteristic).
-
-_cattrs_ is tested with [Hypothesis](http://hypothesis.readthedocs.io/en/latest/), by David R. MacIver.
-
-_cattrs_ is benchmarked using [perf](https://github.com/haypo/perf) and [pytest-benchmark](https://pytest-benchmark.readthedocs.io/en/latest/index.html).
-
-This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [`audreyr/cookiecutter-pypackage`](https://github.com/audreyr/cookiecutter-pypackage) project template.
@@ -1,58 +0,0 @@
-cattr/__init__.py,sha256=bYrmwTYSdYC_ut1xW31V7mxhXBlJQKs8EECgtUBgAuc,906
-cattr/converters.py,sha256=rQhY4J8r7QTZh5WICuFe4GWO1v0DS3DgQ9r569zd6jg,192
-cattr/disambiguators.py,sha256=ugD1fq1Z5x1pGu5P1lMzcT-IEi1q7IfQJIHEdmg62vM,103
-cattr/dispatch.py,sha256=uVEOgHWR9Hn5tm-wIw-bDccqrxJByVi8yRKaYyvL67k,125
-cattr/errors.py,sha256=V4RhoCObwGrlaM3oyn1H_FYxGR8iAB9dG5NxFDYM548,343
-cattr/gen.py,sha256=hWyKoZ_d2D36Jz_npspyGw8s9pWtUA69sXf0R3uOvgM,597
-cattr/preconf/__init__.py,sha256=NqPE7uhVfcP-PggkUpsbfAutMo8oHjcoB1cvjgLft-s,78
-cattr/preconf/bson.py,sha256=Bn4hJxac7OthGg_CR4LCPeBp_fz4kx3QniBVOZhguGs,195
-cattr/preconf/json.py,sha256=LpqYuO3oePDxbQtKFKB0SaoeAi3Z_agIgyNn1VQSIVo,206
-cattr/preconf/msgpack.py,sha256=pyJ9L9ekNlZ0IQHbJ9Ay_fi_NOqY5_rE_q-UnD94-RM,207
-cattr/preconf/orjson.py,sha256=Adh-7csx4eqCjx22zipMFgSlDXbR554wvgNHEb8Q5JM,203
-cattr/preconf/pyyaml.py,sha256=Fy40bejjp7uqgoLhTA_p4wZYF0uFaguHbUK9zs9LoC0,203
-cattr/preconf/tomlkit.py,sha256=_gADJ_UYpj3EiNXGYjAfSOkcoFIkLpYVOFfLEqBfIJQ,207
-cattr/preconf/ujson.py,sha256=IzEa7QUcYOaSUMiLQsFEWJnBihmmOLhehsM-5cPY9NI,199
-cattr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cattrs-26.1.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
-cattrs-26.1.0.dist-info/METADATA,sha256=d94QudQ0gM0Zy_KNPtL7n2gEea7s-Vir2t4_rLD4zLA,8542
-cattrs-26.1.0.dist-info/RECORD,,
-cattrs-26.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cattrs-26.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cattrs-26.1.0.dist-info/licenses/LICENSE,sha256=9fudHt43qIykf0IMSZ3KD0oFvJk-Esd9I1IKrSkcAb8,1074
-cattrs/__init__.py,sha256=UhiFdxf81gCuBBA6FutoE1oOzthzF_PkAdoE2AVslIo,1901
-cattrs/_compat.py,sha256=5dOpD6O8zUVZcreaJ5wSt9n-Nut4n79ibrka5Td6l84,12251
-cattrs/_generics.py,sha256=ERYo_kX-Z6UiwOcYI3WLrlHO6Ya66c_whpko6es5UeI,966
-cattrs/cols.py,sha256=-KmFikvZu7cL_g68ytx0Ad6danfjVY5Ry3w1XRtTaWk,10336
-cattrs/converters.py,sha256=BPpSPuhMuhQz2qFl_OAeIZ8CrI95A8gy6khuvU35bN8,55322
-cattrs/disambiguators.py,sha256=uydD6QXPve1-0dY_3m_FoyOqowvTvEKXzrdb-5xkRPE,6863
-cattrs/dispatch.py,sha256=9qA-pmsPvgrM6MGP8Ev2gVP6YL2rXvoBla_C0VgHxQ0,6780
-cattrs/enums.py,sha256=noADdwXP9TSpyIyjE6WR2iIbGPmigirvArKAoHWJmDI,1130
-cattrs/errors.py,sha256=CLW6Uev31cOxo6cWFb0-g-FAbYJD2mYmR5xTxDIVjDw,4344
-cattrs/fns.py,sha256=z5z1VZOZv8t5LwG8cBM_tIXg-_PlQUOyZb9wIrXNqlw,626
-cattrs/gen/__init__.py,sha256=wrmi87jGEfmWcbbNkZXk1Gqn9PLwXerKUDJoCQBCRek,42553
-cattrs/gen/_consts.py,sha256=ZwT_m2J3S7p-UjltpbA1WtfQZLNj9KhmFYCAv6Zl-g0,511
-cattrs/gen/_generics.py,sha256=_DyXCGql2QIxGhAv3_B1hsi80uPK8PhK2hhZa95YOlo,3011
-cattrs/gen/_lc.py,sha256=4fjeUsmgQcCAIjnNndBic0gf5qKmxVS3CZHqUQ9Rw5g,882
-cattrs/gen/_shared.py,sha256=QctJIsgfhZqgdALdD-L9FUEX1k2uNUpJQW4NbcGLVWQ,2747
-cattrs/gen/typeddicts.py,sha256=svG8RjqNt411KzkRFEKp6zsJHJvrwZNe1UQIhQewv7w,22085
-cattrs/literals.py,sha256=0kzAewmWk9ikJGoKq4ysnAR22DMawG3iNqLl8NLgpk0,331
-cattrs/preconf/__init__.py,sha256=YMY1ADc7OzpuZ2cdQZbH5kUKZF30UYd6owf3BOT4TO0,1435
-cattrs/preconf/bson.py,sha256=I0632WE3L7VN5aA9T3PJ1Jq_iy5XOfTsjJcKjQSEMAM,4211
-cattrs/preconf/cbor2.py,sha256=o13uyALyX2dvxp6HRYq_xHeB84nEGyBOB0V8OcohY30,2035
-cattrs/preconf/json.py,sha256=JiAetUezqQ_ixjRydLCavkvnIQxQCTyQXKzViC-vO6A,2644
-cattrs/preconf/msgpack.py,sha256=12c3sE5tfIVVhxHD4QmZaSGmxTvwHfrtTdk0ohOCcLI,2338
-cattrs/preconf/msgspec.py,sha256=Hea-jCkcqH7wtONAHjpe9EaaqhGodQFfkLtKuWdV09k,7384
-cattrs/preconf/orjson.py,sha256=o1GZwvH2hlLbovmsB7OH3fDkcROhHOAQKMsrDW3VTsY,3883
-cattrs/preconf/pyyaml.py,sha256=w0aM_gJ6VhZf-Zpu_UlJki7rdgv4mfaSXElPofB3nlE,2378
-cattrs/preconf/tomlkit.py,sha256=sPrBZgq7Zg78y31SAPhBuSWQllGxXXysyI-2-T6MY6U,3311
-cattrs/preconf/tomllib.py,sha256=wDOhVcIkBR0bw5zMACPlUcf2YXv-eamgg-GmGdv4cSU,3083
-cattrs/preconf/ujson.py,sha256=ev1fdMvQdP-PSDqDbJ714Oy3Xxi2lbc6qVSZ-LGdgKg,2438
-cattrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cattrs/strategies/__init__.py,sha256=nkZWCzSRYcS-75FMfk52mioZSuWykaN8hB39Vig5Xkg,339
-cattrs/strategies/_class_methods.py,sha256=O5xhQCzNpuFiDNDMlbcyeOVqyrV65NhMZNRsG3jnoBU,2591
-cattrs/strategies/_subclasses.py,sha256=8fTr7CLbNlV2Nobi0yXkQ9OKpGyUENmEzyYAsy4SDJw,9852
-cattrs/strategies/_unions.py,sha256=XQwrnPEE7KhBqOy5vyUZ06reQPfqcO85jdVjQ7i3HFk,10070
-cattrs/subclasses.py,sha256=SyAaJ84sO3aen_dBQkuSAIg0eGOXYX-aF151d7IbiNk,783
-cattrs/typealiases.py,sha256=toHavC2kJsIcxThwvATPO5JShzKeC8kIl9KqteFohbw,1619
-cattrs/types.py,sha256=cqvfmzliYfrvPswxlW_tN4DmhQ2xpAKQvVbNBJaxiWs,278
-cattrs/v.py,sha256=IqUajgJFCKJYf-4S9TCKRtJcmmK4c3En69TGuf2FKOs,4126
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Christoph	f44539ec2f	Auto stash before rebase of "relpace_lsp_with_rust" onto "origin/relpace_lsp_with_rust"	2025-11-16 20:55:25 +01:00
Christoph	7a3e3ae9f7	test rust lsp	2025-09-07 07:18:18 +02:00
				`@@ -0,0 +1 @@`
				`{"root":["./src/extension.ts","./src/common/handlers.ts","./src/common/log/logging.ts"],"version":"5.7.2"}`