@duet3d/monacotokens 3.7.0-alpha.1 → 3.7.0-alpha.3

package/dist/monaco-gcode.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gcodeCNCLanguage = exports.gcodeFDMLanguage = void 0;
+exports.gcodeLanguageConfiguration = exports.gcodeCNCLanguage = exports.gcodeFDMLanguage = void 0;
 /**
  * Generate a Monarch language for RRF-style G-code
  * @param cncMode If true, comments in parentheses are allowed
@@ -8,17 +8,26 @@ exports.gcodeCNCLanguage = exports.gcodeFDMLanguage = void 0;
 function generateMonarchLanguage(fdmMode) {
     return {
         consts: ["true", "false", "iterations", "line", "null", "pi", "result", "input"],
-        functions: ["abs", "acos", "asin", "atan", "atan2", "cos", "degrees", "exists", "fileexists", "fileread", "floor", "isnan", "max",
-            "min", "mod", "radians", "random", "sin", "square", "sqrt", "tan", "vector", "take", "drop", "find"],
-        keywords: ["abort", "echo", "if", "elif", "while", "set"],
-        noArgKeywords: ["else", "break", "continue"],
+        functions: ["abs", "acos", "asin", "atan", "atan2", "ceil", "cos", "datetime", "degrees", "drop", "exists", "exp", "fileexists", "fileread",
+            "find", "floor", "isnan", "log", "max", "min", "mod", "pow", "radians", "random", "round", "sin", "sqrt", "square", "take", "tan", "vector"],
+        // Non-flow meta keywords that take an expression after (abort/echo/set) - render as regular keywords (blue)
+        keywords: ["abort", "echo", "set"],
+        // Flow-control keywords that take a condition/expression - render in Monaco's flow-keyword purple (matches VSCode)
+        flowExprKeywords: ["if", "elif", "while"],
+        // Flow-control keywords that stand alone - render in the same purple as flowExprKeywords
+        flowNoArgKeywords: ["else", "break", "continue"],
         varKeywords: ["global", "var"],
         symbols: /[=><!~?:&|+\-*#\/\^%]+/,
         operators: ['*', '/', '+', '-', "==", "!=", '=', "<=", '<', ">=", ">>>", ">>", '>', '!', "&&", '&', "||", '|', '^', '?', ':'],
         includeLF: true,
         tokenizer: {
             root: [
-                // G/M/T-codes
+                // line numbers
+                [/[nN]\d+/, "type"],
+                // G53 acting as a same-line prefix (e.g. "G53 G1 X10") - highlight as a modifier, distinct from both
+                // line numbers (type) and regular codes (keyword)
+                [/[gG]53(?=[\s]+[gGmMtT][0-9-])/, "regexp", "afterG53"],
+                // G/M/T-codes (including bare G53 on its own line, which behaves like a regular command)
                 [/[gG][0123](?=\D)/, "keyword", fdmMode ? "normalGcode" : "moveGcode"],
                 [/[gGmM]\d+(\.\d+)?/, "keyword", "normalGcode"],
                 [/[tT](?=\{)/, "keyword", "normalGcodeWithT"],
@@ -27,7 +36,8 @@ function generateMonarchLanguage(fdmMode) {
                 [/[a-z_$][\w$]*/, {
                         cases: {
                             "@keywords": { token: "keyword", next: "@lineExpression" },
-                            "@noArgKeywords": { token: "keyword" },
+                            "@flowExprKeywords": { token: "keyword.flow", next: "@lineExpression" },
+                            "@flowNoArgKeywords": { token: "keyword.flow" },
                             "@varKeywords": { token: "keyword", next: "varName" }
                         }
                     }],
@@ -37,18 +47,28 @@ function generateMonarchLanguage(fdmMode) {
                 [/\d+/, "number"],
                 // strings
                 [/"(.|\"\")*?"/, "string"],
+                [/"[^"\n]*/, "invalid"],
                 // comments
                 [/;.*/, "comment"],
                 [/\(.*\)/, fdmMode ? "invalid" : "comment"]
             ],
