@gram-data/tree-sitter-gram 0.3.4 → 0.3.6

package/bindings/node/binding_test.js

@@ -8,30 +8,29 @@ test("can load grammar", () => {
   assert.doesNotThrow(() => parser.setLanguage(require(".")));
 });
 
-test("annotation node kinds: identified_annotation and property_annotation", () => {
+test("parses a simple node pattern", () => {
   const Parser = require("tree-sitter");
   const GramLang = require(".");
   const parser = new Parser();
   parser.setLanguage(GramLang);
 
-  const annotated = (root) => root.child(0) ?? null;
+  const tree = parser.parse("(a)");
+  const pattern = tree.rootNode.child(0);
+  assert(pattern, "root should have a pattern child");
 
-  const withIdentified = parser.parse("@@p (a)");
-  const ap1 = annotated(withIdentified.rootNode);
-  assert(ap1?.type === "annotated_pattern", "root should have annotated_pattern child");
-  const annotations1 = ap1.childForFieldName("annotations");
-  assert(annotations1, "annotations node should exist");
-  const first1 = annotations1.child(0);
-  assert.strictEqual(first1?.type, "identified_annotation", "@@ form should be identified_annotation");
-  assert(first1?.childForFieldName("identifier"), "identified_annotation should have identifier field");
+  // Find the symbol 'a' in the pattern
+  function findSymbol(node, text) {
+    if (node.isNamed && node.type === "symbol" && node.text === text) {
+      return node;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const result = findSymbol(node.child(i), text);
+      if (result) return result;
+    }
+    return null;
+  }
 
-  const withProperty = parser.parse("@x(1) ()");
-  const ap2 = annotated(withProperty.rootNode);
-  assert(ap2?.type === "annotated_pattern", "root should have annotated_pattern child");
-  const annotations2 = ap2.childForFieldName("annotations");
-  assert(annotations2, "annotations node should exist");
-  const first2 = annotations2.child(0);
-  assert.strictEqual(first2?.type, "property_annotation", "@ form should be property_annotation");
-  assert(first2?.childForFieldName("key"), "property_annotation should have key field");
-  assert(first2?.childForFieldName("value"), "property_annotation should have value field");
+  const symbol = findSymbol(pattern, "a");
+  assert(symbol, "pattern should contain symbol 'a'");
+  assert.strictEqual(symbol.type, "symbol");
 });

package/editors/zed/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gram_zed_extension"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+repository = "https://github.com/gram-data/tree-sitter-gram"
+build = "build.rs"
+
+[lib]
+path = "src/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.7"
+
+# Standalone workspace root so this crate is not treated as a stray member of the
+# repository workspace (see root `Cargo.toml` `[workspace]`).
+[workspace]
+members = ["."]

package/editors/zed/README.md

@@ -5,6 +5,7 @@ A [Zed](https://zed.dev) extension providing syntax highlighting and language su
 ## Features
 
 - **Syntax Highlighting**: Full syntax highlighting for all Gram constructs including subjects, nodes, relationships, and data types
+- **Language server**: When [`gram-lsp`](../../tools/lsp/) is on your `PATH`, Zed starts it for `.gram` files (diagnostics, hover, definitions, references, completions)
 - **Subject Pattern Matching**: Automatic matching for `()`, `[]`, and `{}`
 - **File Type Detection**: Automatic recognition of `.gram` files
 - **Smart Indentation**: Proper indentation handling for nested structures
@@ -40,7 +41,7 @@ Then restart Zed.
 
 ## Usage
 
-Once installed, the extension automatically provides syntax highlighting for any file with a `.gram` extension.
+Once installed, the extension provides syntax highlighting for `.gram` files. With `gram-lsp` installed and on `PATH`, Zed also attaches the language server automatically.
 
 ### Example Gram Syntax
 
@@ -108,14 +109,25 @@ To work on this extension:
    - Select the `editors/zed` directory
    - Restart Zed
 
-3. Make changes to the extension files
-4. Restart Zed to see changes
+3. Build the Wasm extension once after Rust changes (Zed loads the cdylib):
+
+   ```bash
+   rustup target add wasm32-wasip1
+   cd editors/zed && cargo check --target wasm32-wasip1
+   ```
+
+4. Make changes to the extension files
+5. Restart Zed to see changes
 
 ### Extension Structure
 
 ```
 editors/zed/
-├── extension.toml          # Extension metadata; points at grammar repo (repository + rev)
+├── Cargo.toml              # Wasm extension crate (zed_extension_api)
+├── build.rs                # Embeds `extension.toml` version for release asset lookup
+├── Cargo.lock
+├── src/lib.rs              # `language_server_command`: PATH, then GitHub release download
+├── extension.toml          # Extension metadata; grammar repo + `[language_servers.gram-lsp]`
 ├── languages/
 │   └── gram/
 │       ├── config.toml     # Zed language config (brackets, suffixes, etc.)
@@ -144,6 +156,12 @@ After either command, `extension.toml` is updated in place. For local dev you ty
 
 **If Zed shows an old version (e.g. 0.1.11) after installing the dev extension:** Zed may be using a cached clone of the grammar (at an old rev) or an older copy of the extension. Try: (1) Uninstall the Gram extension from Zed’s Extensions panel. (2) Delete the grammar cache: remove `editors/zed/grammars/` if it exists (Zed recreates it when needed). (3) Run `npm run zed:dev` again so `extension.toml` has the current version and rev. (4) In Zed, run “Install Dev Extension” and select `editors/zed` again. Restart Zed and recheck the extension version.
 
+### Bundled `gram-lsp` (GitHub Releases)
+
+Zed extensions ship a **Wasm** adapter only; native `gram-lsp` binaries cannot be embedded in that bundle. Instead, when `gram-lsp` is **not** on `PATH`, the extension downloads a platform archive from **this repo’s GitHub Release** whose tag is **`v` + `version` from `extension.toml`** (for example `v0.3.5` for `version = "0.3.5"`).
+
+Maintainers: pushing a **`v*`** tag runs **`.github/workflows/gram-lsp-release-assets.yml`**, which builds `gram-lsp` for common targets and uploads `gram-lsp-{target}.tar.gz` to the matching GitHub Release. Filenames must stay in sync with `editors/zed/src/lib.rs`. Keep `extension.toml`’s `version` aligned with the tag you ship to the Zed extension registry (for example tag `v0.3.5` and `version = "0.3.5"`) so installs download the intended binaries.
+
 ## Contributing
 
 Contributions are welcome! Please see the main [repository](https://github.com/gram-data/tree-sitter-gram) for contribution guidelines.
@@ -156,7 +174,7 @@ To improve syntax highlighting and editor behavior:
 
 ## License
 
-This extension is part of the tree-sitter-gram project and is licensed under the ISC License. See the main repository's [LICENSE](../../LICENSE) file for details.
+This extension is part of the tree-sitter-gram project and is licensed under the MIT License. See the main repository's [LICENSE](../../LICENSE) file for details.
 
 ## Learn More
 

package/editors/zed/build.rs

@@ -0,0 +1,26 @@
+//! Expose `extension.toml`'s `version = "…"` as `env!("GRAM_EXT_VERSION")` for release lookups.
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR"));
+    let ext_toml = manifest_dir.join("extension.toml");
+    println!("cargo:rerun-if-changed={}", ext_toml.display());
+
+    let content = fs::read_to_string(&ext_toml).unwrap_or_else(|e| panic!("read {}: {e}", ext_toml.display()));
+    let version = parse_version(&content)
+        .unwrap_or_else(|| panic!("{}: missing `version = \"…\"` line", ext_toml.display()));
+    println!("cargo:rustc-env=GRAM_EXT_VERSION={version}");
+}
+
+fn parse_version(toml: &str) -> Option<String> {
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("version = \"") {
+            return rest.split('"').next().map(str::to_string);
+        }
+    }
+    None
+}

