bridge-syntax-highlight 0.8.0

package/.depcheckrc

@@ -0,0 +1,7 @@
+{
+  "ignores": [
+    "@tsconfig/node22",
+    "typescript",
+    "vscode"
+  ]
+}

package/.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+      "preLaunchTask": "build"
+    }
+  ]
+}

package/.vscode/tasks.json

@@ -0,0 +1,12 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build",
+      "type": "shell",
+      "command": "node build.mjs",
+      "group": { "kind": "build", "isDefault": true },
+      "problemMatcher": []
+    }
+  ]
+}

package/.vscodeignore

@@ -0,0 +1,7 @@
+.vscode/**
+.vscode-test/**
+.gitignore
+build.mjs
+tsconfig.json
+src/**
+build/*.map

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Change Log
+
+All notable changes to the "bridge" extension will be documented in this file.
+
+## [0.5.0] - 2026-02-21
+
+### Added
+
+- **Language Server** with real-time diagnostics and hover information
+- Syntax error diagnostics powered by Chevrotain parser with error recovery (partial AST even on broken files)
+- Semantic diagnostics: undeclared handles, unsatisfied `with` dependencies
+- Hover provider: hover over any handle, dependency, or wire name to see its type and declaration context
+
+## [0.0.1] - 2026-02-21
+
+### Added
+
+- Syntax highlighting for Bridge language version 1.5
+- Support for all top-level blocks: `version`, `const`, `tool`, `define`, `bridge`
+- Wire operator highlighting: `<-`, `||`, `??`, `catch`, `:`
+- Array mapping syntax: `source[] as iter { … }`
+- Constant assignment highlighting: `.property = value`
+- Built-in handle highlighting: `input`, `output`, `context`
+- HTTP method constants: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, etc.
+- Unquoted URL path values (e.g. `/search`, `/forecast`)
+- `on error` fallback declarations
+- Block brace matching
+- Comment support (`#` line comments)
+- String, number, and boolean literal highlighting
+- `language-configuration.json` for bracket matching and comment toggling

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stackables
+
+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.

package/README.md

@@ -0,0 +1,61 @@
+# The Bridge Language — VS Code Extension
+
+Full IDE support for [The Bridge](https://github.com/stackables/bridge): a declarative dataflow language for GraphQL. Wire data between APIs and schema fields using `.bridge` files — no resolvers, no codegen, no plumbing.
+
+![Bridge syntax highlighting and language server in action](./docs/images/syntax-image.png)
+
+## Features
+
+### Language Server (LSP)
+
+- **Real-time diagnostics** — syntax errors and semantic issues highlighted as you type
+- **Semantic validation** — undeclared handles, unsatisfied `with` dependencies, and unknown wire targets flagged immediately
+- **Hover information** — hover over any handle, dependency, or declaration to see its type and source
+  - Bridge hover: type/field name, handle count, wire count
+  - Tool hover: function name, deps, wires
+  - Define hover: subgraph details
+  - Const hover: name and raw value
+- Error recovery — partial AST is built even on broken files, so diagnostics remain accurate while you're mid-edit
+
+### Syntax Highlighting
+
+- Full syntax highlighting for `.bridge` files (language version 1.5)
+- Block keyword highlighting: `version`, `const`, `tool`, `define`, `bridge`
+- Wire operator colouring: `<-` (pull), `||` (falsy-coalesce), `??` (nullish gate), `catch` (error boundary), `:` (pipe)
+- `force <handle>` and `force <handle> catch null` keyword highlighting
+- Distinct colours for GraphQL type/field targets in `bridge` declarations
+- Tool handle and alias highlighting
+- Built-in handle highlighting: `input`, `output`, `context`
+- Constant assignment colouring: `.property = value`
+- HTTP method constants: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`
+- Unquoted URL path values (e.g. `/search`, `/api/v1/forecast`)
+- Array mapping syntax: `source[] as iter { … }`
+- `on error` fallback declarations inside `tool` blocks
+- String, number, boolean, and `null` literals
+
+### Editor Integration
+
+- Line comment toggling (`#`)
+- Bracket matching for `{}` and `[]`
+- Automatic language detection for `*.bridge` files
+
+## Installation
+
+Search for **"The Bridge Language"** in the VS Code Extensions panel, or install from the terminal:
+
+```bash
+code --install-extension stackables.bridge-syntax-highlight
+```
+
+Files named `*.bridge` are automatically detected.
+
+## Related
+
+- [The Bridge runtime](https://github.com/stackables/bridge) — `@stackables/bridge` on npm
+- [Language reference](https://github.com/stackables/bridge/blob/main/docs/bridge-language-guide.md) — full syntax documentation
+
+---
+
+## Release Notes
+
+See [CHANGELOG.md](CHANGELOG.md).

package/build.mjs

@@ -0,0 +1,57 @@
+/**
+ * esbuild bundler for the Bridge Language extension.
+ *
+ * Produces two outputs:
+ *   build/extension.js  — VS Code extension host entry (CJS, vscode external)
+ *   build/server.js     — Language server process (CJS, fully self-contained)
+ *
+ * Run:  node build.mjs
+ * Watch: node build.mjs --watch
+ */
+import * as esbuild from "esbuild";
+
+const isWatch = process.argv.includes("--watch");
+
+const sharedOptions = {
+  bundle: true,
+  format: "cjs",
+  platform: "node",
+  target: "node18",
+  sourcemap: true,
+  minify: false,
+  logLevel: "info",
+};
+
+if (isWatch) {
+  // Watch mode: two separate contexts
+  const [ctxExt, ctxSrv] = await Promise.all([
+    esbuild.context({
+      ...sharedOptions,
+      entryPoints: ["src/extension.ts"],
+      outfile: "build/extension.js",
+      external: ["vscode"],
+    }),
+    esbuild.context({
+      ...sharedOptions,
+      entryPoints: ["src/server.ts"],
+      outfile: "build/server.js",
+    }),
+  ]);
+  await Promise.all([ctxExt.watch(), ctxSrv.watch()]);
+  console.log("Watching for changes…");
+} else {
+  await Promise.all([
+    esbuild.build({
+      ...sharedOptions,
+      entryPoints: ["src/extension.ts"],
+      outfile: "build/extension.js",
+      external: ["vscode"],
+    }),
+    esbuild.build({
+      ...sharedOptions,
+      entryPoints: ["src/server.ts"],
+      outfile: "build/server.js",
+    }),
+  ]);
+  console.log("Build complete.");
+}

