vne-language 0.0.2

package/.vscode/launch.json

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

package/.vscodeignore

@@ -0,0 +1,6 @@
+.vscode/**
+.vscode-test/**
+.gitignore
+vsc-extension-quickstart.md
+../**
+../../**

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change Log
+
+All notable changes to the "vne-language" extension will be documented in this file.
+
+Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
+
+## [Unreleased]
+
+- Initial release

package/language-configuration.json

@@ -0,0 +1,22 @@
+{
+  "comments": {
+    "lineComment": "//"
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ]
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "vne-language",
+  "displayName": "vne-language",
+  "description": "Syntax highlighting for .vne scenario files",
+  "version": "0.0.2",
+  "main": "./src/extension.js",
+  "scripts": {
+    "package:vsix": "vsce package",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
+  },
+  "engines": {
+    "vscode": "^1.100.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "activationEvents": [
+    "onLanguage:vnelang"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./syntaxes/vne.json": "./syntaxes/vne.json",
+    "./language-configuration.json": "./language-configuration.json",
+    "./load-commands": "./src/load-commands.js",
+    "./collect-command-tokens": "./src/collect-command-tokens.js",
+    "./semantic-tokens": "./src/semantic-tokens.js"
+  },
+  "contributes": {
+    "languages": [
+      {
+        "id": "vnelang",
+        "extensions": [
+          ".vne"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "vnelang",
+        "scopeName": "source.vnelang",
+        "path": "./syntaxes/vne.json"
+      }
+    ]
+  }
+}

package/src/build-grammar.js

@@ -0,0 +1,85 @@
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const actionLiterals = (entry = {}) =>
+  Object.values(entry.actions || {}).filter((value) => typeof value === "string" && value.length > 0);
+
+const mergeCommands = (manifests = []) => {
+  const modules = {};
+  const blocks = {};
+
+  for (const manifest of manifests) {
+    if (!manifest || typeof manifest !== "object") continue;
+
+    Object.assign(modules, manifest.modules || {});
+    Object.assign(blocks, manifest.blocks || {});
+  }
+
+  return { modules, blocks };
+};
+
+const patternsForNamedCommands = (commands = {}) => {
+  const patterns = [];
+
+  for (const [name, entry] of Object.entries(commands)) {
+    const actions = actionLiterals(entry);
+
+    if (!actions.length) continue;
+
+    const namePattern = escapeRegExp(name);
+    const actionsPattern = actions.map(escapeRegExp).join("|");
+
+    patterns.push({
+      name: "keyword.control",
+      match: `(?<=\\b${namePattern}\\s+)(${actionsPattern})\\b`,
+    });
+
+    patterns.push({
+      name: "entity.name.function",
+      match: `(?<=\\b${namePattern}\\s+(?:${actionsPattern})\\s+)[a-zA-Z0-9_/-]+`,
+    });
+  }
+
+  return patterns;
+};
+
+const lineKeywordPattern = (keywords = []) => {
+  const values = keywords.filter((value) => typeof value === "string" && value.length > 0);
+
+  if (!values.length) return null;
+
+  return {
+    name: "keyword.control",
+    match: `(?<=\\s\\|\\s.*)(${values.map(escapeRegExp).join("|")})(?=\\s|$)`,
+  };
+};
+
+/**
+ * Build TextMate grammar from structural base + SCENARIO_COMMANDS manifests.
+ * @param {object} baseGrammar
+ * @param {object[]} manifests
+ * @param {{ lineKeywords?: string[] }} [options]
+ */
+const buildGrammar = (baseGrammar, manifests = [], options = {}) => {
+  const { modules, blocks } = mergeCommands(manifests);
+  const commandPatterns = [
+    ...patternsForNamedCommands(modules),
+    ...patternsForNamedCommands(blocks),
+  ];
+
+  const keywordPattern = lineKeywordPattern(options.lineKeywords || []);
+  const basePatterns = Array.isArray(baseGrammar.patterns) ? baseGrammar.patterns : [];
+
+  return {
+    ...baseGrammar,
+    patterns: [...basePatterns, ...(keywordPattern ? [keywordPattern] : []), ...commandPatterns],
+  };
+};
+
+module.exports = {
+  actionLiterals,
+  buildGrammar,
+  escapeRegExp,
+  lineKeywordPattern,
+  mergeCommands,
+  patternsForNamedCommands,
+};