+            afterG53: [
+                // whitespace between the G53 prefix and the following G/M/T-code
+                [/[ \t]+/, ""],
+                // next G/M/T-code - replace this state with the code's own state so its parameters
+                // are parsed normally and any trailing T letters are treated as parameters, not T-codes
+                [/[gG][0123](?=\D)/, { token: "keyword", switchTo: fdmMode ? "@normalGcode" : "@moveGcode" }],
+                [/[gGmM]\d+(\.\d+)?/, { token: "keyword", switchTo: "@normalGcode" }],
+                [/[tT](?=\{)/, { token: "keyword", switchTo: "@normalGcodeWithT" }],
+                [/[tT]-?\d+/, { token: "keyword", switchTo: "@normalGcodeWithT" }]
+            ],
             gcode: [
-                // next G/M/T-code
-                [/[gG][0123](?=\D)/, "keyword", "moveGcode"],
-                [/[gGmM]\d+(\.\d*)?/, "keyword", "normalGcode"],
-                [/[tT](?=\{)/, "keyword", "normalGcodeWithT"],
-                [/[tT]-?\d+/, "keyword", "normalGcodeWithT"],
+                // checksums
+                [/\*\d+/, "type"],
                 // parameter letters
                 [/'?[a-zA-Z]/, "keyword"],
+                // unterminated expression (no closing brace before end of line)
+                [/\{(?![^\n]*\})/, "invalid", "@unterminatedCurly"],
                 // expressions
                 [/{/, "operator", "@curlyBracket"],
                 // enclosed comments
@@ -79,15 +99,30 @@ function generateMonarchLanguage(fdmMode) {
             expression: [
                 // variables
                 [/(global|param|var)\.[a-zA-Z_$][\w$]*/, "variable.name"],
-                // object model properties
-                [/\w+(\.\w+)*/, "variable"],
-                // consts and functions
+                // Member access after `]` or any other punctuator (e.g. `fans[1].max`): always a property name,
+                // not a function call - so it must win over the function rule below even if the member name
+                // happens to match a function identifier (`max`, `min`, ...).
+                [/(\.)([a-zA-Z_$][\w$]*)/, ["delimiter", "variable"]],
+                // consts and functions need to match before the generic identifier rule below, otherwise
+                // `cos` / `pi` / etc. get consumed as plain variables and never reach this check
+                // `support.function` is the TextMate scope used by VSCode's Dark+/Light+ themes for built-in
+                // function calls; Monaco's default themes have no rule for it, so our `registerDuetLanguages`
+                // theme overrides are unambiguously applied (yellow #DCDCAA dark / #795E26 light).
                 [/[a-z]\w*/, {
                         cases: {
                             "@consts": "constant",
-                            "@functions": "keyword"
+                            "@functions": "support.function",
+                            "@default": "variable"
                         }
                     }],
+                // object model properties with dotted paths (e.g. move.axes)
+                [/\w+(\.\w+)*/, "variable"],
+                // unterminated nested expressions
+                [/\{(?![^\n]*\})/, "invalid", "@unterminatedCurly"],
+                [/\[(?![^\n]*\])/, "invalid", "@unterminatedSquare"],
+                // unterminated nested expressions
+                [/\{(?![^\n]*\})/, "invalid", "@unterminatedCurly"],
+                [/\[(?![^\n]*\])/, "invalid", "@unterminatedSquare"],
                 // nested expressions
                 [/{/, "operator", "@curlyBracket"],
                 [/\[/, "operator", "@squareBracket"],
@@ -97,6 +132,7 @@ function generateMonarchLanguage(fdmMode) {
                 [/\d+/, "number"],
                 // strings and chars
                 [/"(.|\"\")*?"/, "string"],
+                [/"[^"\n]*/, "invalid"],
                 [/'.'/, "string"],
                 // operators
                 [/@symbols/, {
@@ -117,20 +153,33 @@ function generateMonarchLanguage(fdmMode) {
                 { include: "expression" }
             ],
             curlyBracket: [
+                // unterminated brace
+                [/\n/, "invalid", "@popall"],
                 // curly brackets contain expressions
                 { include: "expression" },
-                // terminate whern reaching a closing bracket
+                // terminate when reaching a closing bracket
                 [/}/, "operator", "@pop"],
             ],
             squareBracket: [
+                // unterminated bracket
+                [/\n/, "invalid", "@popall"],
                 // square brackets contain expressions
                 { include: "expression" },
-                // terminate whern reaching a closing bracket
+                // terminate when reaching a closing bracket
                 [/\]/, "operator", "@pop"],
             ],
+            unterminatedCurly: [
+                // color remainder of line as invalid, then pop
+                [/[^\n]+/, "invalid"],
+                [/\n/, "", "@popall"]
+            ],
+            unterminatedSquare: [
+                [/[^\n]+/, "invalid"],
+                [/\n/, "", "@popall"]
+            ],
             varName: [
-                // variable name
-                [/[a-zA-Z_$][\w$]*/, "variable.name", "@expression"],
+                // variable name being declared by `var` / `global` - render as a parameter so the name stands out from generic identifier colour
+                [/[a-zA-Z_$][\w$]*/, "variable.parameter", "@expression"],
                 // EOL
                 [/\n/, "", "@popall"]
             ]
@@ -139,3 +188,31 @@ function generateMonarchLanguage(fdmMode) {
 }
 exports.gcodeFDMLanguage = generateMonarchLanguage(true);
 exports.gcodeCNCLanguage = generateMonarchLanguage(false);
+exports.gcodeLanguageConfiguration = {
+    comments: {
+        lineComment: ";"
+    },
+    brackets: [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"]
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: "\"", close: "\"" }
+    ],
+    surroundingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: "\"", close: "\"" }
+    ],
+    // Python-style block indentation: pressing Enter after if/elif/else/while indents the next line one level deeper
+    indentationRules: {
+        increaseIndentPattern: /^\s*(if|elif|else|while)\b.*$/,
+        // `elif|else` dedent so they align with the matching `if`; `break|continue` end the surrounding while-block
+        decreaseIndentPattern: /^\s*(elif|else|break|continue)\b.*$/
+    }
+};

package/dist/monaco-menu.d.ts

@@ -0,0 +1,3 @@
+import type * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+export declare const menuLanguage: monaco.languages.IMonarchLanguage;
+export declare const menuLanguageConfiguration: monaco.languages.LanguageConfiguration;

package/dist/monaco-menu.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.menuLanguageConfiguration = exports.menuLanguage = void 0;
+exports.menuLanguage = {
+    keywords: ["image", "text", "button", "value", "alter", "files"],
+    symbols: /[=><!~?:&|+\-*#\/\^%]+/,
+    operators: ['*', '/', '+', '-', "==", "!=", '=', "<=", '<', ">=", ">>>", ">>", '>', '!', "&&", '&', "||", '|', '^', '?', ':'],
+    includeLF: true,
+    tokenizer: {
+        root: [
+            // keywords
+            [/[a-z_$][\w$]*/, {
+                    cases: {
+                        "@keywords": { token: "keyword" }
+                    }
+                }],
+            // numbers
+            [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+            [/0[xX][0-9a-fA-F]+/, "number.hex"],
+            [/\d+/, "number"],
+            // strings
+            [/"(.|\"\")*?"/, "string"],
+            // comments
+            [/;.*/, "comment"],
+            // parameter letters
+            [/'?[A-Z]/, "keyword"],
+            [/'[a-z]/, "keyword"]
+        ]
+    }
+};
+exports.menuLanguageConfiguration = {
+    comments: {
+        lineComment: ";"
+    }
+};

package/dist/monaco-stm32.d.ts

@@ -0,0 +1,3 @@
+import type * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+export declare const stm32Language: monaco.languages.IMonarchLanguage;
+export declare const stm32LanguageConfiguration: monaco.languages.LanguageConfiguration;

package/dist/monaco-stm32.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stm32LanguageConfiguration = exports.stm32Language = void 0;
+exports.stm32Language = {
+    keywordsPrimary: ["8266wifi", "accelerometer", "atx", "board", "heat", "lcd", "led", "leds", "pins", "power", "sbc", "sdCard", "serial", "SPI0", "SPI1", "SPI2", "SPI3", "SPI4", "SPI5", "SPI6", "SPI7", "SPI8", "stepper"],
+    keywordsSecondary: ["clockReg", "csPin", "espDataReadyPin", "espResetPin", "TfrReadyPin", "serialRxTxPins", "spiChannel", "initialPowerOn", "powerPin", "powerPinInverted", "spiTempSensorChannel", "spiTempSensorCSPins", "tempSensePins", "thermistorSeriesResistor", "encoderPinA", "encoderPinB", "encoderPinSw", "lcdBeepPin", "lcdCSPin", "lcdDCPin", "panelButtonPin", "neopixelPin", "activity", "activityOn", "diagnostic", "diagnosticOn", "SetHigh", "SetLow", "VInDetectPin", "voltage", "loadConfig", "external", "internal", "aux", "aux2", "pins", "directionPins", "enablePins", "numSmartDrivers", "num5160Drivers", "stepPins", "TmcDiagPins", "TmcUartPins"],
+    keywordsTertiary: ["cardDetectPin", "csPin", "spiChannel", "spiFrequencyHz", "spiFrequencyHz", "rxTxPins", "rxTxPins"],
+    symbols: /[=><!~?:&|+\-*#\/\^%]+/,
+    operators: ['*', '/', '+', '-', "==", "!=", '=', "<=", '<', ">=", ">>>", ">>", '>', '!', "&&", '&', "||", '|', '^', '?', ':'],
+    includeLF: true,
+    tokenizer: {
+        root: [
+            // keywords
+            [/[a-zA-Z0-9_$][\w$]*/, {
+                    cases: {
+                        "@keywordsPrimary": { token: "keyword" },
+                        "@keywordsSecondary": { token: "keyword" },
+                        "@keywordsTertiary": { token: "keyword" }
+                    }
+                }],
+            // comments
+            [/\/\/.*/, "comment"],
+            [/;.*/, "comment"],
+            // expressions
+            [/{/, "operator", "@curlyBracket"],
+            // expressions
+            [/=/, "operator", "@equals"],
+        ],
+        expression: [
+            // numbers
+            [/\d+/, "number"],
+            // Pin Numbers
+            [/[a-iA-I]\.\d+/, "string"],
+            [/[a-iA-I]\_\d+/, "string"],
+            [/[a-iA-I]\d+/, "string"],
+            [/P[a-iA-I]\.\d+/, "string"],
+            [/P[a-iA-I]\_\d+/, "string"],
+            [/P[a-iA-I]\d+/, "string"],
+            [/NoPin/, "string"],
+            // strings
+            [/"(.|\"\")*?"/, "string"],
+            [/[a-zA-Z0-9_$][\w$]*/, "string"],
+            // operators
+            [/@symbols/, {
+                    cases: {
+                        "@operators": "operator",
+                        "@default": ""
+                    }
+                }],
+            // comments
+            [/;.*/, "comment"],
+            // EOL
+            [/\n/, "", "@popall"],
+        ],
+        curlyBracket: [
+            // curly brackets contain expressions
+            { include: "expression" },
+            // terminate when reaching a closing bracket
+            [/}/, "operator", "@pop"],
+        ],
+        equals: [
+            // curly brackets contain expressions
+            { include: "expression" },
+            // EOL
+            [/\n/, "", "@popall"],
+        ]
+    }
+};
+exports.stm32LanguageConfiguration = {
+    comments: {
+        lineComment: ";"
+    },
+    brackets: [
+        ["{", "}"]
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "\"", close: "\"" }
+    ],
+    surroundingPairs: [
+        { open: "{", close: "}" },
+        { open: "\"", close: "\"" }
+    ]
+};

package/dist/objectmodel/deprecations.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Look up the deprecation message for a full object-model path (with literal numeric indices) or any of its
+ * prefixes. Returns the deprecation message when the path itself or a containing path is deprecated (the
+ * shallowest match wins so the user sees the root cause, e.g. `move.rotation.angle` reports `move.rotation`
+ * as deprecated). Returns null when neither the path nor any prefix is deprecated.
+ */
+export declare function getPathDeprecation(path: string): string | null;
+/**
+ * Look up the deprecation message for `parentPath + "." + field`. `parentPath` is the dotted path of the parent
+ * value from the root (e.g. `move.extruders[0]`), or empty for a top-level field. Returns null if not deprecated.
+ */
+export declare function getMemberDeprecation(parentPath: string, field: string): string | null;

package/dist/objectmodel/deprecations.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathDeprecation = getPathDeprecation;
+exports.getMemberDeprecation = getMemberDeprecation;
+const deprecations_json_1 = __importDefault(require("@duet3d/objectmodel/dist/deprecations.json"));
+const paths_1 = require("./paths");
+/**
+ * Map of full object-model paths (with `[]` standing for any array index) to the deprecation message extracted
+ * from the property's `@deprecated` JSDoc tag. Built by @duet3d/objectmodel's build script from its TS sources.
+ */
+const deprecations = deprecations_json_1.default;
+/**
+ * Look up the deprecation message for a full object-model path (with literal numeric indices) or any of its
+ * prefixes. Returns the deprecation message when the path itself or a containing path is deprecated (the
+ * shallowest match wins so the user sees the root cause, e.g. `move.rotation.angle` reports `move.rotation`
+ * as deprecated). Returns null when neither the path nor any prefix is deprecated.
+ */
+function getPathDeprecation(path) {
+    if (!path) {
+        return null;
+    }
+    const key = (0, paths_1.normalisePath)(path);
+    // Walk prefixes from shallowest to deepest; first hit wins
+    let cursor = 0;
+    while (cursor < key.length) {
+        // Advance to the next boundary (dot or closing bracket that ends a step)
+        let next = key.indexOf(".", cursor);
+        if (next < 0) {
+            next = key.length;
+        }
+        const prefix = key.substring(0, next);
+        if (Object.prototype.hasOwnProperty.call(deprecations, prefix)) {
+            return deprecations[prefix];
+        }
+        cursor = next + 1;
+    }
+    return null;
+}
+/**
+ * Look up the deprecation message for `parentPath + "." + field`. `parentPath` is the dotted path of the parent
+ * value from the root (e.g. `move.extruders[0]`), or empty for a top-level field. Returns null if not deprecated.
+ */
+function getMemberDeprecation(parentPath, field) {
+    const fullPath = parentPath ? `${parentPath}.${field}` : field;
+    return getPathDeprecation(fullPath);
+}

package/dist/objectmodel/enums.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Return the list of valid values for a given object-model path, or null if the path has no known enum values.
+ */
+export declare function getEnumValuesForPath(path: string): string[] | null;

package/dist/objectmodel/enums.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumValuesForPath = getEnumValuesForPath;
+const enums_json_1 = __importDefault(require("@duet3d/objectmodel/dist/enums.json"));
+const paths_1 = require("./paths");
+/**
+ * Map of full object-model paths (with `[]` standing for any array index) to the list of valid enum / string-
+ * literal values the field can take. Generated by @duet3d/objectmodel's build script from its TS sources.
+ */
+const enumValues = enums_json_1.default;
+/**
+ * Return the list of valid values for a given object-model path, or null if the path has no known enum values.
+ */
+function getEnumValuesForPath(path) {
+    if (!path) {
+        return null;
+    }
+    const key = (0, paths_1.normalisePath)(path);
+    return Object.prototype.hasOwnProperty.call(enumValues, key) ? enumValues[key] : null;
+}

package/dist/objectmodel/machine-context.d.ts

@@ -0,0 +1,33 @@
+import type { ObjectModel } from "@duet3d/objectmodel";
+/**
+ * Runtime context describing the currently connected machine. Completion and hover providers read this to surface
+ * machine-specific information (visible axes, configured extruders, object-model fields) alongside the static
+ * gcode/expression datasets bundled with this package.
+ *
+ * Framework-agnostic: Vue, React, or any other consumer just calls `setMachineContext` when its model reference
+ * becomes available or changes. The reference is expected to stay stable - providers read field values through
+ * the reference at completion time so state mutations inside the object model are picked up automatically.
+ */
+export interface MachineContext {
+    /** Live machine object-model reference. */
+    readonly model: ObjectModel;
+    /**
+     * Optional callback that returns a Markdown/HTML description for an object-model path (with `[]` placeholders
+     * for collection items, e.g. `move.extruders[].pressureAdvance`). Used by the hover provider to surface the
+     * DuetAPI.xml documentation. Return `null` when no description is available. May be async - the hover provider
+     * awaits the result so callbacks can lazily fetch the docs on first hover without losing the popup.
+     */
+    readonly getObjectModelDescription?: (path: string) => string | null | Promise<string | null>;
+}
+/**
+ * Set (or clear) the runtime machine context. Pass `null` when the machine is disconnected.
+ */
+export declare function setMachineContext(context: MachineContext | null): void;
+/**
+ * Get the currently installed machine context, or null when no machine is connected.
+ */
+export declare function getMachineContext(): MachineContext | null;
+/**
+ * Subscribe to machine-context changes. Returns an unsubscribe function.
+ */
+export declare function onMachineContextChange(listener: () => void): () => void;

package/dist/objectmodel/machine-context.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMachineContext = setMachineContext;
+exports.getMachineContext = getMachineContext;
+exports.onMachineContextChange = onMachineContextChange;
+let current = null;
+const listeners = new Set();
+/**
+ * Set (or clear) the runtime machine context. Pass `null` when the machine is disconnected.
+ */
+function setMachineContext(context) {
+    current = context;
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch (e) {
+            // Listener threw - don't let it break other listeners
+            console.error("[monacotokens] machine-context listener threw:", e);
+        }
+    }
+}
+/**
+ * Get the currently installed machine context, or null when no machine is connected.
+ */
+function getMachineContext() {
+    return current;
+}
+/**
+ * Subscribe to machine-context changes. Returns an unsubscribe function.
+ */
+function onMachineContextChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/objectmodel/paths.d.ts

@@ -0,0 +1,3 @@
+/** Normalise a runtime object-model path (with literal numeric indices) to the lookup form used by
+ * the deprecations / enums maps, where `[]` stands in for any array index. */
+export declare function normalisePath(path: string): string;

package/dist/objectmodel/paths.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalisePath = normalisePath;
+/** Normalise a runtime object-model path (with literal numeric indices) to the lookup form used by
+ * the deprecations / enums maps, where `[]` stands in for any array index. */
+function normalisePath(path) {
+    return path.replace(/\[\d+\]/g, "[]");
+}

package/dist/providers.d.ts

@@ -0,0 +1,55 @@
+import type * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+export { getMachineContext, onMachineContextChange } from "./objectmodel/machine-context";
+/**
+ * Flatten a machine object-model snapshot into a list of dotted paths (with `[0]` placeholders for arrays).
+ * Walks the entire reachable subtree; arrays contribute a single representative `[0]` entry so the list
+ * doesn't explode on machines with many tools/axes. Cycles are guarded via a visited WeakSet.
+ */
+export declare function flattenObjectModel(root: any): string[];
+/**
+ * Detect whether the cursor sits inside an RRF expression context:
+ *   - inside a balanced-but-still-open `{ ... }` span, OR
+ *   - after an `=` on a `set|var|global` line (whole line is expression territory), OR
+ *   - after `if|elif|while` (condition is an expression).
+ */
+export declare function isInsideExpression(beforeCursor: string): boolean;
+/**
+ * Find the closest G/M/T-code to the left of `column` on the given line.
+ * Returns the matched code (e.g. "G1") and the column where it starts, or null.
+ *
+ * A bare `T` is only treated as its own code when it's the first code on the line; otherwise it's a parameter
+ * letter of the preceding command (e.g. `M104 T1` - the T belongs to M104, not a separate `T` code).
+ */
+export declare function findCodeAtCursor(line: string, column: number): {
+    code: string;
+    startColumn: number;
+} | null;
+/**
+ * Register Duet-specific completion and hover providers for a language id.
+ */
+export declare function registerProvidersFor(monacoInstance: typeof monaco, languageId: string): monaco.IDisposable[];
+/**
+ * Register Duet completion and hover providers for both gcode-fdm and gcode-cnc languages.
+ */
+export declare function registerDuetProviders(monacoInstance: typeof monaco): monaco.IDisposable[];
+/**
+ * Attach a per-editor cursor-position watcher that closes the signature-help tooltip immediately when the cursor
+ * moves to a position where our provider would return null (between parameters, before the code, on a different line).
+ * Monaco only re-invokes the signature-help provider on content changes, so this bridges arrow-key / click movement.
+ * Call this once per editor right after `monaco.editor.create(...)`.
+ */
+export declare function attachGcodeSignatureHelpWatcher(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;
+/**
+ * Apply a strikethrough decoration (class `duet-deprecated-code`) to every occurrence of a deprecated G/M/T-code
+ * (e.g. `M557`) and to every deprecated parameter letter belonging to any G/M/T-code on that line (e.g. the `S` in
+ * `M84 S`). Re-runs on every content change; hover tooltip carries the deprecation reason.
+ * Call once per editor; the returned IDisposable removes the listener and clears the decorations.
+ */
+export declare function attachGcodeDeprecationDecorations(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;
+/**
+ * Strike-through deprecated object-model paths that appear in the editor. Matches dotted chains like
+ * `move.extruders[0].pressureAdvance`, normalises the bracket indices to `[]`, and highlights the chain if
+ * the normalised path is present in the deprecations map shipped by @duet3d/objectmodel. Re-runs on every
+ * content change; hover tooltip carries the deprecation reason.
+ */
+export declare function attachObjectModelDeprecationDecorations(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;