package/language-configuration.json

@@ -0,0 +1,28 @@
+{
+    "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": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"]
+    ]
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "bridge-syntax-highlight",
+  "displayName": "The Bridge Language",
+  "description": "Syntax highlighting, real-time diagnostics, and hover information for the Bridge declarative dataflow language",
+  "version": "0.8.0",
+  "publisher": "stackables",
+  "icon": "logo128.png",
+  "engines": {
+    "vscode": "^1.109.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stackables/bridge.git"
+  },
+  "main": "./build/extension.js",
+  "activationEvents": [
+    "onLanguage:bridge"
+  ],
+  "contributes": {
+    "languages": [
+      {
+        "id": "bridge",
+        "aliases": [
+          "The Bridge",
+          "bridge"
+        ],
+        "extensions": [
+          ".bridge"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "bridge",
+        "scopeName": "source.bridge",
+        "path": "./syntaxes/bridge.tmLanguage.json"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "@types/vscode": "^1.109.0",
+    "esbuild": "^0.27.3",
+    "typescript": "^5.9.3",
+    "vscode-languageclient": "^9.0.1",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "@stackables/bridge": "1.22.1"
+  },
+  "scripts": {
+    "prebuild": "pnpm --filter @stackables/bridge build",
+    "build": "node build.mjs",
+    "watch": "node build.mjs --watch",
+    "prevscode:prepublish": "pnpm --filter @stackables/bridge build",
+    "vscode:prepublish": "node build.mjs"
+  }
+}

package/src/extension.ts

@@ -0,0 +1,51 @@
+/**
+ * VS Code extension client — activates and manages the Bridge Language Server.
+ *
+ * Runs inside the VS Code extension host. Its only job is to spawn the
+ * language server process and wire up the LSP client.
+ */
+import * as path from "path";
+import { ExtensionContext } from "vscode";
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind,
+} from "vscode-languageclient/node";
+
+let client: LanguageClient | undefined;
+
+export function activate(context: ExtensionContext): void {
+  const serverModule = context.asAbsolutePath(path.join("build", "server.js"));
+
+  const serverOptions: ServerOptions = {
+    run: {
+      module: serverModule,
+      transport: TransportKind.ipc,
+    },
+    debug: {
+      module: serverModule,
+      transport: TransportKind.ipc,
+      options: { execArgv: ["--nolazy", "--inspect=6009"] },
+    },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    // Only activate for .bridge files
+    documentSelector: [{ scheme: "file", language: "bridge" }],
+  };
+
+  client = new LanguageClient(
+    "bridgeLanguageServer",
+    "Bridge Language Server",
+    serverOptions,
+    clientOptions,
+  );
+
+  client.start();
+}
+
+export function deactivate(): Thenable<void> | undefined {
+  if (!client) return undefined;
+  return client.stop();
+}

package/src/server.ts

@@ -0,0 +1,137 @@
+/**
+ * Bridge Language Server — provides LSP features for .bridge files.
+ *
+ * Runs as a standalone Node.js process spawned by the extension client.
+ * Communicates via IPC using the Language Server Protocol.
+ *
+ * This file is a thin adapter: all intelligence logic lives in
+ * `BridgeLanguageService` from @stackables/bridge. This server just
+ * maps its output to the LSP wire format.
+ *
+ * Features:
+ *   • Real-time diagnostics  (syntax errors + semantic validation)
+ *   • Hover information      (handle bindings, bridge/tool declarations)
+ *   • Autocomplete           (built-in std.* / math.* tool names)
+ */
+import {
+  createConnection,
+  TextDocuments,
+  ProposedFeatures,
+  type InitializeResult,
+  TextDocumentSyncKind,
+  DiagnosticSeverity,
+  CompletionItemKind,
+  MarkupKind,
+} from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { BridgeLanguageService } from "@stackables/bridge";
+import type { CompletionKind } from "@stackables/bridge";
+
+// ── Connection & document manager ──────────────────────────────────────────
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+/** One language-service instance per open document (keyed by URI). */
+const services = new Map<string, BridgeLanguageService>();
+
+function getService(uri: string): BridgeLanguageService {
+  let svc = services.get(uri);
+  if (!svc) {
+    svc = new BridgeLanguageService();
+    services.set(uri, svc);
+  }
+  return svc;
+}
+
+connection.onInitialize(
+  (): InitializeResult => ({
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      hoverProvider: true,
+      completionProvider: {
+        triggerCharacters: ["."],
+      },
+    },
+  }),
+);
+
+// ── Mapping helpers ────────────────────────────────────────────────────────
+
+const completionKindMap: Record<CompletionKind, CompletionItemKind> = {
+  function: CompletionItemKind.Function,
+  variable: CompletionItemKind.Variable,
+  keyword: CompletionItemKind.Keyword,
+  type: CompletionItemKind.Class,
+};
+
+// ── Diagnostics ────────────────────────────────────────────────────────────
+
+function validate(doc: TextDocument): void {
+  const svc = getService(doc.uri);
+  svc.update(doc.getText());
+
+  const diags = svc.getDiagnostics();
+
+  connection.sendDiagnostics({
+    uri: doc.uri,
+    diagnostics: diags.map((d) => ({
+      severity:
+        d.severity === "error"
+          ? DiagnosticSeverity.Error
+          : DiagnosticSeverity.Warning,
+      range: d.range,
+      message: d.message,
+      source: "bridge",
+    })),
+  });
+}
+
+documents.onDidChangeContent((change) => validate(change.document));
+documents.onDidOpen((e) => validate(e.document));
+documents.onDidClose((e) => {
+  services.delete(e.document.uri);
+  connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+});
+
+// ── Hover ──────────────────────────────────────────────────────────────────
+
+connection.onHover((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return null;
+
+  const svc = getService(doc.uri);
+  svc.update(doc.getText());
+
+  const hover = svc.getHover(params.position);
+  if (!hover) return null;
+
+  return {
+    contents: { kind: MarkupKind.Markdown, value: hover.content },
+    ...(hover.range ? { range: hover.range } : {}),
+  };
+});
+
+// ── Completion ─────────────────────────────────────────────────────────────
+
+connection.onCompletion((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return [];
+
+  const svc = getService(doc.uri);
+  svc.update(doc.getText());
+
+  const completions = svc.getCompletions(params.position);
+
+  return completions.map((c) => ({
+    label: c.label,
+    kind: completionKindMap[c.kind] ?? CompletionItemKind.Text,
+    detail: c.detail,
+    documentation: c.documentation,
+  }));
+});
+
+// ── Start ──────────────────────────────────────────────────────────────────
+
+documents.listen(connection);
+connection.listen();