package/src/collect-command-tokens.js

@@ -0,0 +1,119 @@
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  } else {
+    root.VneCommandTokens = factory();
+  }
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  const TOKEN_TYPES = ["keyword", "function"];
+
+  const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+  const actionLiterals = (entry) =>
+    Object.values((entry && entry.actions) || {}).filter((value) => typeof value === "string" && value.length > 0);
+
+  /**
+   * Collect semantic token ranges for document text.
+   * @returns {{ line: number, start: number, length: number, type: string }[]}
+   */
+  const collectCommandTokenRanges = (text, commands) => {
+    const modules = (commands && commands.modules) || {};
+    const blocks = (commands && commands.blocks) || {};
+    const lineKeywords = (commands && commands.lineKeywords) || [];
+    const ranges = [];
+    const lines = String(text).split(/\r?\n/);
+
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex];
+      const trimmedStart = line.search(/\S/);
+
+      if (trimmedStart === -1) continue;
+
+      const lead = line.slice(trimmedStart);
+      if (lead.startsWith("//") || lead.startsWith("#")) continue;
+
+      const execMatch = /^(\s*)([%$])\s+([a-zA-Z0-9_.-]+)(?:\s+([a-zA-Z0-9_-]+))?/.exec(line);
+
+      if (execMatch) {
+        const prefix = execMatch[2];
+        const commandName = execMatch[3];
+        const action = execMatch[4];
+        const dict = prefix === "$" ? modules : blocks;
+        const entry = dict[commandName];
+        const actions = actionLiterals(entry);
+
+        if (entry && action && actions.includes(action)) {
+          const nameOffset = line.indexOf(commandName, execMatch[1].length);
+          const actionOffset = line.indexOf(action, nameOffset + commandName.length);
+
+          if (actionOffset !== -1) {
+            ranges.push({ line: lineIndex, start: actionOffset, length: action.length, type: "keyword" });
+          }
+
+          if (actionOffset !== -1) {
+            const afterAction = line.slice(actionOffset + action.length);
+            const idMatch = /^\s+([a-zA-Z0-9_/-]+)/.exec(afterAction);
+
+            if (idMatch) {
+              const idOffset = actionOffset + action.length + afterAction.indexOf(idMatch[1]);
+              ranges.push({ line: lineIndex, start: idOffset, length: idMatch[1].length, type: "function" });
+            }
+          }
+        }
+      }
+
+      const pipeIndex = line.indexOf("|");
+
+      if (pipeIndex !== -1 && lineKeywords.length) {
+        const rest = line.slice(pipeIndex + 1);
+
+        for (const keyword of lineKeywords) {
+          const pattern = new RegExp(`\\b${escapeRegExp(keyword)}\\b`, "g");
+          let match;
+
+          while ((match = pattern.exec(rest))) {
+            ranges.push({
+              line: lineIndex,
+              start: pipeIndex + 1 + match.index,
+              length: keyword.length,
+              type: "keyword",
+            });
+          }
+        }
+      }
+    }
+
+    return ranges;
+  };
+
+  /** Encode ranges to Monaco/VS Code semantic tokens Uint32Array. */
+  const encodeSemanticTokenData = (ranges, tokenTypes) => {
+    const typeIndex = new Map((tokenTypes || TOKEN_TYPES).map((name, index) => [name, index]));
+    const sorted = [...ranges].sort((a, b) => (a.line === b.line ? a.start - b.start : a.line - b.line));
+    const data = [];
+    let prevLine = 0;
+    let prevStart = 0;
+
+    for (const range of sorted) {
+      const index = typeIndex.get(range.type);
+      if (index === undefined) continue;
+
+      const deltaLine = range.line - prevLine;
+      const deltaStart = deltaLine === 0 ? range.start - prevStart : range.start;
+
+      data.push(deltaLine, deltaStart, range.length, index, 0);
+      prevLine = range.line;
+      prevStart = range.start;
+    }
+
+    return new Uint32Array(data);
+  };
+
+  return {
+    TOKEN_TYPES,
+    actionLiterals,
+    collectCommandTokenRanges,
+    encodeSemanticTokenData,
+    escapeRegExp,
+  };
+});

