package.json

{
  "name": "vscode-kopytko",
  "displayName": "Kopytko BrightScript",
  "description": "BrightScript & Kopytko language support for Visual Studio Code — syntax, IntelliSense, diagnostics, and Kopytko import resolution.",
  "version": "1.15.1",
  "publisher": "bchelkowski",
  "license": "MIT",
  "icon": "images/kopytko-logo.png",
  "keywords": [
    "roku",
    "brightscript",
    "scenegraph",
    "brs",
    "kopytko",
    "formatter",
    "prettier",
    "linter",
    "lint",
    "debugger",
    "debug",
    "remote",
    "perfetto"
  ],
  "engines": {
    "vscode": "^1.125.0",
    "node": ">=24.0.0"
  },
  "scripts": {
    "vscode:prepublish": "npm run bundle",
    "bundle": "npm run bundle:extension && npm run bundle:server && npm run bundle:webview && npm run bundle:perfetto-webview && npm run bundle:node-tree-webview && npm run bundle:nav-webview && npm run bundle:deep-linking-webview && npm run bundle:device-manager-webview && npm run bundle:script-editor-webview && npm run bundle:roku-pay-webview && npm run bundle:network-webview && npm run bundle:console-webview",
    "bundle:extension": "esbuild src/extension.ts --bundle --outfile=out/extension.js --external:vscode --platform=node --format=cjs --sourcemap",
    "bundle:server": "esbuild src/server/server.ts --bundle --outfile=out/server/server.js --platform=node --format=cjs --sourcemap",
    "bundle:webview": "esbuild src/client/diagnostics/webview/main.ts --bundle --outfile=out/diagnostics-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:perfetto-webview": "esbuild src/client/perfetto/webview/main.ts --bundle --outfile=out/perfetto-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:node-tree-webview": "esbuild src/client/nodes/webview/main.ts --bundle --outfile=out/node-tree-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:nav-webview": "esbuild src/client/nav/webview/main.ts --bundle --outfile=out/nav-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:deep-linking-webview": "esbuild src/client/deepLinking/webview/main.ts --bundle --outfile=out/deep-linking-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:device-manager-webview": "esbuild src/client/deviceManager/webview/main.ts --bundle --outfile=out/device-manager-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:script-editor-webview": "esbuild src/client/deviceManager/editorWebview/main.ts --bundle --outfile=out/script-editor-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:roku-pay-webview": "esbuild src/client/rokuPay/webview/main.ts --bundle --outfile=out/roku-pay-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:network-webview": "esbuild src/client/network/webview/main.ts --bundle --outfile=out/network-webview/main.js --platform=browser --format=iife --sourcemap",
    "bundle:console-webview": "esbuild src/client/console/webview/main.ts --bundle --outfile=out/console-webview/main.js --platform=browser --format=iife --sourcemap --loader:.woff=dataurl",
    "compile": "tsc -p ./tsconfig.json && tsc -p ./tsconfig.server.json && npm run bundle:webview && npm run bundle:perfetto-webview && npm run bundle:node-tree-webview && npm run bundle:nav-webview && npm run bundle:deep-linking-webview && npm run bundle:device-manager-webview && npm run bundle:script-editor-webview && npm run bundle:roku-pay-webview && npm run bundle:network-webview && npm run bundle:console-webview",
    "build:roku-device": "npm --prefix packages/roku-device install && npm --prefix packages/roku-device run build",
    "watch": "tsc -w -p ./tsconfig.json",
    "watch:server": "tsc -w -p ./tsconfig.server.json",
    "watch:webview": "esbuild src/client/diagnostics/webview/main.ts --bundle --outfile=out/diagnostics-webview/main.js --platform=browser --format=iife --sourcemap --watch",
    "watch:perfetto-webview": "esbuild src/client/perfetto/webview/main.ts --bundle --outfile=out/perfetto-webview/main.js --platform=browser --format=iife --sourcemap --watch",
    "map": "node scripts/generate-map.mjs",
    "check:claims": "node scripts/check-doc-claims.mjs",
    "lint": "node scripts/generate-map.mjs --check && node scripts/check-doc-claims.mjs && eslint \"./src/**/*.ts\" \"./test/**/*.ts\"",
    "test": "mocha",
    "test:coverage": "nyc mocha",
    "clean": "node -e \"const fs=require('fs'); fs.rmSync('out',{recursive:true,force:true}); fs.rmSync('out-test',{recursive:true,force:true})\"",
    "package": "vsce package"
  },
  "dependencies": {
    "d3": "^7.9.0",
    "js-yaml": "^5.2.1",
    "kopytko-brightscript-parser": "^1.4.0",
    "kopytko-formatter": "^1.2.2",
    "kopytko-linter": "^2.0.0",
    "kopytko-roku-device": "^1.5.1",
    "vscode-languageclient": "^10.1.0",
    "vscode-languageserver": "^10.1.0",
    "vscode-languageserver-textdocument": "^1.0.12",
    "vscode-uri": "^3.1.0"
  },
  "devDependencies": {
    "@types/js-yaml": "^4.0.9",
    "@types/mocha": "^10.0.10",
    "@types/node": "^26.1.1",
    "@types/sinon": "^22.0.0",
    "@types/vscode": "^1.125.0",
    "@vscode/vsce": "^3.9.2",
    "@xterm/addon-fit": "^0.11.0",
    "@xterm/xterm": "^6.0.0",
    "chai": "^6.2.2",
    "esbuild": "^0.28.1",
    "eslint": "^10.7.0",
    "mocha": "^11.7.6",
    "nyc": "^18.0.0",
    "sinon": "^22.0.0",
    "source-map-support": "^0.5.21",
    "tsx": "^4.23.1",
    "typescript": "^6.0.3",
    "typescript-eslint": "^8.64.0"
  },
  "overrides": {
    "serialize-javascript": "^7.0.5",
    "diff": "^8.0.3"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/bchelkowski/vscode-kopytko"
  },
  "bugs": {
    "url": "https://github.com/bchelkowski/vscode-kopytko/issues"
  },
  "categories": [
    "Programming Languages",
    "Linters",
    "Snippets"
  ],
  "activationEvents": [
    "onLanguage:brightscript",
    "onLanguage:xml",
    "workspaceContains:**/*.brs",
    "workspaceContains:**/.kopytkorc",
    "onDebug"
  ],
  "main": "./out/extension",
  "contributes": {
    "languages": [
      {
        "id": "brightscript",
        "aliases": [
          "BrightScript",
          "brightscript",
          "brs"
        ],
        "extensions": [
          ".brs"
        ],
        "configuration": "./language-configuration.json",
        "icon": {
          "light": "./images/brightscript.svg",
          "dark": "./images/brightscript.svg"
        }
      }
    ],
    "grammars": [
      {
        "language": "brightscript",
        "scopeName": "source.brightscript",
        "path": "./syntaxes/brightscript.tmLanguage.json"
      }
    ],
    "semanticTokenScopes": [
      {
        "language": "brightscript",
        "scopes": {
          "function": [
            "entity.name.function",
            "support.function"
          ],
          "function.declaration": [
            "entity.name.function",
            "support.function"
          ],
          "parameter": [
            "variable.parameter"
          ],
          "parameter.declaration": [
            "variable.parameter"
          ],
          "variable": [
            "variable.other.readwrite"
          ],
          "variable.declaration": [
            "variable.other.readwrite"
          ],
          "property": [
            "variable.other.property"
          ],
          "property.declaration": [
            "variable.other.property"
          ]
        }
      }
    ],
    "configuration": {
      "title": "Kopytko BrightScript",
      "properties": {
        "kopytko.languageServer.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Enable the Kopytko language server."
        },
        "kopytko.languageServer.trace": {
          "type": "string",
          "enum": [
            "off",
            "messages",
            "verbose"
          ],
          "default": "off",
          "description": "Trace LSP communication for debugging."
        },
        "kopytko.debug.trace": {
          "type": "string",
          "enum": [
            "off",
            "messages",
            "verbose"
          ],
          "enumDescriptions": [
            "No protocol tracing.",
            "Log every debug-protocol command, response and device update.",
            "Also hex-dump every framed packet."
          ],
          "default": "off",
          "description": "Trace the Roku debug protocol (port 8081) to the Kopytko output channel. Use when a debug session disconnects or the channel freezes on resume."
        },
        "kopytko.imports.resolveModules": {
          "type": "boolean",
          "default": true,
          "description": "Resolve @import annotations from installed Kopytko NPM modules."
        },
        "kopytko.imports.sourceDir": {
          "type": "string",
          "default": "app",
          "description": "Root source directory for resolving internal @import paths (matches .kopytkorc sourceDir)."
        },
        "kopytko.imports.generatedPaths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Glob patterns for `@import` paths that are generated during the build process and do not exist as source files on disk (e.g. by a Kopytko plugin or code-generation tool). Unresolved imports matching these patterns are shown as informational hints instead of warnings, so the developer is aware of the situation without it being flagged as an error.\n\n**Supported wildcards:** `*` matches any characters except `/`; `**` matches any characters including `/`.\n\n**Examples:**\n- `/components/generated/**`\n- `**/auto-generated/*.brs`"
        },
        "kopytko.imports.generatedModules": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "path",
              "functions"
            ],
            "properties": {
              "path": {
                "type": "string",
                "description": "Glob pattern matching the @import path of the generated file."
              },
              "functions": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Function and sub names exported by the generated file."
              }
            }
          },
          "default": [],
          "markdownDescription": "Declarations for `@import` paths that are generated during the build process and whose function names should be known to the language server.\n\nEach entry has a `path` glob pattern and a `functions` list. When a file imports a path matching `path`, the listed functions are added to the known function scope — so they are not flagged as undefined — and the import itself is shown as an informational hint rather than an unresolved warning.\n\nUse this when a plugin or code-generation tool creates `.brs` files that are not present as source files on disk but will exist at build time.\n\n**Example:**\n```json\n[\n  {\n    \"path\": \"/components/generated/PluginApi.brs\",\n    \"functions\": [\"PluginInit\", \"PluginGetData\"]\n  }\n]\n```"
        },
        "kopytko.imports.siblingPatterns": {
          "type": "array",
          "items": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "minItems": 2
          },
          "default": [],
          "markdownDescription": "Groups of file name patterns whose `.brs` files share import scope for the `import/unused` diagnostic check.\n\nFiles in the same group are always loaded together by the same XML component, so an `@import` in one file is considered used if any file in the group references one of its exported functions.\n\n**Pattern syntax:** each pattern may contain a single `*` wildcard; files with the same wildcard value in the same directory are considered siblings.\n\n**Example** — Kopytko component/template pairs:\n```json\n[\n  [\"*.component.brs\", \"*.template.brs\"],\n  [\"*.view.brs\", \"*.template.brs\"]\n]\n```\nWith this config, if `Foo.component.brs` imports `helperFn` and only `Foo.template.brs` calls it, the import is not flagged as unused."
        },
        "kopytko.readOnlyPaths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Glob patterns for files that the extension should treat as read-only. Acts as a shared fallback — applies to both formatting and linting unless overridden by `kopytko.format.readOnlyPaths` or `kopytko.lint.readOnlyPaths`.\n\n**Supported wildcards:** `*` matches any characters except `/`; `**` matches any characters including `/`.\n\n**Examples:**\n```json\n[\n  \"**/node_modules/**\",\n  \"**/generated/**\",\n  \"**/vendor/*.brs\"\n]\n```"
        },
        "kopytko.format.readOnlyPaths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Glob patterns for files that the formatter should skip. When set, overrides `kopytko.readOnlyPaths` for formatting. When empty, falls back to `kopytko.readOnlyPaths`."
        },
        "kopytko.lint.readOnlyPaths": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Glob patterns for files that the linter should skip. When set, overrides `kopytko.readOnlyPaths` for linting. When empty, falls back to `kopytko.readOnlyPaths`."
        },
        "kopytko.lint.rules.type/missing-return-type": {
          "type": "string",
          "enum": [
            "error",
            "warning",
            "info",
            "hint",
            "off"
          ],
          "default": "warning",
          "description": "Warn when a function is missing an 'as Type' return type annotation."
        },
        "kopytko.lint.rules.type/missing-param-type": {
          "type": "string",
          "enum": [
            "error",
            "warning",
            "info",
            "hint",
            "off"
          ],
          "default": "warning",
          "description": "Warn when a function parameter is missing an 'as Type' annotation."
        },
        "kopytko.lint.rules.component/duplicate-name": {
          "type": "string",
          "enum": [
            "error",
            "warning",
            "info",
            "hint",
            "off"
          ],
          "default": "warning",
          "markdownDescription": "Warn when two XML files declare the same SceneGraph component name. Component names are global to the channel, so the declaration that loads last silently wins.\n\nBuild pipelines that copy the source tree into an output directory will report every component as a duplicate — exclude the copy with `kopytko.lint.readOnlyPaths` (e.g. `**/out/**`)."
        },
        "kopytko.casing.builtin": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "enumDescriptions": [
            "Keep the catalog casing (e.g. Abs, CreateObject)",
            "ALL CAPS (e.g. ABS, CREATEOBJECT)",
            "all lowercase (e.g. abs, createobject)",
            "First letter uppercase, rest lowercase (e.g. Abs, Createobject)",
            "Each word capitalised (e.g. Abs, CreateObject)",
            "First word lowercase, subsequent words capitalised (e.g. abs, createObject)"
          ],
          "default": "preserve",
          "description": "Casing applied to BrightScript built-in function names when a completion is inserted."
        },
        "kopytko.casing.keyword": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "enumDescriptions": [
            "Keep the catalog casing (e.g. for, end sub)",
            "ALL CAPS (e.g. FOR, END SUB)",
            "all lowercase (e.g. for, end sub)",
            "First letter uppercase, rest lowercase (e.g. For, End sub)",
            "Each word capitalised (e.g. For, End Sub)",
            "First word lowercase, subsequent words capitalised (e.g. for, end Sub)"
          ],
          "default": "preserve",
          "description": "Casing applied to BrightScript keywords when a completion is inserted. Acts as fallback for type, literal, and operator casing when those are not set."
        },
        "kopytko.casing.type": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "default": "preserve",
          "markdownDescription": "Casing for BrightScript type names (`boolean`, `integer`, `string`, `void`, …). Falls back to `kopytko.casing.keyword` when not set."
        },
        "kopytko.casing.literal": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "default": "preserve",
          "markdownDescription": "Casing for literal values (`true`, `false`, `invalid`). Falls back to `kopytko.casing.keyword` when not set."
        },
        "kopytko.casing.logicOperator": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "default": "preserve",
          "markdownDescription": "Casing for logic operators (`and`, `or`, `not`). Falls back to `kopytko.casing.keyword` when not set."
        },
        "kopytko.casing.mathOperator": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "default": "preserve",
          "markdownDescription": "Casing for math operators (`mod`). Falls back to `kopytko.casing.keyword` when not set."
        },
        "kopytko.casing.method": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "enumDescriptions": [
            "Keep the catalog casing (e.g. Push, SetUrl)",
            "ALL CAPS (e.g. PUSH, SETURL)",
            "all lowercase (e.g. push, seturl)",
            "First letter uppercase, rest lowercase (e.g. Push, Seturl)",
            "Each word capitalised (e.g. Push, SetUrl)",
            "First word lowercase, subsequent words capitalised (e.g. push, setUrl)"
          ],
          "default": "preserve",
          "description": "Casing applied to component method names when a completion is inserted."
        },
        "kopytko.casing.userFunction": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "enumDescriptions": [
            "Keep the original casing",
            "ALL CAPS",
            "all lowercase",
            "First letter uppercase, rest lowercase",
            "Each word capitalised",
            "First word lowercase, subsequent words capitalised"
          ],
          "default": "preserve",
          "description": "Casing applied to user-defined function/sub names in completions and formatting."
        },
        "kopytko.casing.userMethod": {
          "type": "string",
          "enum": [
            "preserve",
            "upper-case",
            "lower-case",
            "capitalize",
            "pascal-case",
            "camel-case"
          ],
          "enumDescriptions": [
            "Keep the original casing",
            "ALL CAPS",
            "all lowercase",
            "First letter uppercase, rest lowercase",
            "Each word capitalised",
            "First word lowercase, subsequent words capitalised"
          ],
          "default": "preserve",
          "description": "Casing applied to user-defined associative array method names in completions."
        },
        "kopytko.casing.exact": {
          "type": "object",
          "default": {},
          "markdownDescription": "Per-identifier casing overrides applied after all other casing rules. Keys are identifier names (case-insensitive), values are the exact output string.\n\n**Example:**\n```json\n{\n  \"invalid\": \"Invalid\",\n  \"getglobalaa\": \"GetGlobalAA\"\n}\n```"
        },
        "kopytko.format.indentSize": {
          "type": "integer",
          "default": 4,
          "minimum": 1,
          "maximum": 8,
          "description": "Number of spaces per indentation level used by the BrightScript formatter."
        },
        "kopytko.format.useTabs": {
          "type": "boolean",
          "default": false,
          "description": "Use tabs instead of spaces for indentation."
        },
        "kopytko.format.lineEnding": {
          "type": "string",
          "enum": [
            "lf",
            "crlf",
            "auto"
          ],
          "default": "auto",
          "description": "Line ending style. 'auto' preserves the document's existing endings."
        },
        "kopytko.format.trimTrailingWhitespace": {
          "type": "boolean",
          "default": true,
          "description": "Remove trailing whitespace from lines."
        },
        "kopytko.format.insertFinalNewline": {
          "type": "boolean",
          "default": true,
          "description": "Ensure the file ends with a newline."
        },
        "kopytko.format.maxEmptyLines": {
          "type": "integer",
          "default": 2,
          "minimum": 0,
          "description": "Maximum consecutive blank lines allowed. 0 = no limit."
        },
        "kopytko.format.emptyLinesBetweenFunctions": {
          "type": "integer",
          "default": 1,
          "minimum": 0,
          "description": "Number of blank lines to enforce between top-level function/sub declarations."
        },
        "kopytko.format.emptyLinesBetweenMethods": {
          "type": "integer",
          "default": 1,
          "minimum": 0,
          "description": "Number of blank lines between AA method definitions inside a builder function."
        },
        "kopytko.format.emptyLinesAtBlockBoundaries": {
          "type": "string",
          "enum": [
            "strip",
            "enforce",
            "preserve"
          ],
          "default": "preserve",
          "description": "Blank lines at the start/end of blocks: 'strip' removes them, 'enforce' adds one."
        },
        "kopytko.format.endKeywordStyle": {
          "type": "string",
          "enum": [
            "spaced",
            "compact",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Compound end-keyword style: `spaced` = `end if`, `compact` = `endif`. Applies to endif, endfunction, endsub, endwhile, endfor, endtry."
        },
        "kopytko.format.thenStyle": {
          "type": "string",
          "enum": [
            "always",
            "never",
            "multiline-only",
            "singleline-only",
            "preserve"
          ],
          "default": "preserve",
          "description": "Controls 'then' on if-lines."
        },
        "kopytko.format.functionVsSubForVoid": {
          "type": "string",
          "enum": [
            "function",
            "sub",
            "allow-void",
            "preserve"
          ],
          "enumDescriptions": [
            "Convert all void procedures to use function keyword",
            "Convert all void procedures to use sub keyword (removes 'as Void')",
            "Allow function() as Void — keep both function-with-Void and sub as valid styles",
            "Leave as-is"
          ],
          "default": "preserve",
          "markdownDescription": "Controls function vs sub for void procedures.\n\n```brightscript\n' \"sub\": converts function foo() as Void → sub foo()\n' \"function\": converts sub foo() → function foo() as Void\n' \"allow-void\": preserves both sub foo() and function foo() as Void\n```"
        },
        "kopytko.format.spaceBeforeNamedFunctionParens": {
          "type": "boolean",
          "default": false,
          "markdownDescription": "Space before `(` in named function/sub definitions.\n\n```brightscript\n' true:  function doWork ()\n' false: function doWork()\n```"
        },
        "kopytko.format.spaceBeforeAnonymousFunctionParens": {
          "type": "boolean",
          "default": false,
          "markdownDescription": "Space before `(` in anonymous function expressions.\n\n```brightscript\n' true:  m.handler = function ()\n' false: m.handler = function()\n```"
        },
        "kopytko.format.spaceBeforeCallParens": {
          "type": "boolean",
          "default": false,
          "markdownDescription": "Space before `(` in function calls.\n\n```brightscript\n' true:  doWork ()\n' false: doWork()\n```"
        },
        "kopytko.format.spaceInsideParens": {
          "type": "string",
          "enum": [
            "never",
            "always"
          ],
          "default": "never",
          "description": "Spaces inside '()' in calls and definitions."
        },
        "kopytko.format.parenCommaSpacing": {
          "type": "string",
          "enum": [
            "preserve",
            "after",
            "before",
            "both",
            "none"
          ],
          "enumDescriptions": [
            "Keep existing spacing around commas.",
            "Space after comma only: `a(\"1\", \"2\")`.",
            "Space before comma only: `a(\"1\" ,\"2\")`.",
            "Space on both sides: `a(\"1\" , \"2\")`.",
            "No spaces around commas: `a(\"1\",\"2\")`."
          ],
          "default": "preserve",
          "markdownDescription": "Spaces around commas separating arguments in function calls and parameters in function/sub definitions — `foo(a, b)` / `function foo(a, b)`. Applies to whichever `()` most immediately encloses the comma, independent of `associativeArrayCommaSpacing`/`arrayCommaSpacing` for `{}`/`[]` elsewhere on the same line. Only applies to commas on the same line as `(` and `)` — multi-line parameter/argument lists are not affected."
        },
        "kopytko.format.paramAlignmentStyle": {
          "type": "string",
          "enum": [
            "indent",
            "align-to-paren",
            "preserve"
          ],
          "default": "preserve",
          "description": "Multi-line parameter alignment style."
        },
        "kopytko.format.maxLineLength": {
          "type": "integer",
          "default": 120,
          "minimum": 0,
          "markdownDescription": "Max line length before the formatter wraps long strings. `0` = no limit."
        },
        "kopytko.format.wrapLongStrings": {
          "type": "string",
          "enum": [
            "preserve",
            "plus",
            "array-join"
          ],
          "default": "preserve",
          "markdownDescription": "How to break long string literals.\n\n- `plus`: break with `+` concatenation\n- `array-join`: break with `[..., ...].join(\"\")`"
        },
        "kopytko.format.associativeArrayBracketSpacing": {
          "type": "boolean",
          "default": true,
          "markdownDescription": "Spaces inside `{}`: `{ key: value }` (true) vs `{key: value}` (false)."
        },
        "kopytko.format.associativeArrayCommaSpacing": {
          "type": "string",
          "enum": [
            "preserve",
            "after",
            "before",
            "both",
            "none"
          ],
          "enumDescriptions": [
            "Keep existing spacing around commas.",
            "Space after comma only: `{ a: 1, b: 2 }`.",
            "Space before comma only: `{ a: 1 ,b: 2 }`.",
            "Space on both sides: `{ a: 1 , b: 2 }`.",
            "No spaces around commas: `{ a: 1,b: 2 }`."
          ],
          "default": "preserve",
          "markdownDescription": "Spaces around commas separating key-value pairs in inline associative arrays `{}`. Only applies to commas on the same line as `{` and `}` — multi-line AAs are not affected."
        },
        "kopytko.format.arrayCommaSpacing": {
          "type": "string",
          "enum": [
            "preserve",
            "after",
            "before",
            "both",
            "none"
          ],
          "enumDescriptions": [
            "Keep existing spacing around commas.",
            "Space after comma only: `[\"1\", \"2\"]`.",
            "Space before comma only: `[\"1\" ,\"2\"]`.",
            "Space on both sides: `[\"1\" , \"2\"]`.",
            "No spaces around commas: `[\"1\",\"2\"]`."
          ],
          "default": "preserve",
          "markdownDescription": "Spaces around commas separating elements in inline arrays `[]`. Applies to whichever `[]` most immediately encloses the comma — independent of `associativeArrayCommaSpacing` for nested `{}` elements, e.g. in `[{a: 1}, {b: 2}]`. Only applies to commas on the same line as `[` and `]` — multi-line arrays are not affected."
        },
        "kopytko.format.trailingComma": {
          "type": "string",
          "enum": [
            "never",
            "always",
            "multiline"
          ],
          "default": "never",
          "description": "Trailing comma after the last item in multi-line arrays and associative arrays."
        },
        "kopytko.format.arrayCommaStyle": {
          "type": "string",
          "enum": [
            "always",
            "never",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Comma separators in multi-line arrays. BrightScript allows omitting commas when items are on separate lines.\n\n```brightscript\n' \"always\":\narr = [\n  1,\n  2,\n  3,\n]\n\n' \"never\":\narr = [\n  1\n  2\n  3\n]\n```"
        },
        "kopytko.format.associativeArrayCommaStyle": {
          "type": "string",
          "enum": [
            "always",
            "never",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Comma separators in multi-line associative arrays. BrightScript allows omitting commas when entries are on separate lines.\n\n```brightscript\n' \"always\":\nobj = {\n  name: \"foo\",\n  value: 42,\n}\n\n' \"never\":\nobj = {\n  name: \"foo\"\n  value: 42\n}\n```"
        },
        "kopytko.format.associativeArraySingleLineThreshold": {
          "type": "integer",
          "default": 0,
          "minimum": 0,
          "description": "Max number of keys before forcing an AA to multi-line. 0 = no limit."
        },
        "kopytko.format.arraySplitOpenBracket": {
          "type": "boolean",
          "default": false,
          "markdownDescription": "When `true`, splits `[{` onto separate lines in multi-item arrays for better readability.\n\n```brightscript\n' true:\nreturn [\n  {\n    name: \"Component\",\n  },\n  otherItem()\n]\n\n' false:\nreturn [{\n    name: \"Component\",\n  },\n  otherItem()\n]\n```"
        },
        "kopytko.format.associativeArrayKeySortOrder": {
          "type": "string",
          "enum": [
            "preserve",
            "alphabetical"
          ],
          "enumDescriptions": [
            "Keep entries in the order they were written.",
            "Sort entries alphabetically by key (quoted and unquoted keys sort identically)."
          ],
          "default": "preserve",
          "markdownDescription": "Sort assoc-array (`{ key: value }`) entries alphabetically by key. See `kopytko.format.sortPriorityKeys`/`kopytko.format.associativeArraySortPriorityKeys` to pin specific keys first."
        },
        "kopytko.format.sortPriorityKeys": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Global default priority-key list used by every sort scope (assoc arrays, XML interface fields, Kopytko template props) unless that scope's own override list is non-empty. Keys listed here always sort first, in this order (only for keys actually present); everything else follows alphabetically.\n\n**Example:**\n```json\n[\"id\", \"width\", \"height\"]\n```"
        },
        "kopytko.format.associativeArraySortPriorityKeys": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Priority-key override for plain assoc-array sorting (`associativeArrayKeySortOrder`). When empty, falls back to `kopytko.format.sortPriorityKeys`."
        },
        "kopytko.format.kopytkoTemplateKeyOrder": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Top-level key order enforced on detected Kopytko UI template objects — assoc arrays shaped like `{ name, props, dynamicProps, children, events }`, where a `name` key plus an `id` key inside `props`/`dynamicProps` is required for detection. Applies regardless of `associativeArrayKeySortOrder`. Nested `props`/`dynamicProps`/`events` objects are always alphabetically sorted (see `kopytkoTemplatePropsSortPriorityKeys`); `children` (an array of nested template objects) is recursed into the same way.\n\n**Empty = feature disabled.** Example:\n```json\n[\"name\", \"props\", \"dynamicProps\", \"events\", \"children\"]\n```"
        },
        "kopytko.format.kopytkoTemplatePropsSortPriorityKeys": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Priority-key override for the nested `props`/`dynamicProps`/`events` objects of a detected Kopytko template object. When empty, falls back to `kopytko.format.sortPriorityKeys`. Only has an effect when `kopytkoTemplateKeyOrder` is non-empty."
        },
        "kopytko.format.xmlInterfaceSortOrder": {
          "type": "string",
          "enum": [
            "preserve",
            "alphabetical"
          ],
          "enumDescriptions": [
            "Keep <field>/<function> entries in document order.",
            "Sort entries alphabetically — fields by their `id` attribute, functions by their `name` attribute."
          ],
          "default": "preserve",
          "markdownDescription": "Sort `<field>`/`<function>` entries inside a SceneGraph `<interface>` block alphabetically. Works through *Format Document* on `.xml` component files, and via the `kopytko-format` CLI. See `kopytko.format.xmlInterfaceGroupOrder` for field/function grouping and `kopytko.format.xmlInterfaceSortPriorityKeys` for pinning specific fields/functions first."
        },
        "kopytko.format.xmlInterfaceGroupOrder": {
          "type": "string",
          "enum": [
            "preserve",
            "fields-first",
            "functions-first"
          ],
          "enumDescriptions": [
            "Keep the original relative interleaving of <field> and <function> entries.",
            "Group all <field> entries before any <function> entries.",
            "Group all <function> entries before any <field> entries."
          ],
          "default": "preserve",
          "markdownDescription": "Relative grouping of `<field>` vs `<function>` entries inside a SceneGraph `<interface>` block."
        },
        "kopytko.format.xmlInterfaceSortPriorityKeys": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "default": [],
          "markdownDescription": "Priority-key override for XML interface sorting — matched against each `<field>`'s `id` attribute or `<function>`'s `name` attribute. When empty, falls back to `kopytko.format.sortPriorityKeys`."
        },
        "kopytko.format.spaceAroundOperators": {
          "type": "boolean",
          "default": true,
          "description": "Spaces around binary operators (+, -, *, /, <>, and, or, mod)."
        },
        "kopytko.format.spaceAroundAssignment": {
          "type": "boolean",
          "default": true,
          "description": "Spaces around = in assignments."
        },
        "kopytko.format.unarySpacing": {
          "type": "boolean",
          "default": true,
          "description": "Space after unary 'not'."
        },
        "kopytko.format.commentStyle": {
          "type": "string",
          "enum": [
            "'",
            "rem",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Normalize comment markers: `'` or `rem`, or preserve existing."
        },
        "kopytko.format.spaceAfterCommentMarker": {
          "type": "boolean",
          "default": true,
          "markdownDescription": "Enforce space after `'` or `rem`: `' comment` vs `'comment`."
        },
        "kopytko.format.commentWidth": {
          "type": "integer",
          "default": 0,
          "minimum": 0,
          "description": "Max comment line length. 0 = no limit."
        },
        "kopytko.format.sortImports": {
          "type": "boolean",
          "default": false,
          "description": "Sort @import statements alphabetically (module name first, then path)."
        },
        "kopytko.format.emptyLineAfterImports": {
          "type": "boolean",
          "default": false,
          "description": "Insert blank line after the last @import line, before code starts."
        },
        "kopytko.format.emptyLineAfterFunctionOpen": {
          "type": "boolean",
          "default": false,
          "description": "Insert empty line after function/sub opening line."
        },
        "kopytko.format.emptyLineBeforeFunctionClose": {
          "type": "boolean",
          "default": false,
          "description": "Insert empty line before end function/sub."
        },
        "kopytko.format.emptyLineBeforeReturn": {
          "type": [
            "string",
            "boolean"
          ],
          "enum": [
            "always",
            "not-alone",
            false
          ],
          "enumDescriptions": [
            "Always add an empty line before return",
            "Add an empty line only when return is NOT the sole statement in a block",
            "Do not enforce empty lines before return"
          ],
          "default": false,
          "markdownDescription": "Empty line before `return` statements. `not-alone` skips the empty line when `return` is the only statement in its block (e.g. a guard clause like `if x then return`)."
        },
        "kopytko.format.emptyLineBeforeComment": {
          "type": "boolean",
          "default": false,
          "description": "Enforce empty line before stand-alone comment blocks."
        },
        "kopytko.format.parenthesisIfCase": {
          "type": "string",
          "enum": [
            "preserve",
            "always",
            "never"
          ],
          "default": "preserve",
          "description": "Wrap if-condition in parentheses: 'always' adds them, 'never' removes them."
        },
        "kopytko.format.elseOnNewLine": {
          "type": "boolean",
          "default": true,
          "description": "Place 'else' on its own line."
        },
        "kopytko.format.forLoopSpacing": {
          "type": "boolean",
          "default": true,
          "description": "Enforce spaces around 'to' and 'step' in for loops."
        },
        "kopytko.format.printStatement": {
          "type": "string",
          "enum": [
            "warn",
            "remove",
            "preserve"
          ],
          "default": "preserve",
          "description": "Flag or remove print debug statements."
        },
        "kopytko.format.lineCommentPosition": {
          "type": "string",
          "enum": [
            "above",
            "inline",
            "preserve"
          ],
          "default": "preserve",
          "description": "Move trailing comments: 'above' puts them on the line above."
        },
        "kopytko.format.stringConcatStyle": {
          "type": "string",
          "enum": [
            "preserve",
            "plus",
            "array-join"
          ],
          "default": "preserve",
          "markdownDescription": "Normalize string concatenation style.\n\n```brightscript\n' \"plus\":\nresult = \"hello\" + \" \" + \"world\"\n\n' \"array-join\":\nresult = [\"hello\", \" \", \"world\"].join(\"\")\n```"
        },
        "kopytko.format.observeFieldStyle": {
          "type": "string",
          "enum": [
            "always-scoped",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Enforce `observeFieldScoped` over `observeField`. Using non-scoped `observeField` can cause memory leaks.\n\n```brightscript\n' \"always-scoped\": converts\nobserveField → observeFieldScoped\n```"
        },
        "kopytko.format.mPrefixStyle": {
          "type": "string",
          "enum": [
            "dot",
            "bracket",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Normalize `m`-prefix field access style.\n\n```brightscript\n' \"dot\":\nm.fieldName\nm.top.visible\n\n' \"bracket\":\nm[\"fieldName\"]\nm.top[\"visible\"]\n```"
        },
        "kopytko.format.alignAssignments": {
          "type": "boolean",
          "default": false,
          "markdownDescription": "Align `=` signs in consecutive assignment lines.\n\n```brightscript\n' true:\nname    = \"app\"\nversion = \"1.0\"\ncount   = 42\n\n' false:\nname = \"app\"\nversion = \"1.0\"\ncount = 42\n```"
        },
        "kopytko.format.fieldAccessConsistency": {
          "type": "string",
          "enum": [
            "dot",
            "method",
            "preserve"
          ],
          "default": "preserve",
          "markdownDescription": "Field access consistency on nodes.\n\n```brightscript\n' \"dot\": prefers dot notation\nm.top.visible = true\nvalue = m.top.id\n\n' \"method\": prefers getField/setField\nm.top.setField(\"visible\", true)\nvalue = m.top.getField(\"id\")\n```"
        },
        "kopytko.format.verifySyntax": {
          "type": "boolean",
          "default": true,
          "description": "Verify that formatted output re-parses to an equivalent AST before applying it, catching formatter bugs. Disable only to debug or skip that safety check."
        },
        "kopytko.deviceDiscovery.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Enable automatic Roku device discovery via SSDP."
        },
        "kopytko.deviceDiscovery.scanTimeout": {
          "type": "number",
          "default": 5000,
          "description": "Timeout in milliseconds for active SSDP device scans."
        },
        "kopytko.deviceDiscovery.showNotifications": {
          "type": "boolean",
          "default": true,
          "description": "Show notification messages when devices come online or go offline."
        },
        "kopytko.console.defaultPort": {
          "type": "number",
          "enum": [
            8085,
            8080
          ],
          "enumDescriptions": [
            "BrightScript runtime console — app output and the interactive BrightScript Debugger prompt.",
            "SceneGraph debug server — chanperf, sgnodes, sgperf, textures, and other utilities."
          ],
          "default": 8085,
          "description": "Debug console port the Kopytko Console selects when it opens."
        },
        "kopytko.console.autoConnect": {
          "type": "boolean",
          "default": false,
          "description": "Connect to the active device automatically when the Kopytko Console panel opens."
        },
        "kopytko.console.maxLines": {
          "type": "number",
          "default": 20000,
          "description": "Maximum number of output lines kept per console port. Older lines are dropped from the buffer."
        },
        "kopytko.console.reconnect": {
          "type": "boolean",
          "default": true,
          "description": "Reconnect automatically (with backoff) when the console connection drops."
        },
        "kopytko.console.colorize": {
          "type": "boolean",
          "default": true,
          "description": "Colour console output by severity — errors, warnings, beacons, rendezvous logs, and debugger frames."
        },
        "kopytko.console.logToFile": {
          "type": "boolean",
          "default": false,
          "description": "Append every console line to a log file as it arrives, in addition to the in-memory buffer."
        },
        "kopytko.console.outputDir": {
          "type": "string",
          "default": "debug",
          "description": "Folder (relative to the workspace root, or absolute) where console logs and saved output are written."
        },
        "kopytko.console.historySize": {
          "type": "number",
          "default": 200,
          "description": "Number of submitted commands remembered per console port for history recall."
        },
        "kopytko.diagnostics.outputDir": {
          "type": "string",
          "default": "debug",
          "description": "Folder (relative to the workspace root, or absolute) where diagnostics sessions are saved. Each session gets its own timestamped subfolder."
        },
        "kopytko.diagnostics.maxLivePoints": {
          "type": "number",
          "default": 3600,
          "description": "Maximum number of samples kept in memory per stream for the live view. Older points are dropped from the live charts but remain on disk."
        },
        "kopytko.diagnostics.debugConsolePort": {
          "type": "number",
          "default": 8080,
          "description": "TCP port of the Roku SceneGraph debug server used for chanperf / sgnodes / texture metrics."
        },
        "kopytko.diagnostics.collectors.memCpu.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Collect per-channel CPU and memory usage (chanperf)."
        },
        "kopytko.diagnostics.collectors.memCpu.intervalMs": {
          "type": "number",
          "default": 1000,
          "description": "Polling interval in milliseconds for per-channel CPU/memory."
        },
        "kopytko.diagnostics.collectors.nodeCounts.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Collect SceneGraph node counts by type (sgnodes counts)."
        },
        "kopytko.diagnostics.collectors.nodeCounts.intervalMs": {
          "type": "number",
          "default": 2000,
          "description": "Polling interval in milliseconds for node counts."
        },
        "kopytko.diagnostics.collectors.objectCounts.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Collect BrightScript object counts by type via ECP /query/app-object-counts. Only polled while the Objects chart or table is visible in the panel (both hidden by default)."
        },
        "kopytko.diagnostics.collectors.objectCounts.intervalMs": {
          "type": "number",
          "default": 2000,
          "description": "Polling interval in milliseconds for object counts."
        },
        "kopytko.diagnostics.collectors.rendezvous.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Collect render-thread rendezvous via ECP."
        },
        "kopytko.diagnostics.collectors.rendezvous.intervalMs": {
          "type": "number",
          "default": 1000,
          "description": "Polling interval in milliseconds for rendezvous events."
        },
        "kopytko.diagnostics.collectors.systemMem.enabled": {
          "type": "boolean",
          "default": false,
          "description": "Collect device-wide memory (free). Off by default; per-channel memory is usually more useful."
        },
        "kopytko.diagnostics.collectors.systemMem.intervalMs": {
          "type": "number",
          "default": 5000,
          "description": "Polling interval in milliseconds for device-wide memory."
        },
        "kopytko.diagnostics.collectors.textures.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Collect GPU texture/bitmap memory (r2d2_bitmaps). Enabled by default; the Textures chart/table only shows when selected in the Charts/Tables dropdowns."
        },
        "kopytko.diagnostics.collectors.textures.intervalMs": {
          "type": "number",
          "default": 5000,
          "description": "Polling interval in milliseconds for texture memory."
        },
        "kopytko.diagnostics.collectors.appState.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Track app foreground/background state via ECP /query/app-state, shown as background shading on the charts. Requires \"Control by mobile apps\" enabled on the device — degrades to no shading (not an error) when unavailable."
        },
        "kopytko.diagnostics.collectors.appState.intervalMs": {
          "type": "number",
          "default": 2000,
          "description": "Polling interval in milliseconds for app state."
        },
        "kopytko.diagnostics.collectors.fwBeacon.enabled": {
          "type": "boolean",
          "default": true,
          "description": "Track framework beacon markers (AppLaunch/AppResume/VODStart Initiate/Complete) via ECP /fwbeacons. Enabled by default, including the Beacons checkbox."
        },
        "kopytko.diagnostics.collectors.fwBeacon.intervalMs": {
          "type": "number",
          "default": 1000,
          "description": "Polling interval in milliseconds for framework beacon events."
        },
        "kopytko.diagnostics.defaultVisibleCharts": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "memory",
              "cpu",
              "nodes",
              "objects",
              "textures"
            ]
          },
          "default": [
            "memory",
            "cpu",
            "nodes"
          ],
          "description": "Charts shown by default when the diagnostics panel opens. The corresponding data is only collected while at least one visible chart or table needs it."
        },
        "kopytko.diagnostics.defaultVisibleTables": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "nodes",
              "objects",
              "rendezvous",
              "textures"
            ]
          },
          "default": [
            "nodes",
            "rendezvous"
          ],
          "description": "Tables shown by default when the diagnostics panel opens."
        },
        "kopytko.diagnostics.memoryLimits.backgroundMB": {
          "type": "number",
          "default": 100,
          "description": "Reference line on the Memory chart for Roku's published background-app DRAM guidance. Not device-reported (unlike the foreground limit, which comes from chanperf) — Roku publishes this as a fixed recommendation that may change between OS versions, hence configurable here."
        },
        "kopytko.deviceManager.holdThresholdMs": {
          "type": "number",
          "default": 1000,
          "description": "Remote Control: how long (ms) a button must be held before a press becomes a keydown/keyup hold instead of a single keypress."
        },
        "kopytko.deviceManager.runner.pollIntervalMs": {
          "type": "number",
          "default": 500,
          "description": "Script runner: how often (ms) to poll the device for wait_for_player_state / validate_streaming / launch completion."
        },
        "kopytko.deviceManager.runner.waitTimeoutSec": {
          "type": "number",
          "default": 30,
          "description": "Script runner: how long (seconds) wait_for_player_state and validate_streaming wait for the expected player state before failing the step."
        },
        "kopytko.perfetto.ecpPort": {
          "type": "number",
          "default": 8060,
          "description": "ECP port used for Perfetto tracing control and the WebSocket connection."
        },
        "kopytko.perfetto.refreshIntervalMs": {
          "type": "number",
          "default": 3000,
          "description": "How often (in milliseconds) the live buffer is pushed to the Perfetto UI iframe."
        },
        "kopytko.perfetto.startCommand": {
          "type": "string",
          "default": "",
          "description": "Build and deploy command for Perfetto sessions. Defaults to `npx kopytko start` when empty."
        },
        "kopytko.network.proxyPort": {
          "type": "number",
          "default": 8888,
          "description": "Local port the Network Inspector capture proxy listens on. Device traffic is redirected here."
        },
        "kopytko.network.redirectPorts": {
          "type": "array",
          "items": {
            "type": "number"
          },
          "default": [
            80
          ],
          "description": "Device-side ports whose traffic is transparently redirected into the capture proxy (HTTP only)."
        },
        "kopytko.network.maxEntries": {
          "type": "number",
          "default": 5000,
          "description": "Maximum number of captured requests kept in memory before the oldest are dropped."
        },
        "kopytko.network.maxBufferBytes": {
          "type": "number",
          "default": 52428800,
          "description": "Approximate memory budget in bytes for the captured-flow buffer (retained bodies + header overhead). Oldest requests are evicted when exceeded. 0 disables the byte cap; kopytko.network.maxEntries still applies."
        },
        "kopytko.network.upstreamKeepAlive": {
          "type": "boolean",
          "default": true,
          "description": "Reuse upstream connections (HTTP keep-alive) between the capture proxy and origin servers, avoiding a fresh TCP/TLS handshake per request. The device-side connection is always closed per request. Disable if an origin misbehaves with connection reuse."
        },
        "kopytko.network.filterToActiveDevice": {
          "type": "boolean",
          "default": true,
          "description": "Only show traffic originating from the active Roku device's IP (hides the dev machine's own traffic)."
        },
        "kopytko.network.maxBodyBytes": {
          "type": "number",
          "default": 262144,
          "description": "Maximum bytes of each request/response body retained in memory for inline display and HAR export. The full body is always forwarded to the device, and is persisted uncapped to the capture session folder (see kopytko.network.outputDir) for the “Open full body in editor” action."
        },
        "kopytko.network.outputDir": {
          "type": "string",
          "default": "debug",
          "description": "Folder (relative to the workspace root, or absolute) where Network Inspector capture sessions are saved — flow metadata plus full request/response bodies. Each capture session gets its own timestamped subfolder."
        },
        "kopytko.network.defaultUpstreamScheme": {
          "type": "string",
          "enum": [
            "https",
            "http",
            "auto"
          ],
          "default": "https",
          "description": "Scheme the proxy uses to reach an origin when the device called it over HTTP. `https` bridges the plaintext device call to a secure upstream connection."
        },
        "kopytko.network.winDivertDir": {
          "type": "string",
          "default": "",
          "scope": "machine",
          "description": "Windows only, and usually unnecessary — this extension bundles a working WinDivert driver for 64-bit Windows. Only set this to override it with a different WinDivert build/version, or on a non-x64 architecture the bundled driver doesn't cover. A local driver path is inherently per-machine, so this can only be set in User Settings, never in a workspace/team settings.json."
        },
        "kopytko.network.rewriteRules": {
          "type": "array",
          "default": [],
          "description": "Body rewrite rules applied to text request/response bodies. Each item: { enabled, direction: 'response'|'request', hostPattern?, pathPattern?, contentTypePattern?, find, replace, isRegex? }. When empty, the built-in `https://` → `http://` and `wss://` → `ws://` response rules are used.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "direction": {
                "type": "string",
                "enum": [
                  "response",
                  "request"
                ],
                "default": "response"
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              },
              "contentTypePattern": {
                "type": "string"
              },
              "find": {
                "type": "string"
              },
              "replace": {
                "type": "string"
              },
              "isRegex": {
                "type": "boolean",
                "default": false
              }
            }
          }
        },
        "kopytko.network.rewriteExcludeRules": {
          "type": "array",
          "default": [],
          "description": "Opt specific host+path combinations out of ALL body rewriting (every enabled rewrite rule, both directions) — for a response that must reach the device byte-for-byte even though a broad rule like the built-in https→http one would otherwise match it. Each item: { enabled?, hostPattern?, pathPattern? }.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              }
            }
          }
        },
        "kopytko.network.upstreamSchemes": {
          "type": "array",
          "default": [],
          "description": "Per-host upstream scheme overrides. Each item: { hostPattern, scheme: 'https'|'http'|'auto' }.",
          "items": {
            "type": "object",
            "properties": {
              "hostPattern": {
                "type": "string"
              },
              "scheme": {
                "type": "string",
                "enum": [
                  "https",
                  "http",
                  "auto"
                ],
                "default": "https"
              }
            }
          }
        },
        "kopytko.network.mapLocalRules": {
          "type": "array",
          "default": [],
          "description": "Serve a local file or inline body instead of contacting the upstream when host/path match. Each item: { enabled?, hostPattern, pathPattern?, filePath?, body?, contentType?, status? }. filePath wins over body; a rule with neither is ignored.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              },
              "filePath": {
                "type": "string"
              },
              "body": {
                "type": "string"
              },
              "contentType": {
                "type": "string"
              },
              "status": {
                "type": "number"
              }
            }
          }
        },
        "kopytko.network.latencyRules": {
          "type": "array",
          "default": [],
          "description": "Delay matched responses by delayMs before sending them to the device — simulate slow backends. Each item: { enabled?, hostPattern, pathPattern?, delayMs }.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              },
              "delayMs": {
                "type": "number"
              }
            }
          }
        },
        "kopytko.network.headerRules": {
          "type": "array",
          "default": [],
          "description": "Add/set/remove request or response headers for matched hosts. Each item: { enabled?, direction: 'request'|'response', hostPattern?, op: 'set'|'add'|'remove', name, value? }. Proxy-managed headers (content-length, transfer-encoding, connection, host) cannot be changed.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "direction": {
                "type": "string",
                "enum": [
                  "request",
                  "response"
                ],
                "default": "response"
              },
              "hostPattern": {
                "type": "string"
              },
              "op": {
                "type": "string",
                "enum": [
                  "set",
                  "add",
                  "remove"
                ],
                "default": "set"
              },
              "name": {
                "type": "string"
              },
              "value": {
                "type": "string"
              }
            }
          }
        },
        "kopytko.network.blockRules": {
          "type": "array",
          "default": [],
          "description": "Abort matched requests before they reach the upstream — the device sees a connection reset, for testing the channel's network-error handling. Each item: { enabled?, hostPattern, pathPattern? }.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              }
            }
          }
        },
        "kopytko.network.breakpointRules": {
          "type": "array",
          "default": [],
          "description": "Pause matched requests and/or responses so you can edit them live before continuing. Each item: { enabled?, hostPattern, pathPattern?, onRequest?, onResponse? }.",
          "items": {
            "type": "object",
            "properties": {
              "enabled": {
                "type": "boolean",
                "default": true
              },
              "hostPattern": {
                "type": "string"
              },
              "pathPattern": {
                "type": "string"
              },
              "onRequest": {
                "type": "boolean",
                "default": true
              },
              "onResponse": {
                "type": "boolean",
                "default": false
              }
            }
          }
        },
        "kopytko.network.breakpointTimeoutMs": {
          "type": "number",
          "default": 30000,
          "description": "How long a breakpoint pause waits for you to act before auto-continuing the request/response unmodified, so a forgotten breakpoint can't hang the device."
        }
      }
    },
    "snippets": [
      {
        "language": "brightscript",
        "path": "./snippets/brightscript.json"
      }
    ],
    "jsonValidation": [
      {
        "fileMatch": "**/.kopytkorc",
        "url": "./schemas/kopytkorc.schema.json"
      }
    ],
    "breakpoints": [
      {
        "language": "brightscript"
      }
    ],
    "debuggers": [
      {
        "type": "kopytko",
        "label": "Kopytko BrightScript",
        "languages": [
          "brightscript"
        ],
        "configurationAttributes": {
          "launch": {
            "properties": {
              "host": {
                "type": "string",
                "description": "IP address of the Roku device. Auto-filled from the active device in the Roku Devices panel if omitted."
              },
              "password": {
                "type": "string",
                "description": "Developer password. Auto-filled from the active device's stored credentials if omitted."
              },
              "rootDir": {
                "type": "string",
                "description": "Root directory of the BrightScript project (where .kopytkorc lives).",
                "default": "${workspaceFolder}"
              },
              "env": {
                "type": "string",
                "description": "Kopytko environment to build (matches .kopytkorc environments key). Auto-filled from the active device's environment selection if omitted."
              },
              "stopOnEntry": {
                "type": "boolean",
                "description": "Pause execution at the first line of main on launch.",
                "default": false
              },
              "startCommand": {
                "type": "string",
                "description": "Command to build and deploy the project (default: 'npx kopytko start'). Must accept env as a positional argument and ROKU_IP, ROKU_DEV_PASSWORD, ENV as environment variables.",
                "default": "npx kopytko start"
              }
            }
          }
        },
        "initialConfigurations": [
          {
            "type": "kopytko",
            "request": "launch",
            "name": "Run on Roku",
            "rootDir": "${workspaceFolder}"
          }
        ],
        "configurationSnippets": [
          {
            "label": "BrightScript: Launch on Roku",
            "description": "Package and deploy the current project to a Roku device. Host, password, and env are auto-filled from the active device if omitted.",
            "body": {
              "type": "kopytko",
              "request": "launch",
              "name": "Run on Roku",
              "rootDir": "^\"${workspaceFolder}\""
            }
          }
        ]
      }
    ],
    "viewsContainers": {
      "activitybar": [
        {
          "id": "kopytko-sidebar",
          "title": "Kopytko",
          "icon": "images/kopytko-logo.svg"
        },
        {
          "id": "kopytko-device-manager",
          "title": "Kopytko Device Manager",
          "icon": "images/remote-control.svg"
        }
      ],
      "panel": [
        {
          "id": "kopytko-diagnostics",
          "title": "Kopytko Diagnostics",
          "icon": "images/kopytko-logo.svg"
        },
        {
          "id": "kopytko-console",
          "title": "Kopytko Console",
          "icon": "images/kopytko-logo.svg"
        }
      ]
    },
    "views": {
      "kopytko-diagnostics": [
        {
          "type": "webview",
          "id": "kopytko.diagnostics",
          "name": "Kopytko Diagnostics"
        }
      ],
      "kopytko-console": [
        {
          "type": "webview",
          "id": "kopytko.console",
          "name": "Kopytko Console"
        }
      ],
      "kopytko-sidebar": [
        {
          "id": "kopytko.rokuDevices",
          "icon": "images/roku-device.svg",
          "name": "Roku Devices"
        },
        {
          "type": "webview",
          "id": "kopytko.nav",
          "icon": "images/kopytko-logo.svg",
          "name": "Tools"
        }
      ],
      "kopytko-device-manager": [
        {
          "type": "webview",
          "id": "kopytko.deviceManager.remote",
          "icon": "images/remote-control.svg",
          "name": "Remote Control"
        },
        {
          "type": "webview",
          "id": "kopytko.deviceManager.scripts",
          "icon": "images/roku-device.svg",
          "name": "Scripts",
          "collapsed": true
        }
      ]
    },
    "commands": [
      {
        "command": "kopytko.deviceManager.open",
        "title": "Open Device Manager",
        "icon": "$(device-mobile)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.deviceManager.toggleRemoteMode",
        "title": "Toggle Remote Control Keyboard Mode",
        "icon": "$(broadcast)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.deviceManager.newScript",
        "title": "New Device Script",
        "icon": "$(file-code)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.refreshDevices",
        "title": "Refresh Roku Devices",
        "icon": "$(refresh)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.selectDevice",
        "title": "Set as Active Device",
        "icon": "$(plug)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.unselectDevice",
        "title": "Unset Active Device",
        "icon": "$(debug-disconnect)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.addDevice",
        "title": "Add Device by IP",
        "icon": "$(add)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.addFavorite",
        "title": "Add to Favorites",
        "icon": "$(star-empty)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.removeFavorite",
        "title": "Remove from Favorites",
        "icon": "$(star-full)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.setDevicePassword",
        "title": "Set Device Password",
        "icon": "$(key)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.clearDevicePassword",
        "title": "Clear Device Password",
        "icon": "$(close)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.copyDeviceIp",
        "title": "Copy IP Address",
        "icon": "$(clippy)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.openDevicePortal",
        "title": "Open Web Portal",
        "icon": "$(globe)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.removeDevice",
        "title": "Remove Device",
        "icon": "$(trash)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.copyToClipboard",
        "title": "Copy to Clipboard",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.readRegistry",
        "title": "Read Registry",
        "icon": "$(database)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.setDeviceEnvironment",
        "title": "Set Environment",
        "icon": "$(symbol-namespace)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.uploadToDevice",
        "title": "Start (Ctrl+Shift+F5)",
        "icon": "$(run)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.debugDevice",
        "title": "Start Debugging (F5)",
        "icon": "$(debug-alt)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.open",
        "title": "Open Console",
        "icon": "$(terminal)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.connect",
        "title": "Connect Console",
        "icon": "$(plug)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.disconnect",
        "title": "Disconnect Console",
        "icon": "$(debug-disconnect)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.clear",
        "title": "Clear Console",
        "icon": "$(clear-all)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.saveOutput",
        "title": "Save Console Output",
        "icon": "$(save)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.selectPort",
        "title": "Select Console Port",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.console.showCommands",
        "title": "Show Console Commands",
        "icon": "$(list-unordered)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.diagnostics.startSession",
        "title": "Start Diagnostics Session",
        "icon": "$(record)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.diagnostics.stopSession",
        "title": "Stop Diagnostics Session",
        "icon": "$(stop-circle)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.nodes.open",
        "title": "Open SceneGraph Tree",
        "icon": "$(type-hierarchy)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.deepLinking.open",
        "title": "Open Deep Linking",
        "icon": "$(link)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.rokuPay.open",
        "title": "Open Roku Pay Web Services",
        "icon": "$(credit-card)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.perfetto.open",
        "title": "Open Kopytko Perfetto",
        "icon": "$(pulse)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.perfetto.startSession",
        "title": "Start Perfetto Tracing Session",
        "icon": "$(record)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.perfetto.stopSession",
        "title": "Stop Perfetto Tracing Session",
        "icon": "$(stop-circle)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.perfetto.captureHeapSnapshot",
        "title": "Capture Heap Snapshot (Perfetto)",
        "icon": "$(database)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.network.open",
        "title": "Open Network Inspector",
        "icon": "$(radio-tower)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.network.toggleCapture",
        "title": "Toggle Network Capture",
        "icon": "$(debug-disconnect)",
        "category": "Kopytko"
      },
      {
        "command": "kopytko.network.clear",
        "title": "Clear Network Capture",
        "icon": "$(clear-all)",
        "category": "Kopytko"
      }
    ],
    "menus": {
      "view/title": [
        {
          "command": "kopytko.refreshDevices",
          "when": "view == kopytko.rokuDevices",
          "group": "navigation@1"
        },
        {
          "command": "kopytko.addDevice",
          "when": "view == kopytko.rokuDevices",
          "group": "navigation@2"
        }
      ],
      "commandPalette": [],
      "view/item/context": [
        {
          "command": "kopytko.selectDevice",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/ && viewItem =~ /^(?!.*-active)/",
          "group": "inline@1"
        },
        {
          "command": "kopytko.unselectDevice",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-active/",
          "group": "inline@1"
        },
        {
          "command": "kopytko.uploadToDevice",
          "when": "view == kopytko.rokuDevices && (viewItem =~ /^rokuDevice.*-online/ || viewItem =~ /^rokuDevice.*-active/)",
          "group": "inline@2"
        },
        {
          "command": "kopytko.debugDevice",
          "when": "view == kopytko.rokuDevices && (viewItem =~ /^rokuDevice.*-online/ || viewItem =~ /^rokuDevice.*-active/)",
          "group": "inline@3"
        },
        {
          "command": "kopytko.addFavorite",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/ && viewItem =~ /^(?!.*-favorite)/",
          "group": "inline@4"
        },
        {
          "command": "kopytko.removeFavorite",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-favorite/",
          "group": "inline@4"
        },
        {
          "command": "kopytko.selectDevice",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/ && viewItem =~ /^(?!.*-active)/",
          "group": "device@1"
        },
        {
          "command": "kopytko.unselectDevice",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-active/",
          "group": "device@1"
        },
        {
          "command": "kopytko.uploadToDevice",
          "when": "view == kopytko.rokuDevices && (viewItem =~ /^rokuDevice.*-online/ || viewItem =~ /^rokuDevice.*-active/)",
          "group": "device@2"
        },
        {
          "command": "kopytko.debugDevice",
          "when": "view == kopytko.rokuDevices && (viewItem =~ /^rokuDevice.*-online/ || viewItem =~ /^rokuDevice.*-active/)",
          "group": "device@3"
        },
        {
          "command": "kopytko.addFavorite",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/ && viewItem =~ /^(?!.*-favorite)/",
          "group": "device@4"
        },
        {
          "command": "kopytko.removeFavorite",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-favorite/",
          "group": "device@4"
        },
        {
          "command": "kopytko.setDevicePassword",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/",
          "group": "credentials@1"
        },
        {
          "command": "kopytko.clearDevicePassword",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/",
          "group": "credentials@2"
        },
        {
          "command": "kopytko.copyDeviceIp",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice/",
          "group": "info@1"
        },
        {
          "command": "kopytko.openDevicePortal",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-online/",
          "group": "info@2"
        },
        {
          "command": "kopytko.removeDevice",
          "when": "view == kopytko.rokuDevices && viewItem =~ /^rokuDevice.*-favorite/",
          "group": "danger@1"
        },
        {
          "command": "kopytko.setDeviceEnvironment",
          "when": "view == kopytko.rokuDevices && viewItem == deviceEnvironment",
          "group": "inline@1"
        },
        {
          "command": "kopytko.setDeviceEnvironment",
          "when": "view == kopytko.rokuDevices && viewItem == deviceEnvironment",
          "group": "environment@1"
        }
      ]
    },
    "keybindings": [
      {
        "command": "kopytko.uploadToDevice",
        "key": "ctrl+shift+f5",
        "mac": "ctrl+shift+f5",
        "when": "!inDebugMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "up",
        "args": {
          "key": "Up"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "down",
        "args": {
          "key": "Down"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "left",
        "args": {
          "key": "Left"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "right",
        "args": {
          "key": "Right"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "enter",
        "args": {
          "key": "Select"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "escape",
        "args": {
          "key": "Back"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "backspace",
        "args": {
          "key": "Backspace"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "home",
        "args": {
          "key": "Home"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+enter",
        "mac": "cmd+enter",
        "args": {
          "key": "Play"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+left",
        "mac": "cmd+left",
        "args": {
          "key": "Rev"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+right",
        "mac": "cmd+right",
        "args": {
          "key": "Fwd"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+backspace",
        "mac": "cmd+backspace",
        "args": {
          "key": "InstantReplay"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+8",
        "mac": "cmd+8",
        "args": {
          "key": "Info"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+up",
        "mac": "cmd+up",
        "args": {
          "key": "VolumeUp"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+down",
        "mac": "cmd+down",
        "args": {
          "key": "VolumeDown"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.pressKey",
        "key": "ctrl+m",
        "mac": "cmd+m",
        "args": {
          "key": "VolumeMute"
        },
        "when": "kopytko.deviceManager.remoteMode"
      },
      {
        "command": "kopytko.deviceManager.toggleRemoteMode",
        "key": "ctrl+k",
        "mac": "cmd+k",
        "when": "kopytko.deviceManager.remoteMode"
      }
    ]
  },
  "configurationDefaults": {
    "editor.tokenColorCustomizations": {
      "textMateRules": [
        {
          "scope": "keyword.preprocessor.brightscript",
          "settings": {
            "foreground": "#C586C0"
          }
        },
        {
          "scope": "keyword.control.import.brightscript",
          "settings": {
            "foreground": "#C586C0"
          }
        },
        {
          "scope": "keyword.control.mock.brightscript",
          "settings": {
            "foreground": "#CE9178"
          }
        },
        {
          "scope": "string.unquoted.kopytko.import.path",
          "settings": {
            "foreground": "#CE9178"
          }
        },
        {
          "scope": "entity.name.module.kopytko",
          "settings": {
            "foreground": "#4EC9B0"
          }
        },
        {
          "scope": "punctuation.definition.annotation.brightscript",
          "settings": {
            "foreground": "#6A9955"
          }
        }
      ]
    }
  }
}