package/editors/zed/extension.toml

@@ -1,11 +1,16 @@
 id = "gram"
 name = "Gram Language Support"
-version = "0.3.4"
+version = "0.3.6"
 schema_version = 1
 authors = ["Gram Data Contributors"]
 description = "Support for Gram notation - composable data patterns"
 
+capabilities = [
+  { kind = "process:exec", command = "*", args = ["stdio"] },
+  { kind = "download_file", host = "github.com", path = ["gram-data", "tree-sitter-gram", "**"] },
+]
+
 # path = "grammars/tree-sitter-gram"
 [grammars.gram]
 repository = "https://github.com/gram-data/tree-sitter-gram"
-rev = "7aee4c203a5c6ea48660ae6d8af849ed90317bed"
+rev = "184b524f4a0653bee3a07c44907dc266d698cb6e"

package/editors/zed/languages/gram/config.toml

@@ -12,5 +12,5 @@ word_characters = ["_"]
 [prettier]
 allowed = false
 
-# [language_servers]
-# Add language server configuration here if you develop one for Gram
+# Language servers are declared in extension.toml (`[language_servers.gram-lsp]`)
+# and started from `src/lib.rs`. Per-server options go in Zed settings.json under `lsp`.

package/editors/zed/languages/gram/highlights.scm