package/src/extension.js

@@ -0,0 +1,125 @@
+const vscode = require("vscode");
+
+const { resolveGameRoot } = require("./resolve-game-root.js");
+const { loadCommandsFromNodeModules, EMPTY_COMMANDS } = require("./load-commands.js");
+const { TOKEN_TYPES, buildSemanticTokens } = require("./semantic-tokens.js");
+
+/** @type {Map<string, { modules: object, blocks: object, lineKeywords: string[] }>} */
+const commandsCache = new Map();
+
+/** @type {Map<string, Promise<{ modules: object, blocks: object, lineKeywords: string[] }>>} */
+const commandsInflight = new Map();
+
+const legend = new vscode.SemanticTokensLegend(TOKEN_TYPES, []);
+const onDidChangeSemanticTokensEmitter = new vscode.EventEmitter();
+
+const getCommandsForGameRoot = async (gameRoot) => {
+  if (!gameRoot) return { modules: {}, blocks: {}, lineKeywords: [] };
+
+  if (commandsCache.has(gameRoot)) return commandsCache.get(gameRoot);
+
+  if (commandsInflight.has(gameRoot)) return commandsInflight.get(gameRoot);
+
+  const pending = loadCommandsFromNodeModules(gameRoot)
+    .then((commands) => {
+      commandsCache.set(gameRoot, commands);
+      commandsInflight.delete(gameRoot);
+      return commands;
+    })
+    .catch(() => {
+      commandsInflight.delete(gameRoot);
+      return { modules: {}, blocks: {}, lineKeywords: [] };
+    });
+
+  commandsInflight.set(gameRoot, pending);
+  return pending;
+};
+
+const invalidateGameRoot = (gameRoot) => {
+  if (!gameRoot) {
+    commandsCache.clear();
+    commandsInflight.clear();
+  } else {
+    commandsCache.delete(gameRoot);
+    commandsInflight.delete(gameRoot);
+  }
+
+  onDidChangeSemanticTokensEmitter.fire();
+};
+
+const createSemanticTokensProvider = () => ({
+  onDidChangeSemanticTokens: onDidChangeSemanticTokensEmitter.event,
+
+  async provideDocumentSemanticTokens(document) {
+    if (document.languageId !== "vnelang") {
+      return new vscode.SemanticTokens(new Uint32Array());
+    }
+
+    const gameRoot = resolveGameRoot(document.uri.fsPath);
+    const commands = gameRoot ? await getCommandsForGameRoot(gameRoot) : EMPTY_COMMANDS;
+
+    return buildSemanticTokens(vscode, legend, commands, document);
+  },
+});
+
+const watchGameRoot = (context, gameRoot) => {
+  if (!gameRoot) return;
+
+  const pattern = new vscode.RelativePattern(gameRoot, "{package.json,node_modules/@vnejs/contracts.*/**}");
+  const watcher = vscode.workspace.createFileSystemWatcher(pattern);
+
+  const invalidate = () => invalidateGameRoot(gameRoot);
+
+  watcher.onDidCreate(invalidate);
+  watcher.onDidChange(invalidate);
+  watcher.onDidDelete(invalidate);
+
+  context.subscriptions.push(watcher);
+};
+
+/** @type {Set<string>} */
+const watchedRoots = new Set();
+
+/**
+ * @param {import("vscode").ExtensionContext} context
+ */
+const activate = (context) => {
+  const provider = createSemanticTokensProvider();
+
+  context.subscriptions.push(
+    vscode.languages.registerDocumentSemanticTokensProvider({ language: "vnelang" }, provider, legend),
+  );
+
+  context.subscriptions.push(onDidChangeSemanticTokensEmitter);
+
+  context.subscriptions.push(
+    vscode.workspace.onDidOpenTextDocument((document) => {
+      if (document.languageId !== "vnelang") return;
+
+      const gameRoot = resolveGameRoot(document.uri.fsPath);
+      if (!gameRoot || watchedRoots.has(gameRoot)) return;
+
+      watchedRoots.add(gameRoot);
+      watchGameRoot(context, gameRoot);
+      getCommandsForGameRoot(gameRoot).then(() => onDidChangeSemanticTokensEmitter.fire());
+    }),
+  );
+
+  for (const document of vscode.workspace.textDocuments) {
+    if (document.languageId !== "vnelang") continue;
+
+    const gameRoot = resolveGameRoot(document.uri.fsPath);
+    if (!gameRoot || watchedRoots.has(gameRoot)) continue;
+
+    watchedRoots.add(gameRoot);
+    watchGameRoot(context, gameRoot);
+  }
+};
+
+const deactivate = () => {
+  commandsCache.clear();
+  commandsInflight.clear();
+  watchedRoots.clear();
+};
+
+module.exports = { activate, deactivate, invalidateGameRoot, getCommandsForGameRoot, legend };