package/syntaxes/bridge.tmLanguage.json

@@ -0,0 +1,279 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "bridge",
+  "scopeName": "source.bridge",
+  "patterns": [
+    { "include": "#comments" },
+    { "include": "#version-line" },
+    { "include": "#block-headers" },
+    { "include": "#block-braces" },
+    { "include": "#force-lines" },
+    { "include": "#wire-lines" },
+    { "include": "#const-lines" },
+    { "include": "#reserved-handles" },
+    { "include": "#strings" },
+    { "include": "#numbers" },
+    { "include": "#booleans" },
+    { "include": "#http-methods" },
+    { "include": "#path-values" }
+  ],
+  "repository": {
+
+    "version-line": {
+      "comment": "version 1.5",
+      "match": "^\\s*(version)\\s+(\\d+\\.\\d+)",
+      "captures": {
+        "1": { "name": "keyword.other.version.bridge" },
+        "2": { "name": "constant.numeric.version.bridge" }
+      }
+    },
+
+    "block-braces": {
+      "comment": "Optional block delimiters { }",
+      "patterns": [{
+        "name": "punctuation.definition.block.bridge",
+        "match": "[{}]"
+      }]
+    },
+
+    "comments": {
+      "patterns": [{
+        "name": "comment.line.number-sign.bridge",
+        "match": "#.*$"
+      }]
+    },
+
+    "http-methods": {
+      "comment": "HTTP method constants used as bare values",
+      "match": "\\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\\b",
+      "name": "constant.language.http-method.bridge"
+    },
+
+    "path-values": {
+      "comment": "Unquoted slash-prefixed URL paths used as values (e.g. /search, /forecast)",
+      "match": "(?<==\\s*)/[A-Za-z0-9_/-]*",
+      "name": "string.unquoted.path.bridge"
+    },
+
+    "reserved-handles": {
+      "comment": "Special injected graph handles",
+      "match": "\\b(input|output|context)\\b",
+      "name": "variable.language.special.bridge"
+    },
+
+    "barewords": {
+      "comment": "Uppercase barewords like EUR or USD",
+      "match": "\\b[A-Z_][A-Z0-9_]*\\b",
+      "name": "constant.other.enum.bridge"
+    },
+
+    "block-headers": {
+      "comment": "Lines starting with bridge/define/tool/const/with keywords",
+      "patterns": [
+        {
+          "comment": "bridge Type.field with <target>  (inline composition, no braces)",
+          "match": "^\\s*(bridge)\\s+([A-Za-z_][A-Za-z0-9_]*)\\.([A-Za-z_][A-Za-z0-9_]*)(\\s+with\\s+)([A-Za-z_][A-Za-z0-9_.]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.type.bridge" },
+            "3": { "name": "entity.name.function.bridge" },
+            "4": { "name": "keyword.control.bridge" },
+            "5": { "name": "entity.name.function.bridge" }
+          }
+        },
+        {
+          "comment": "bridge Type.field  (block form)",
+          "match": "^\\s*(bridge)\\s+([A-Za-z_][A-Za-z0-9_]*)\\.([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.type.bridge" },
+            "3": { "name": "entity.name.function.bridge" }
+          }
+        },
+        {
+          "comment": "define <name>  (reusable sub-graph)",
+          "match": "^\\s*(define)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.function.bridge" }
+          }
+        },
+        {
+          "comment": "tool <name> from <std.source>",
+          "match": "^\\s*(tool)\\s+([A-Za-z_][A-Za-z0-9_]*)(\\s+from\\s+)([A-Za-z_][A-Za-z0-9_.]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "variable.other.handle.bridge" },
+            "3": { "name": "keyword.control.bridge" },
+            "4": { "name": "entity.name.function.bridge" }
+          }
+        },
+        {
+          "comment": "const name = ...",
+          "match": "^\\s*(const)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "variable.other.constant.bridge" }
+          }
+        },
+        {
+          "comment": "with <tool> as <handle>  /  with input as i",
+          "match": "^\\s*(with)\\s+([A-Za-z_][A-Za-z0-9_.]*)(\\s+as\\s+)([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.function.bridge" },
+            "3": { "name": "keyword.control.bridge" },
+            "4": { "name": "variable.other.handle.bridge" }
+          }
+        },
+        {
+          "comment": "with <tool>  (no alias)",
+          "match": "^\\s*(with)\\s+([A-Za-z_][A-Za-z0-9_.]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.function.bridge" }
+          }
+        },
+        {
+          "comment": "alias <source> as <name>  (node alias / rename)",
+          "match": "^\\s*(alias)\\s+(.+?)\\s+(as)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "entity.name.function.bridge" },
+            "3": { "name": "keyword.control.bridge" },
+            "4": { "name": "variable.other.handle.bridge" }
+          }
+        },
+        {
+          "comment": "on error = value  /  on error <- source",
+          "match": "^\\s*(on error)\\s*(<-|=)",
+          "captures": {
+            "1": { "name": "keyword.control.bridge" },
+            "2": { "name": "keyword.operator.wire.bridge" }
+          }
+        }
+      ]
+    },
+
+    "force-lines": {
+      "comment": "Force statement: force <handle> [catch null]",
+      "match": "^\\s*(force)\\s+([A-Za-z_][A-Za-z0-9_]*)(?:\\s+(catch)\\s+(null))?",
+      "captures": {
+        "1": { "name": "keyword.control.bridge" },
+        "2": { "name": "variable.other.handle.bridge" },
+        "3": { "name": "keyword.control.bridge" },
+        "4": { "name": "constant.language.null.bridge" }
+      }
+    },
+
+    "wire-lines": {
+      "comment": "Wire line: target <- source [|| …] [?? …] [catch …]  — target may be dot-prefixed (.field) inside array-map blocks",
+      "begin": "^(\\s*)(\\.?[A-Za-z_][A-Za-z0-9_.]*)\\s*(<-)",
+      "end": "$",
+      "beginCaptures": {
+        "2": { "name": "variable.other.target.bridge" },
+        "3": { "name": "keyword.operator.wire.bridge" }
+      },
+      "patterns": [
+        { "include": "#comments" },
+        {
+          "comment": "Array mapping: source[] as <alias>",
+          "match": "(\\[\\])(\\s+as\\s+)([A-Za-z_][A-Za-z0-9_]*)",
+          "captures": {
+            "1": { "name": "keyword.operator.array-map.bridge" },
+            "2": { "name": "keyword.control.bridge" },
+            "3": { "name": "variable.other.handle.bridge" }
+          }
+        },
+        {
+          "comment": "Array index [N]",
+          "match": "\\[\\d+\\]",
+          "name": "keyword.operator.index.bridge"
+        },
+        {
+          "comment": "Pipe separator: colon between identifiers",
+          "match": ":(?=[A-Za-z_])",
+          "name": "keyword.operator.pipe.bridge"
+        },
+        {
+          "comment": "|| null-coalesce",
+          "match": "\\|\\|",
+          "name": "keyword.operator.null-coalesce.bridge"
+        },
+        {
+          "comment": "?? nullish gate",
+          "match": "\\?\\?",
+          "name": "keyword.operator.nullish.bridge"
+        },
+        {
+          "comment": "catch error boundary",
+          "match": "\\bcatch\\b",
+          "name": "keyword.control.bridge"
+        },
+        { "include": "#reserved-handles" },
+        { "include": "#strings" },
+        { "include": "#numbers" },
+        { "include": "#booleans" }
+      ]
+    },
+
+    "const-lines": {
+      "comment": "Property/param assignments: .name = value  or  name = value. Hyphens allowed in path segments (e.g. .headers.User-Agent).",
+      "patterns": [
+        {
+          "comment": "Dot-prefixed config param: .property[.segment]* = value (hyphens allowed in segments)",
+          "begin": "^\\s*(\\.[A-Za-z_][A-Za-z0-9_-]*(?:\\.[A-Za-z_][A-Za-z0-9_-]*)*)\\s*(=)\\s*",
+          "end": "$",
+          "beginCaptures": {
+            "1": { "name": "variable.other.property.bridge" },
+            "2": { "name": "keyword.operator.assignment.bridge" }
+          },
+          "patterns": [
+            { "include": "#comments" },
+            { "include": "#barewords" },
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            { "include": "#booleans" },
+            { "include": "#http-methods" },
+            { "include": "#path-values" }
+          ]
+        },
+        {
+          "comment": "Regular param: property = value",
+          "begin": "^\\s*([A-Za-z_][A-Za-z0-9_.]*)\\s*(=)\\s*",
+          "end": "$",
+          "beginCaptures": {
+            "1": { "name": "variable.other.property.bridge" },
+            "2": { "name": "keyword.operator.assignment.bridge" }
+          },
+          "patterns": [
+            { "include": "#comments" },
+            { "include": "#barewords" },
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            { "include": "#booleans" },
+            { "include": "#http-methods" },
+            { "include": "#path-values" }
+          ]
+        }
+      ]
+    },
+
+    "strings": {
+      "name": "string.quoted.double.bridge",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [{ "name": "constant.character.escape.bridge", "match": "\\\\." }]
+    },
+
+    "numbers": {
+      "name": "constant.numeric.bridge",
+      "match": "-?\\b\\d+(\\.\\d+)?\\b"
+    },
+
+    "booleans": {
+      "name": "constant.language.bridge",
+      "match": "\\b(true|false|null)\\b"
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "outDir": "build",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "out"]
+}