@@ -21,30 +21,48 @@
 ; Reference identifier: pattern_reference (FR-001)
 (pattern_reference identifier: (_) @variable)
 
-; Definition-like identifiers (FR-001): @type
+; Symbols and identifiers (generic; definition/reference/tag captured above)
+(symbol) @variable
+
+; Definition-like identifiers and labels (FR-001): @type
+; These must come AFTER generic symbol rule to take priority
+
+; Labels (symbols and quoted names in labels nodes)
+(labels (symbol) @type)
+(labels (quoted_name) @type)
+
+; Annotation identifiers and labels
+(identified_annotation identifier: (_) @type)
+(identified_annotation labels: (labels (symbol) @type))
+(identified_annotation labels: (labels (quoted_name) @type))
+
+; Subject, node, and relationship pattern definitions (FR-001): @type
 ; subject/node subject is _subject (use wildcard _ as it may be hidden in some runtimes)
 (subject_pattern subject: (_ identifier: (_) @type))
 (subject_pattern subject: (_ labels: (labels (symbol) @type)))
+(subject_pattern subject: (_ labels: (labels (quoted_name) @type)))
 (node_pattern subject: (_ identifier: (_) @type))
 (node_pattern subject: (_ labels: (labels (symbol) @type)))
+(node_pattern subject: (_ labels: (labels (quoted_name) @type)))
 (relationship_pattern left: (node_pattern subject: (_ identifier: (_) @type)))
 (relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern right: (node_pattern subject: (_ identifier: (_) @type)))
 (relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
 ; Arrow kind: subject is inside optional brackets on the arrow
 (relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @type))))