package/src/load-commands.js

@@ -0,0 +1,103 @@
+const fs = require("fs");
+const path = require("path");
+const { pathToFileURL } = require("url");
+
+const { mergeCommands } = require("./build-grammar.js");
+
+const EMPTY_COMMANDS = Object.freeze({
+  modules: Object.freeze({}),
+  blocks: Object.freeze({}),
+  lineKeywords: Object.freeze([]),
+});
+
+/**
+ * Collect @vnejs/contracts.* package dirs visible from gameRoot (including hoisted ancestors).
+ * @param {string} gameRoot
+ * @returns {Map<string, string>} short name (e.g. contracts.core.stack) → absolute package dir
+ */
+const findContractPackageDirs = (gameRoot) => {
+  const found = new Map();
+  let dir = path.resolve(gameRoot);
+
+  while (true) {
+    const scopeDir = path.join(dir, "node_modules", "@vnejs");
+
+    if (fs.existsSync(scopeDir) && fs.statSync(scopeDir).isDirectory()) {
+      for (const name of fs.readdirSync(scopeDir)) {
+        if (!name.startsWith("contracts.")) continue;
+        if (found.has(name)) continue;
+
+        const packageDir = path.join(scopeDir, name);
+        if (fs.statSync(packageDir).isDirectory()) found.set(name, packageDir);
+      }
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return found;
+};
+
+const importModule = async (filePath) => import(pathToFileURL(filePath).href);
+
+/**
+ * Load and merge SCENARIO_COMMANDS from contracts in node_modules of the game package.
+ *
+ * Imports only `dist/commands.js` when present (not the full package entry), so we do not
+ * pull every contract's side-effect graph into the editor/extension host.
+ *
+ * @param {string} gameRoot
+ * @returns {Promise<{ modules: Record<string, object>, blocks: Record<string, object>, lineKeywords: string[] }>}
+ */
+const loadCommandsFromNodeModules = async (gameRoot) => {
+  if (!gameRoot) return { ...EMPTY_COMMANDS, modules: {}, blocks: {}, lineKeywords: [] };
+
+  const packageDirs = findContractPackageDirs(gameRoot);
+  const manifests = [];
+  let lineKeywords = [];
+
+  for (const [shortName, packageDir] of packageDirs) {
+    const commandsPath = path.join(packageDir, "dist", "commands.js");
+
+    if (!fs.existsSync(commandsPath)) continue;
+
+    try {
+      const mod = await importModule(commandsPath);
+
+      if (mod.SCENARIO_COMMANDS) manifests.push(mod.SCENARIO_COMMANDS);
+
+      if (shortName === "contracts.core.scenario") {
+        const constPath = path.join(packageDir, "dist", "const.js");
+
+        if (fs.existsSync(constPath)) {
+          const consts = await importModule(constPath);
+          const keywords = consts.LINE_KEYWORDS || consts.CONSTANTS?.LINE_KEYWORDS;
+
+          if (keywords && typeof keywords === "object") {
+            lineKeywords = Object.values(keywords).filter(
+              (value) => typeof value === "string" && value.length > 0,
+            );
+          }
+        }
+      }
+    } catch {
+      // Skip unreadable / incompatible packages.
+    }
+  }
+
+  const merged = mergeCommands(manifests);
+
+  return {
+    modules: merged.modules,
+    blocks: merged.blocks,
+    lineKeywords,
+  };
+};
+
+module.exports = {
+  EMPTY_COMMANDS,
+  findContractPackageDirs,
+  loadCommandsFromNodeModules,
+};

package/src/resolve-game-root.js

@@ -0,0 +1,28 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Nearest package root for a .vne file: directory that has package.json and a game/ folder.
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+const resolveGameRoot = (filePath) => {
+  if (!filePath || typeof filePath !== "string") return null;
+
+  let dir = path.dirname(path.resolve(filePath));
+
+  while (true) {
+    const packageJsonPath = path.join(dir, "package.json");
+    const gameDir = path.join(dir, "game");
+
+    if (fs.existsSync(packageJsonPath) && fs.existsSync(gameDir) && fs.statSync(gameDir).isDirectory()) {
+      return dir;
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+};
+
+module.exports = { resolveGameRoot };

package/src/semantic-tokens.js

@@ -0,0 +1,22 @@
+const { TOKEN_TYPES, collectCommandTokenRanges } = require("./collect-command-tokens.js");
+
+/**
+ * @param {import("vscode")} vscode
+ * @param {import("vscode").SemanticTokensLegend} legend
+ * @param {{ modules?: Record<string, object>, blocks?: Record<string, object>, lineKeywords?: string[] }} commands
+ * @param {import("vscode").TextDocument} document
+ */
+const buildSemanticTokens = (vscode, legend, commands, document) => {
+  const builder = new vscode.SemanticTokensBuilder(legend);
+  const ranges = collectCommandTokenRanges(document.getText(), commands);
+
+  for (const range of ranges) {
+    const typeIndex = legend.tokenTypes.indexOf(range.type);
+    if (typeIndex === -1) continue;
+    builder.push(range.line, range.start, range.length, typeIndex, 0);
+  }
+
+  return builder.build();
+};
+
+module.exports = { TOKEN_TYPES, buildSemanticTokens, collectCommandTokenRanges };

package/src/smoke-check.js

@@ -0,0 +1,69 @@
+const path = require("path");
+
+const { resolveGameRoot } = require("./resolve-game-root.js");
+const { loadCommandsFromNodeModules } = require("./load-commands.js");
+const { collectCommandTokenRanges } = require("./semantic-tokens.js");
+
+const sampleVne = path.resolve(
+  __dirname,
+  "../../../games/vn.skeleton/game/main/scenario/tests/index.vne",
+);
+
+const assert = (condition, message) => {
+  if (!condition) throw new Error(message);
+};
+
+const main = async () => {
+  const gameRoot = resolveGameRoot(sampleVne);
+  assert(gameRoot, "expected game root for vn.skeleton scenario");
+  assert(gameRoot.endsWith(`${path.sep}vn.skeleton`) || gameRoot.endsWith("/vn.skeleton"), `unexpected root: ${gameRoot}`);
+
+  const commands = await loadCommandsFromNodeModules(gameRoot);
+
+  assert(commands.modules.stack, "expected stack module from contracts");
+  assert(commands.modules.scenario, "expected scenario module from contracts");
+  assert(
+    Object.values(commands.modules.stack.actions || {}).includes("jump"),
+    "expected stack jump action",
+  );
+  assert(
+    Object.values(commands.modules.scenario.actions || {}).includes("goto"),
+    "expected scenario goto action",
+  );
+  assert(commands.lineKeywords.includes("async"), "expected LINE_KEYWORDS from scenario contract");
+
+  const ranges = collectCommandTokenRanges(
+    ['  $ stack jump testsCanvas', '  "hi" | async global', '  $ scenario goto loop'].join("\n"),
+    commands,
+  );
+
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 0),
+    "expected keyword token on stack jump",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 0),
+    "expected function token for jump target",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 1),
+    "expected keyword token for line keywords",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 2),
+    "expected keyword token on scenario goto",
+  );
+
+  console.log("ok", {
+    gameRoot,
+    modules: Object.keys(commands.modules),
+    blocks: Object.keys(commands.blocks),
+    lineKeywords: commands.lineKeywords,
+    sampleRanges: ranges.length,
+  });
+};
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/syntaxes/base.json

@@ -0,0 +1,219 @@
+{
+  "scopeName": "source.vnelang",
+  "patterns": [
+    {
+      "name": "comment.line",
+      "match": "(//|#).*$"
+    },
+    {
+      "name": "string.quoted.double",
+      "match": "\".*\""
+    },
+    {
+      "name": "variable.other",
+      "match": "\\{[^}]*\\}"
+    },
+    {
+      "name": "keyword.control",
+      "match": "[%$]"
+    },
+    {
+      "name": "keyword.declaration",
+      "match": "\\blabel\\b"
+    },
+    {
+      "name": "keyword.other",
+      "match": "\\bimport\\b"
+    },
+    {
+      "name": "keyword.operator.comparison",
+      "match": "!==|===|>=|<=|<|>"
+    },
+    {
+      "name": "keyword.operator.assignment",
+      "match": "\\+=|-=|\\+\\+|--|="
+    },
+    {
+      "name": "keyword.operator",
+      "match": "[+\\-*:|]"
+    },
+    {
+      "name": "constant.numeric",
+      "match": "(?<=\\s|[+\\-:])\\d+(\\.\\d+)?"
+    },
+    {
+      "name": "constant.language",
+      "match": "\\b(true|false|null)\\b"
+    },
+    {
+      "name": "entity.name.namespace",
+      "match": "(?<=\\bimport\\s+)[a-zA-Z0-9_/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\blabel\\s+)[a-zA-Z0-9_/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=[%$]\\s+)[a-zA-Z0-9_.-]+"
+    },
+    {
+      "name": "variable.other",
+      "match": "(?<=\\s)[a-zA-Z0-9_-]+:(?=\\s|$)"
+    },
+    {
+      "name": "variable.other",
+      "match": "(?<=\\b(counter|flag)\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.other",
+      "match": "(?<=^\\s*)[a-zA-Z0-9_-]+(?=\\s+\")"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s)(show|hide|change|move)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\s)(show|hide|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.video\\s)(show|hide|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.text\\s)(show|hide|change|move)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.filter\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.clip\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.mask\\s)(set|unset|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.scale\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.animation\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\baudio\\.(music|sound|ambient|voice)\\s)(play|stop|pause|resume|volume)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bvideo\\s)play\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\binterface\\s)(show|hide|view)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bsave\\s)key\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bflag\\s+[a-zA-Z0-9_-]+\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btime\\s+)(add|set)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bdate\\s+)(add|set)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btext\\.wall\\s+)(clear|start|end)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btext\\.meet\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bcomment\\s+)hide\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bachievement\\s+)unlock\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bwallet\\s+[a-zA-Z0-9_-]+\\s)(add|set|reset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bcredits\\s+)(show|hide)\\b"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\bachievement\\s+unlock\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\bwallet\\s+)[a-zA-Z0-9_-]+(?=\\s+(add|set|reset))"
+    },
+    {
+      "name": "entity.name.type",
+      "match": "(?<=\\binterface\\s+view\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\sshow\\s\\{[^}]*\\}\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\shide\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\sshow\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s(hide|change|move)\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.video\\s(show|change)\\s)[a-zA-Z0-9_{}/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.text\\s(show|hide|change|move)\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.filter\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.clip\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.mask\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.animation\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.other",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s(show|hide|change|move)\\s[a-zA-Z0-9_-]+\\s)[a-zA-Z0-9_-]+"
+    }
+  ],
+  "repository": {},
+  "uuid": "vne-language-grammar"
+}