-(identified_annotation identifier: (_) @type)
-(identified_annotation labels: (labels (symbol) @type))
-
-; Symbols and identifiers (generic; definition/reference/tag captured above)
-(symbol) @variable
+(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @type))))
 
 ; Keywords and operators
 [
@@ -71,11 +89,11 @@
 
 ; Field names in records and maps
 (record_property key: (symbol) @property)
-(record_property key: (string_literal) @property)
-(record_property key: (integer) @property)
+(record_property key: (quoted_name) @property)
+(record_property key: (double_quoted_name) @property)
 (map_entry key: (symbol) @property)
-(map_entry key: (string_literal) @property)
-(map_entry key: (integer) @property)
+(map_entry key: (quoted_name) @property)
+(map_entry key: (double_quoted_name) @property)
 
 ; Annotation keys (property-style) and headers (identified/label-style)
 (property_annotation key: (symbol) @attribute)

package/editors/zed/languages/gram/locals.scm

@@ -7,22 +7,31 @@
 ; Definitions: identifiers that define a pattern or annotation
 (subject_pattern subject: (_ identifier: (_) @local.definition))
 (subject_pattern subject: (_ labels: (labels (symbol) @local.definition)))
+(subject_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
 (node_pattern subject: (_ identifier: (_) @local.definition))
 (node_pattern subject: (_ labels: (labels (symbol) @local.definition)))
+(node_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
 (relationship_pattern left: (node_pattern subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern right: (node_pattern subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (identified_annotation identifier: (_) @local.definition)
 (identified_annotation labels: (labels (symbol) @local.definition))
+(identified_annotation labels: (labels (quoted_name) @local.definition))
 
 ; References: pattern_reference identifier
 (pattern_reference identifier: (_) @local.reference)

package/editors/zed/src/lib.rs

@@ -0,0 +1,156 @@
+//! Zed extension host glue: starts `gram-lsp` from `PATH` or downloads a release asset.
+
+use zed_extension_api::{
+    self as zed,
+    github_release_by_tag_name,
+    set_language_server_installation_status,
+    Architecture, Command, DownloadedFileType, Extension, LanguageServerId,
+    LanguageServerInstallationStatus, Os, Result, Worktree, current_platform, download_file,
+    make_file_executable,
+};
+
+const GRAM_REPO: &str = "gram-data/tree-sitter-gram";
+
+struct GramExtension {
+    /// Relative path (under the extension work dir) or absolute path from `which`.
+    cached_binary: Option<String>,
+}
+
+impl GramExtension {
+    fn rust_target_triple() -> Result<&'static str> {
+        match current_platform() {
+            (Os::Mac, Architecture::Aarch64) => Ok("aarch64-apple-darwin"),
+            (Os::Mac, Architecture::X8664) => Ok("x86_64-apple-darwin"),
+            (Os::Linux, Architecture::Aarch64) => Ok("aarch64-unknown-linux-gnu"),
+            (Os::Linux, Architecture::X8664) => Ok("x86_64-unknown-linux-gnu"),
+            (Os::Windows, Architecture::Aarch64) => Ok("aarch64-pc-windows-msvc"),
+            (Os::Windows, Architecture::X8664) => Ok("x86_64-pc-windows-msvc"),
+            (Os::Linux, Architecture::X86) | (Os::Windows, Architecture::X86) => Err(
+                "gram-lsp: 32-bit platforms are not supported; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+            (Os::Mac, Architecture::X86) => Err(
+                "gram-lsp: unexpected macOS x86 architecture; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+        }
+    }
+
+    fn gram_lsp_bin_name(os: Os) -> &'static str {
+        match os {
+            Os::Windows => "gram-lsp.exe",
+            Os::Mac | Os::Linux => "gram-lsp",
+        }
+    }
+
+    fn ensure_downloaded(
+        &mut self,
+        language_server_id: &LanguageServerId,
+    ) -> Result<String> {
+        let version = env!("GRAM_EXT_VERSION");
+        let extract_dir = format!("gram-lsp-{version}");
+        let (os, _) = current_platform();
+        let bin_name = Self::gram_lsp_bin_name(os);
+        let relative_binary = format!("{extract_dir}/{bin_name}");
+
+        let triple = Self::rust_target_triple()?;
+        let asset_name = format!("gram-lsp-{triple}.tar.gz");
+        let tag = format!("v{version}");
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::Downloading,
+        );
+
+        let release = match github_release_by_tag_name(GRAM_REPO, &tag) {
+            Ok(r) => r,
+            Err(e) => {
+                let detail = format!(
+                    "GitHub release {tag}: {e}. Install `gram-lsp` on PATH or publish release assets (see .github/workflows/gram-lsp-release-assets.yml)."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(detail.clone()),
+                );
+                return Err(format!("gram-lsp: no GitHub release for {tag}: {e}"));
+            }
+        };
+
+        let asset = match release.assets.iter().find(|a| a.name == asset_name) {
+            Some(a) => a,
+            None => {
+                let msg = format!(
+                    "gram-lsp: release {tag} has no asset {asset_name}. Build with the gram-lsp-release-assets workflow."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(msg.clone()),
+                );
+                return Err(msg);
+            }
+        };
+
+        if let Err(e) = download_file(
+            &asset.download_url,
+            &extract_dir,
+            DownloadedFileType::GzipTar,
+        ) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: download failed: {e}"));
+        }
+
+        if let Err(e) = make_file_executable(&relative_binary) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: chmod failed: {e}"));
+        }
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::None,
+        );
+
+        self.cached_binary = Some(relative_binary.clone());
+        Ok(relative_binary)
+    }
+}
+
+impl Extension for GramExtension {
+    fn new() -> Self {
+        Self {
+            cached_binary: None,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &Worktree,
+    ) -> Result<Command> {
+        if language_server_id.as_ref() != "gram-lsp" {
+            return Err(format!(
+                "unsupported language server id: {}",
+                language_server_id.as_ref()
+            ));
+        }
+
+        if let Some(path) = &self.cached_binary {
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        if let Some(path) = worktree.which("gram-lsp") {
+            self.cached_binary = Some(path.clone());
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        let path = self.ensure_downloaded(language_server_id)?;
+        Ok(Command::new(path).arg("stdio"))
+    }
+}
+
+zed::register_extension!(GramExtension);

package/grammar.js

@@ -69,7 +69,7 @@ module.exports = grammar({
 
     pattern_reference: ($) => field("identifier", $._identifier),
 
-    _identifier: ($) => choice($.symbol, $.string_literal, $.integer),
+    _identifier: ($) => choice($.symbol, $.quoted_name, $.integer),
 
     _subject: ($) =>
       choice(
@@ -114,13 +114,13 @@ module.exports = grammar({
 
     labels: ($) => repeat1($._label),
 
-    _label: ($) => seq(choice(":", "::"), $.symbol),
+    _label: ($) => seq(choice(":", "::"), choice($.symbol, $.quoted_name)),
 
     record: ($) => seq("{", commaSep($.record_property), "}"),
 
     record_property: ($) =>
       seq(
-        field("key", $._identifier),
+        field("key", $._key_name),
         choice(":", "::"),
         field("value", $._value),
       ),
@@ -128,7 +128,7 @@ module.exports = grammar({
     map: ($) => seq("{", commaSep($.map_entry), "}"),
 
     map_entry: ($) =>
-      seq(field("key", $._identifier), ":", field("value", $._scalar_value)),
+      seq(field("key", $._key_name), ":", field("value", $._scalar_value)),
 
     symbol: ($) => token(/[a-zA-Z_][0-9a-zA-Z_.\-@]*/),
 
@@ -174,6 +174,15 @@ module.exports = grammar({
       return token(measurement);
     },
 
+    quoted_name: ($) =>
+      delimit_string(alias($._backticked_text, $.string_content), "`"),
+
+    double_quoted_name: ($) =>
+      delimit_string(alias($._double_quoted_text, $.string_content), '"'),
+
+    _key_name: ($) =>
+      choice($.symbol, $.quoted_name, $.double_quoted_name),
+
     string_literal: ($) =>
       choice(
         $._single_quoted_string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gram-data/tree-sitter-gram",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "subject-oriented notation for structured data",
   "homepage": "https://gram-data.github.io",
   "repository": {

package/queries/highlights.scm

@@ -21,30 +21,48 @@
 ; Reference identifier: pattern_reference (FR-001)
 (pattern_reference identifier: (_) @variable)
 
-; Definition-like identifiers (FR-001): @type
+; Symbols and identifiers (generic; definition/reference/tag captured above)
+(symbol) @variable
+
+; Definition-like identifiers and labels (FR-001): @type
+; These must come AFTER generic symbol rule to take priority
+
+; Labels (symbols and quoted names in labels nodes)
+(labels (symbol) @type)
+(labels (quoted_name) @type)
+
+; Annotation identifiers and labels
+(identified_annotation identifier: (_) @type)
+(identified_annotation labels: (labels (symbol) @type))
+(identified_annotation labels: (labels (quoted_name) @type))
+
+; Subject, node, and relationship pattern definitions (FR-001): @type
 ; subject/node subject is _subject (use wildcard _ as it may be hidden in some runtimes)
 (subject_pattern subject: (_ identifier: (_) @type))
 (subject_pattern subject: (_ labels: (labels (symbol) @type)))
+(subject_pattern subject: (_ labels: (labels (quoted_name) @type)))
 (node_pattern subject: (_ identifier: (_) @type))
 (node_pattern subject: (_ labels: (labels (symbol) @type)))
+(node_pattern subject: (_ labels: (labels (quoted_name) @type)))
 (relationship_pattern left: (node_pattern subject: (_ identifier: (_) @type)))
 (relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern right: (node_pattern subject: (_ identifier: (_) @type)))
 (relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @type))))
 ; Arrow kind: subject is inside optional brackets on the arrow
 (relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @type))))
+(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @type))))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @type)))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @type))))
-(identified_annotation identifier: (_) @type)
-(identified_annotation labels: (labels (symbol) @type))
-
-; Symbols and identifiers (generic; definition/reference/tag captured above)
-(symbol) @variable
+(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @type))))
 
 ; Keywords and operators
 [
@@ -71,11 +89,11 @@
 
 ; Field names in records and maps
 (record_property key: (symbol) @property)
-(record_property key: (string_literal) @property)
-(record_property key: (integer) @property)
+(record_property key: (quoted_name) @property)
+(record_property key: (double_quoted_name) @property)
 (map_entry key: (symbol) @property)
-(map_entry key: (string_literal) @property)
-(map_entry key: (integer) @property)
+(map_entry key: (quoted_name) @property)
+(map_entry key: (double_quoted_name) @property)
 
 ; Annotation keys (property-style) and headers (identified/label-style)
 (property_annotation key: (symbol) @attribute)

package/queries/locals.scm

@@ -7,22 +7,31 @@
 ; Definitions: identifiers that define a pattern or annotation
 (subject_pattern subject: (_ identifier: (_) @local.definition))
 (subject_pattern subject: (_ labels: (labels (symbol) @local.definition)))
+(subject_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
 (node_pattern subject: (_ identifier: (_) @local.definition))
 (node_pattern subject: (_ labels: (labels (symbol) @local.definition)))
+(node_pattern subject: (_ labels: (labels (quoted_name) @local.definition)))
 (relationship_pattern left: (node_pattern subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern left: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern left: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern right: (node_pattern subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern right: (node_pattern subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern right: (node_pattern subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (right_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (right_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (right_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (left_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (left_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (left_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (undirected_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (undirected_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ identifier: (_) @local.definition)))
 (relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (symbol) @local.definition))))
+(relationship_pattern kind: (bidirectional_arrow subject: (_ labels: (labels (quoted_name) @local.definition))))
 (identified_annotation identifier: (_) @local.definition)
 (identified_annotation labels: (labels (symbol) @local.definition))
+(identified_annotation labels: (labels (quoted_name) @local.definition))
 
 ; References: pattern_reference identifier
 (pattern_reference identifier: (_) @local.reference)