package/syntaxes/vne.json

@@ -0,0 +1,223 @@
+{
+  "scopeName": "source.vnelang",
+  "patterns": [
+    {
+      "name": "comment.line",
+      "match": "(//|#).*$"
+    },
+    {
+      "name": "string.quoted.double",
+      "match": "\".*\""
+    },
+    {
+      "name": "variable.other",
+      "match": "\\{[^}]*\\}"
+    },
+    {
+      "name": "keyword.control",
+      "match": "[%$]"
+    },
+    {
+      "name": "keyword.declaration",
+      "match": "\\blabel\\b"
+    },
+    {
+      "name": "keyword.other",
+      "match": "\\bimport\\b"
+    },
+    {
+      "name": "keyword.operator.comparison",
+      "match": "!==|===|>=|<=|<|>"
+    },
+    {
+      "name": "keyword.operator.assignment",
+      "match": "\\+=|-=|\\+\\+|--|="
+    },
+    {
+      "name": "keyword.operator",
+      "match": "[+\\-*:|]"
+    },
+    {
+      "name": "constant.numeric",
+      "match": "(?<=\\s|[+\\-:])\\d+(\\.\\d+)?"
+    },
+    {
+      "name": "constant.language",
+      "match": "\\b(true|false|null)\\b"
+    },
+    {
+      "name": "entity.name.namespace",
+      "match": "(?<=\\bimport\\s+)[a-zA-Z0-9_/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\blabel\\s+)[a-zA-Z0-9_/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=[%$]\\s+)[a-zA-Z0-9_.-]+"
+    },
+    {
+      "name": "variable.other",
+      "match": "(?<=\\s)[a-zA-Z0-9_-]+:(?=\\s|$)"
+    },
+    {
+      "name": "variable.other",
+      "match": "(?<=\\b(counter|flag)\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.other",
+      "match": "(?<=^\\s*)[a-zA-Z0-9_-]+(?=\\s+\")"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s)(show|hide|change|move)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\s)(show|hide|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.video\\s)(show|hide|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.text\\s)(show|hide|change|move)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.filter\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.clip\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.mask\\s)(set|unset|change)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.scale\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.animation\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\baudio\\.(music|sound|ambient|voice)\\s)(play|stop|pause|resume|volume)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bvideo\\s)play\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\binterface\\s)(show|hide|view)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bsave\\s)key\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bflag\\s+[a-zA-Z0-9_-]+\\s)(set|unset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btime\\s+)(add|set)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bdate\\s+)(add|set)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btext\\.wall\\s+)(clear|start|end)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\btext\\.meet\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bcomment\\s+)hide\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bachievement\\s+)unlock\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bwallet\\s+[a-zA-Z0-9_-]+\\s)(add|set|reset)\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\bcredits\\s+)(show|hide)\\b"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\bachievement\\s+unlock\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\bwallet\\s+)[a-zA-Z0-9_-]+(?=\\s+(add|set|reset))"
+    },
+    {
+      "name": "entity.name.type",
+      "match": "(?<=\\binterface\\s+view\\s+)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\sshow\\s\\{[^}]*\\}\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.image\\shide\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\sshow\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s(hide|change|move)\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.video\\s(show|change)\\s)[a-zA-Z0-9_{}/-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.text\\s(show|hide|change|move)\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.filter\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.clip\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.mask\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.animation\\sset\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.other",
+      "match": "(?<=\\b(bg|mg|fg|sg)\\.sprite\\s(show|hide|change|move)\\s[a-zA-Z0-9_-]+\\s)[a-zA-Z0-9_-]+"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?<=\\s\\|\\s.*)(global|skip-if-possible|async|extend|autonext|dangerous)(?=\\s|$)"
+    }
+  ],
+  "repository": {},
+  "uuid": "vne-language-grammar"
+}

package/vsc-extension-quickstart.md

@@ -0,0 +1,29 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+- This folder contains all of the files necessary for your extension.
+- `package.json` - this is the manifest file in which you declare your language support and define the location of the grammar file that has been copied into your extension.
+- `syntaxes/vne.tmLanguage.json` - this is the Text mate grammar file that is used for tokenization.
+- `language-configuration.json` - this is the language configuration, defining the tokens that are used for comments and brackets.
+
+## Get up and running straight away
+
+- Make sure the language configuration settings in `language-configuration.json` are accurate.
+- Press `F5` to open a new window with your extension loaded.
+- Create a new file with a file name suffix matching your language.
+- Verify that syntax highlighting works and that the language configuration settings are working.
+
+## Make changes
+
+- You can relaunch the extension from the debug toolbar after making changes to the files listed above.
+- You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+## Add more language features
+
+- To add features such as IntelliSense, hovers and validators check out the VS Code extenders documentation at https://code.visualstudio.com/api/language-extensions/overview
+
+## Install your extension
+
+- To start using your extension with Visual Studio Code copy it into the `<user home>/.vscode/extensions` folder and restart Code.
+- To share your extension with the world, read on https://code.visualstudio.com/api/working-with-extensions/publishing-extension about publishing an extension.