diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcCatalog.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcCatalog.cs
new file mode 100644
index 0000000..dfd970c
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcCatalog.cs
@@ -0,0 +1,554 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// Single source of truth for FileMaker calculation built-ins. The TextMate
+/// grammar (<c>fmcalc.tmLanguage.json</c>) is regenerated from this catalog
+/// by <c>SharpFM.Tools.GenerateGrammar</c>; the completion provider reads
+/// from the same lists at runtime. Edit here, regenerate grammar, both stay
+/// in sync.
+///
+/// Categorisation follows FileMaker's calculation dialog. Function lists
+/// are based on the public function reference at help.claris.com and may
+/// trail very recent FM releases; bumps are a one-line append.
+/// </summary>
+public static class FmCalcCatalog
+{
+    // Enum-value lists referenced from BuildFunctions(). Declared before
+    // Functions so they're initialised first — C# static field init runs
+    // in textual order, and BuildFunctions() reads these.
+    private static readonly IReadOnlyList<FmCalcEnumValue> GetSelectorKeywords = BuildGetSelectorKeywords();
+    private static readonly IReadOnlyList<FmCalcEnumValue> TextStyles = BuildTextStyles();
+    private static readonly IReadOnlyList<FmCalcEnumValue> HashAlgorithms = BuildHashAlgorithms();
+    private static readonly IReadOnlyList<FmCalcEnumValue> JsonElementTypes = BuildJsonElementTypes();
+
+    public static IReadOnlyList<FmCalcFunction> Functions { get; } = BuildFunctions();
+    public static IReadOnlyList<FmCalcControlForm> ControlForms { get; } = BuildControlForms();
+    public static IReadOnlyList<string> Constants { get; } = new ReadOnlyCollection<string>(
+        new[] { "True", "False", "Pi" });
+
+    /// <summary>Word operators that must scope as keyword.operator.word, not function names.</summary>
+    public static IReadOnlyList<string> WordOperators { get; } = new ReadOnlyCollection<string>(
+        new[] { "and", "or", "not", "xor" });
+
+    private static IReadOnlyList<FmCalcFunction> BuildFunctions()
+    {
+        var list = new List<FmCalcFunction>();
+
+        void Add(string n, FunctionCategory c, string sig, string desc,
+            params FmCalcFunctionParam[] ps)
+        {
+            // When the caller doesn't pass explicit Params, derive them
+            // from the signature string. Lets every function get tab-stop
+            // completion without hand-authoring a param list per entry.
+            IReadOnlyList<FmCalcFunctionParam> paramList = ps.Length > 0
+                ? ps
+                : FmCalcSignatureParser.ParseParams(sig);
+            list.Add(new FmCalcFunction(n, c, sig, desc, paramList));
+        }
+
+        // Text
+        Add("Char", FunctionCategory.Text, "Char(number)", "Returns the character for a Unicode code point.");
+        Add("Code", FunctionCategory.Text, "Code(text)", "Returns the Unicode code points for the characters in text.");
+        Add("Exact", FunctionCategory.Text, "Exact(originalText; comparisonText)", "Returns true if the two values match exactly.");
+        Add("Filter", FunctionCategory.Text, "Filter(textToFilter; filterText)", "Returns characters from textToFilter that also appear in filterText.");
+        Add("FilterValues", FunctionCategory.Text, "FilterValues(textToFilter; filterValues)", "Returns values from textToFilter that match a value list.");
+        Add("GetAsCSS", FunctionCategory.Text, "GetAsCSS(text)", "Returns text marked up with CSS style attributes.");
+        Add("GetAsDate", FunctionCategory.Text, "GetAsDate(text)", "Converts text to a date.");
+        Add("GetAsNumber", FunctionCategory.Text, "GetAsNumber(text)", "Returns only the numeric characters from text.");
+        Add("GetAsSVG", FunctionCategory.Text, "GetAsSVG(text)", "Returns text marked up as SVG.");
+        Add("GetAsText", FunctionCategory.Text, "GetAsText(data)", "Converts a value to text.");
+        Add("GetAsTime", FunctionCategory.Text, "GetAsTime(text)", "Converts text to a time.");
+        Add("GetAsTimestamp", FunctionCategory.Text, "GetAsTimestamp(text)", "Converts text to a timestamp.");
+        Add("GetAsURLEncoded", FunctionCategory.Text, "GetAsURLEncoded(text)", "Returns the URL-encoded form of text.");
+        Add("Hiragana", FunctionCategory.Text, "Hiragana(text)", "Converts katakana to hiragana.");
+        Add("KanaHankaku", FunctionCategory.Text, "KanaHankaku(text)", "Converts full-width katakana to half-width.");
+        Add("KanaZenkaku", FunctionCategory.Text, "KanaZenkaku(text)", "Converts half-width katakana to full-width.");
+        Add("KanjiNumeral", FunctionCategory.Text, "KanjiNumeral(text)", "Converts Arabic numerals to kanji.");
+        Add("KatakanaToRoman", FunctionCategory.Text, "KatakanaToRoman(text)", "Converts katakana to roman characters.");
+        Add("Left", FunctionCategory.Text, "Left(text; numberOfCharacters)", "Returns the leftmost characters of text.");
+        Add("LeftValues", FunctionCategory.Text, "LeftValues(text; numberOfValues)", "Returns the leftmost values from a return-delimited list.");
+        Add("LeftWords", FunctionCategory.Text, "LeftWords(text; numberOfWords)", "Returns the leftmost words from text.");
+        Add("Length", FunctionCategory.Text, "Length(text)", "Returns the number of characters in text.");
+        Add("Lower", FunctionCategory.Text, "Lower(text)", "Returns text in lowercase.");
+        Add("Middle", FunctionCategory.Text, "Middle(text; start; numberOfCharacters)", "Returns characters from text starting at start.");
+        Add("MiddleValues", FunctionCategory.Text, "MiddleValues(text; startingValue; numberOfValues)", "Returns values from a list starting at startingValue.");
+        Add("MiddleWords", FunctionCategory.Text, "MiddleWords(text; startingWord; numberOfWords)", "Returns words from text starting at startingWord.");
+        Add("NumToJText", FunctionCategory.Text, "NumToJText(number; separator; characterType)", "Converts Arabic numerals to Japanese text.");
+        Add("PatternCount", FunctionCategory.Text, "PatternCount(text; searchString)", "Returns how many times searchString appears in text.");
+        Add("Position", FunctionCategory.Text, "Position(text; searchString; start; occurrence)", "Returns the starting position of searchString in text.");
+        Add("Proper", FunctionCategory.Text, "Proper(text)", "Returns text with the first letter of each word capitalized.");
+        Add("Quote", FunctionCategory.Text, "Quote(text)", "Returns text wrapped in quotes with internal quotes escaped.");
+        Add("Replace", FunctionCategory.Text, "Replace(text; start; numberOfCharacters; replacementText)", "Replaces a range of characters in text.");
+        Add("Right", FunctionCategory.Text, "Right(text; numberOfCharacters)", "Returns the rightmost characters of text.");
+        Add("RightValues", FunctionCategory.Text, "RightValues(text; numberOfValues)", "Returns the rightmost values from a return-delimited list.");
+        Add("RightWords", FunctionCategory.Text, "RightWords(text; numberOfWords)", "Returns the rightmost words from text.");
+        Add("RomanHankaku", FunctionCategory.Text, "RomanHankaku(text)", "Converts full-width roman to half-width.");
+        Add("RomanZenkaku", FunctionCategory.Text, "RomanZenkaku(text)", "Converts half-width roman to full-width.");
+        Add("SerialIncrement", FunctionCategory.Text, "SerialIncrement(text; incrementBy)", "Returns text with its trailing digits incremented.");
+        Add("SortValues", FunctionCategory.Text, "SortValues(values; dataType; locale)", "Returns a sorted list of values.");
+        Add("Substitute", FunctionCategory.Text, "Substitute(text; searchString; replaceString)", "Replaces every occurrence of searchString in text.");
+        Add("Trim", FunctionCategory.Text, "Trim(text)", "Removes leading and trailing spaces from text.");
+        Add("TrimAll", FunctionCategory.Text, "TrimAll(text; trimSpaces; trimType)", "Removes spaces with finer control than Trim.");
+        Add("UniqueValues", FunctionCategory.Text, "UniqueValues(values; fieldType; locale)", "Returns the unique values from a list.");
+        Add("Upper", FunctionCategory.Text, "Upper(text)", "Returns text in uppercase.");
+        Add("ValueCount", FunctionCategory.Text, "ValueCount(text)", "Returns the number of values in a return-delimited list.");
+        Add("VerifyID", FunctionCategory.Text, "VerifyID(id)", "Returns whether an ID has a valid checksum.");
+        Add("WordCount", FunctionCategory.Text, "WordCount(text)", "Returns the number of words in text.");
+
+        // Text formatting
+        Add("RGB", FunctionCategory.TextFormatting, "RGB(red; green; blue)", "Returns a numeric color value.");
+        Add("TextColor", FunctionCategory.TextFormatting, "TextColor(text; rgb)", "Returns text with the given color applied.");
+        Add("TextColorRemove", FunctionCategory.TextFormatting, "TextColorRemove(text; rgb)", "Removes color from text.");
+        Add("TextFont", FunctionCategory.TextFormatting, "TextFont(text; fontName; fontScript)", "Returns text with the given font applied.");
+        Add("TextFontRemove", FunctionCategory.TextFormatting, "TextFontRemove(text; fontName; fontScript)", "Removes font from text.");
+        Add("TextFormatRemove", FunctionCategory.TextFormatting, "TextFormatRemove(text)", "Removes all formatting from text.");
+        Add("TextSize", FunctionCategory.TextFormatting, "TextSize(text; size)", "Returns text at the given size.");
+        Add("TextSizeRemove", FunctionCategory.TextFormatting, "TextSizeRemove(text; size)", "Removes size from text.");
+        Add("TextStyleAdd", FunctionCategory.TextFormatting, "TextStyleAdd(text; style)",
+            "Returns text with the given style applied.",
+            new FmCalcFunctionParam("text"),
+            new FmCalcFunctionParam("style", "Style flag", TextStyles));
+        Add("TextStyleRemove", FunctionCategory.TextFormatting, "TextStyleRemove(text; style)",
+            "Removes style from text.",
+            new FmCalcFunctionParam("text"),
+            new FmCalcFunctionParam("style", "Style flag", TextStyles));
+
+        // Number
+        Add("Abs", FunctionCategory.Number, "Abs(number)", "Returns the absolute value of number.");
+        Add("Ceiling", FunctionCategory.Number, "Ceiling(number)", "Rounds number up to the next integer.");
+        Add("Combination", FunctionCategory.Number, "Combination(setSize; numberOfChoices)", "Returns the number of combinations.");
+        Add("Div", FunctionCategory.Number, "Div(number; divisor)", "Returns the integer part of number divided by divisor.");
+        Add("Exp", FunctionCategory.Number, "Exp(number)", "Returns e raised to the power of number.");
+        Add("Factorial", FunctionCategory.Number, "Factorial(number; numberOfFactors)", "Returns the factorial of number.");
+        Add("Floor", FunctionCategory.Number, "Floor(number)", "Rounds number down to the previous integer.");
+        Add("Int", FunctionCategory.Number, "Int(number)", "Returns the integer part of number.");
+        Add("Lg", FunctionCategory.Number, "Lg(number)", "Returns the base-2 logarithm of number.");
+        Add("Ln", FunctionCategory.Number, "Ln(number)", "Returns the natural logarithm of number.");
+        Add("Log", FunctionCategory.Number, "Log(number)", "Returns the base-10 logarithm of number.");
+        Add("Mod", FunctionCategory.Number, "Mod(number; divisor)", "Returns the remainder of number divided by divisor.");
+        Add("Random", FunctionCategory.Number, "Random", "Returns a random number between 0 and 1.");
+        Add("Round", FunctionCategory.Number, "Round(number; precision)", "Rounds number to precision decimal places.");
+        Add("SetPrecision", FunctionCategory.Number, "SetPrecision(expression; precision)", "Returns expression evaluated with extended precision.");
+        Add("Sign", FunctionCategory.Number, "Sign(number)", "Returns -1, 0, or 1 depending on the sign of number.");
+        Add("Sqrt", FunctionCategory.Number, "Sqrt(number)", "Returns the square root of number.");
+        Add("Truncate", FunctionCategory.Number, "Truncate(number; precision)", "Truncates number to precision decimal places.");
+
+        // Date
+        Add("Date", FunctionCategory.Date, "Date(month; day; year)", "Returns a date value.");
+        Add("Day", FunctionCategory.Date, "Day(date)", "Returns the day of the month from date.");
+        Add("DayName", FunctionCategory.Date, "DayName(date)", "Returns the weekday name for date.");
+        Add("DayNameJ", FunctionCategory.Date, "DayNameJ(date)", "Returns the Japanese weekday name for date.");
+        Add("DayOfWeek", FunctionCategory.Date, "DayOfWeek(date)", "Returns the day of the week (1-7) for date.");
+        Add("DayOfYear", FunctionCategory.Date, "DayOfYear(date)", "Returns the day of the year (1-366) for date.");
+        Add("Month", FunctionCategory.Date, "Month(date)", "Returns the month number for date.");
+        Add("MonthName", FunctionCategory.Date, "MonthName(date)", "Returns the month name for date.");
+        Add("MonthNameJ", FunctionCategory.Date, "MonthNameJ(date)", "Returns the Japanese month name for date.");
+        Add("WeekOfYear", FunctionCategory.Date, "WeekOfYear(date)", "Returns the week number of the year for date.");
+        Add("WeekOfYearFiscal", FunctionCategory.Date, "WeekOfYearFiscal(date; startingDay)", "Returns the fiscal week of year for date.");
+        Add("Year", FunctionCategory.Date, "Year(date)", "Returns the year for date.");
+        Add("YearName", FunctionCategory.Date, "YearName(date; format)", "Returns the Japanese era year name for date.");
+
+        // Time
+        Add("Hour", FunctionCategory.Time, "Hour(time)", "Returns the hour for time.");
+        Add("Minute", FunctionCategory.Time, "Minute(time)", "Returns the minute for time.");
+        Add("Seconds", FunctionCategory.Time, "Seconds(time)", "Returns the seconds for time.");
+        Add("Time", FunctionCategory.Time, "Time(hours; minutes; seconds)", "Returns a time value.");
+        Add("Timestamp", FunctionCategory.Time, "Timestamp(date; time)", "Returns a timestamp value.");
+
+        // Aggregate
+        Add("Average", FunctionCategory.Aggregate, "Average(field {; field...})", "Returns the average of non-blank values.");
+        Add("Count", FunctionCategory.Aggregate, "Count(field {; field...})", "Returns the count of non-blank values.");
+        Add("List", FunctionCategory.Aggregate, "List(field {; field...})", "Returns a return-delimited list of non-blank values.");
+        Add("Max", FunctionCategory.Aggregate, "Max(field {; field...})", "Returns the maximum of non-blank values.");
+        Add("Min", FunctionCategory.Aggregate, "Min(field {; field...})", "Returns the minimum of non-blank values.");
+        Add("StDev", FunctionCategory.Aggregate, "StDev(field {; field...})", "Returns the sample standard deviation.");
+        Add("StDevP", FunctionCategory.Aggregate, "StDevP(field {; field...})", "Returns the population standard deviation.");
+        Add("Sum", FunctionCategory.Aggregate, "Sum(field {; field...})", "Returns the sum of non-blank values.");
+        Add("Variance", FunctionCategory.Aggregate, "Variance(field {; field...})", "Returns the sample variance.");
+        Add("VarianceP", FunctionCategory.Aggregate, "VarianceP(field {; field...})", "Returns the population variance.");
+
+        // Summary / repeating
+        Add("GetSummary", FunctionCategory.Summary, "GetSummary(summaryField; breakField)", "Returns a summary value broken on breakField.");
+        Add("GetNthRecord", FunctionCategory.Summary, "GetNthRecord(field; recordNumber)", "Returns field's value from the Nth record.");
+        Add("Last", FunctionCategory.Summary, "Last(field)", "Returns the last non-blank value in a related set.");
+        Add("GetRepetition", FunctionCategory.Summary, "GetRepetition(repeatingField; number)", "Returns the Nth repetition of a repeating field.");
+        Add("Extend", FunctionCategory.Summary, "Extend(nonRepeatingField)", "Allows a non-repeating field to apply to all repetitions.");
+
+        // Financial
+        Add("FV", FunctionCategory.Financial, "FV(payment; interestRate; periods)", "Returns future value.");
+        Add("NPV", FunctionCategory.Financial, "NPV(payment; interestRate)", "Returns net present value.");
+        Add("PMT", FunctionCategory.Financial, "PMT(principal; interestRate; term)", "Returns payment amount.");
+        Add("PV", FunctionCategory.Financial, "PV(payment; interestRate; periods)", "Returns present value.");
+
+        // Trigonometric
+        Add("Acos", FunctionCategory.Trigonometric, "Acos(number)", "Returns the arc cosine of number.");
+        Add("Asin", FunctionCategory.Trigonometric, "Asin(number)", "Returns the arc sine of number.");
+        Add("Atan", FunctionCategory.Trigonometric, "Atan(number)", "Returns the arc tangent of number.");
+        Add("Cos", FunctionCategory.Trigonometric, "Cos(angleInRadians)", "Returns the cosine of angle.");
+        Add("Degrees", FunctionCategory.Trigonometric, "Degrees(angleInRadians)", "Converts radians to degrees.");
+        Add("Radians", FunctionCategory.Trigonometric, "Radians(angleInDegrees)", "Converts degrees to radians.");
+        Add("Sin", FunctionCategory.Trigonometric, "Sin(angleInRadians)", "Returns the sine of angle.");
+        Add("Tan", FunctionCategory.Trigonometric, "Tan(angleInRadians)", "Returns the tangent of angle.");
+
+        // Logical
+        Add("Evaluate", FunctionCategory.Logical, "Evaluate(expression {; [fields]})", "Evaluates an expression provided as text.");
+        Add("EvaluationError", FunctionCategory.Logical, "EvaluationError(expression)", "Returns the error number from an evaluation.");
+        Add("GetAsBoolean", FunctionCategory.Logical, "GetAsBoolean(data)", "Returns 0 if data is empty/zero, otherwise 1.");
+        Add("GetField", FunctionCategory.Logical, "GetField(fieldName)", "Returns the value of the field whose name is fieldName.");
+        Add("GetFieldName", FunctionCategory.Logical, "GetFieldName(field)", "Returns the fully qualified name of field.");
+        Add("IsEmpty", FunctionCategory.Logical, "IsEmpty(expression)", "Returns true if expression is empty.");
+        Add("IsValid", FunctionCategory.Logical, "IsValid(field)", "Returns true if field is valid and references a real field.");
+        Add("IsValidExpression", FunctionCategory.Logical, "IsValidExpression(expression)", "Returns true if expression is syntactically valid.");
+        Add("Lookup", FunctionCategory.Logical, "Lookup(sourceField {; failExpression})", "Returns a looked-up value through a relationship.");
+        Add("LookupNext", FunctionCategory.Logical, "LookupNext(sourceField; lower-/higher-flag)", "Returns the next looked-up value.");
+        Add("Self", FunctionCategory.Logical, "Self", "Refers to the object whose property is being evaluated.");
+        Add("SetField", FunctionCategory.Logical, "SetField(fieldName; value)", "Sets the field whose name is fieldName.");
+
+        // Get
+        Add("Get", FunctionCategory.Get, "Get(parameter)",
+            "Returns information about the FileMaker environment.",
+            new FmCalcFunctionParam("parameter", "Selector keyword", GetSelectorKeywords));
+
+        // Container
+        Add("Base64Decode", FunctionCategory.Container, "Base64Decode(text {; fileNameWithExtension})", "Decodes base64 to container or text.");
+        Add("Base64Encode", FunctionCategory.Container, "Base64Encode(data)", "Encodes data as base64.");
+        Add("Base64EncodeRFC", FunctionCategory.Container, "Base64EncodeRFC(rfcNumber; data)", "Encodes data as base64 per the given RFC.");
+        Add("CryptAuthCode", FunctionCategory.Container, "CryptAuthCode(data; algorithm; key)", "Returns an HMAC authentication code.");
+        Add("CryptDecrypt", FunctionCategory.Container, "CryptDecrypt(data; key)", "Decrypts data with key.");
+        Add("CryptDecryptBase64", FunctionCategory.Container, "CryptDecryptBase64(text; key)", "Decrypts base64-encoded data with key.");
+        Add("CryptDigest", FunctionCategory.Container, "CryptDigest(data; algorithm)",
+            "Returns a cryptographic digest of data.",
+            new FmCalcFunctionParam("data"),
+            new FmCalcFunctionParam("algorithm", "Hash algorithm", HashAlgorithms));
+        Add("CryptEncrypt", FunctionCategory.Container, "CryptEncrypt(data; key)", "Encrypts data with key.");
+        Add("CryptEncryptBase64", FunctionCategory.Container, "CryptEncryptBase64(data; key)", "Encrypts data with key and returns base64.");
+        Add("CryptGenerateSignature", FunctionCategory.Container, "CryptGenerateSignature(data; algorithm; privateRSAKey; password)", "Generates an RSA signature.");
+        Add("CryptVerifySignature", FunctionCategory.Container, "CryptVerifySignature(data; algorithm; publicRSAKey; signature)", "Verifies an RSA signature.");
+        Add("GetContainerAttribute", FunctionCategory.Container, "GetContainerAttribute(field; attribute)", "Returns metadata about a container value.");
+        Add("GetHeight", FunctionCategory.Container, "GetHeight(field)", "Returns the height of an image container.");
+        Add("GetThumbnail", FunctionCategory.Container, "GetThumbnail(field; fitToWidth; fitToHeight)", "Returns a thumbnail of a container.");
+        Add("GetWidth", FunctionCategory.Container, "GetWidth(field)", "Returns the width of an image container.");
+        Add("HexDecode", FunctionCategory.Container, "HexDecode(text {; fileNameWithExtension})", "Decodes hex to container or text.");
+        Add("HexEncode", FunctionCategory.Container, "HexEncode(data)", "Encodes data as hex.");
+        Add("VerifyContainer", FunctionCategory.Container, "VerifyContainer(field)", "Returns whether a container's checksum verifies.");
+
+        // JSON
+        Add("JSONDeleteElement", FunctionCategory.Json, "JSONDeleteElement(json; keyOrIndexOrPath)", "Deletes an element at the given path.");
+        Add("JSONFormatElements", FunctionCategory.Json, "JSONFormatElements(json)", "Returns json formatted with indentation.");
+        Add("JSONGetElement", FunctionCategory.Json, "JSONGetElement(json; keyOrIndexOrPath)", "Returns an element at the given path.");
+        Add("JSONListKeys", FunctionCategory.Json, "JSONListKeys(json; keyOrIndexOrPath)", "Returns the keys of an object element.");
+        Add("JSONListValues", FunctionCategory.Json, "JSONListValues(json; keyOrIndexOrPath)", "Returns the values of an object/array element.");
+        Add("JSONSetElement", FunctionCategory.Json, "JSONSetElement(json; keyOrIndexOrPath; value; type)",
+            "Sets an element at the given path.",
+            new FmCalcFunctionParam("json"),
+            new FmCalcFunctionParam("keyOrIndexOrPath"),
+            new FmCalcFunctionParam("value"),
+            new FmCalcFunctionParam("type", "JSON value type", JsonElementTypes));
+
+        // SQL
+        Add("ExecuteSQL", FunctionCategory.Sql, "ExecuteSQL(sql; fieldSeparator; rowSeparator {; arguments...})", "Executes an SQL query against the open database.");
+
+        // External
+        Add("GetSensor", FunctionCategory.External, "GetSensor(sensorType {; options})", "Returns a value from a device sensor (FileMaker Go).");
+        Add("GetLiveRemoteCallResult", FunctionCategory.External, "GetLiveRemoteCallResult(callID)", "Returns the result of a live remote call.");
+        Add("GetLiveRemoteCallStatus", FunctionCategory.External, "GetLiveRemoteCallStatus(callID)", "Returns the status of a live remote call.");
+
+        // Design
+        Add("DatabaseNames", FunctionCategory.Design, "DatabaseNames", "Returns names of open databases.");
+        Add("FieldBounds", FunctionCategory.Design, "FieldBounds(fileName; layoutName; fieldName)", "Returns layout coordinates of a field.");
+        Add("FieldComment", FunctionCategory.Design, "FieldComment(fileName; fieldName)", "Returns the comment for a field.");
+        Add("FieldIDs", FunctionCategory.Design, "FieldIDs(fileName; layoutName)", "Returns field IDs.");
+        Add("FieldNames", FunctionCategory.Design, "FieldNames(fileName; layoutName)", "Returns field names.");
+        Add("FieldRepetitions", FunctionCategory.Design, "FieldRepetitions(fileName; layoutName; fieldName)", "Returns repetitions for a field.");
+        Add("FieldStyle", FunctionCategory.Design, "FieldStyle(fileName; layoutName; fieldName)", "Returns the style applied to a field.");
+        Add("FieldType", FunctionCategory.Design, "FieldType(fileName; fieldName)", "Returns the type of a field.");
+        Add("GetNextSerialValue", FunctionCategory.Design, "GetNextSerialValue(fileName; fieldName)", "Returns the next auto-enter serial value.");
+        Add("LayoutIDs", FunctionCategory.Design, "LayoutIDs(fileName)", "Returns layout IDs.");
+        Add("LayoutNames", FunctionCategory.Design, "LayoutNames(fileName)", "Returns layout names.");
+        Add("LayoutObjectNames", FunctionCategory.Design, "LayoutObjectNames(fileName; layoutName)", "Returns named objects on a layout.");
+        Add("RelationInfo", FunctionCategory.Design, "RelationInfo(fileName; tableOccurrenceName)", "Returns information about relationships.");
+        Add("ScriptIDs", FunctionCategory.Design, "ScriptIDs(fileName)", "Returns script IDs.");
+        Add("ScriptNames", FunctionCategory.Design, "ScriptNames(fileName)", "Returns script names.");
+        Add("TableIDs", FunctionCategory.Design, "TableIDs(fileName)", "Returns table occurrence IDs.");
+        Add("TableNames", FunctionCategory.Design, "TableNames(fileName)", "Returns table occurrence names.");
+        Add("ValueListIDs", FunctionCategory.Design, "ValueListIDs(fileName)", "Returns value list IDs.");
+        Add("ValueListItems", FunctionCategory.Design, "ValueListItems(fileName; valueListName)", "Returns the items of a value list.");
+        Add("ValueListNames", FunctionCategory.Design, "ValueListNames(fileName)", "Returns value list names.");
+        Add("WindowNames", FunctionCategory.Design, "WindowNames({fileName})", "Returns names of open windows.");
+
+        return new ReadOnlyCollection<FmCalcFunction>(list);
+    }
+
+    private static IReadOnlyList<FmCalcControlForm> BuildControlForms()
+    {
+        return new ReadOnlyCollection<FmCalcControlForm>(new[]
+        {
+            new FmCalcControlForm(
+                "Let",
+                "Let([var = expr; ...]; result)",
+                "Binds variables and evaluates result with them in scope.",
+                "Let ( [ ${1:var} = ${2:value} ] ; ${3:result} )"),
+            new FmCalcControlForm(
+                "Case",
+                "Case(test1; result1 {; test2; result2 ...} {; defaultResult})",
+                "Returns result for the first true test; otherwise default.",
+                "Case ( ${1:test} ; ${2:result} ; ${3:default} )"),
+            new FmCalcControlForm(
+                "If",
+                "If(test; resultIfTrue; resultIfFalse)",
+                "Branches between two results based on test.",
+                "If ( ${1:test} ; ${2:trueResult} ; ${3:falseResult} )"),
+            new FmCalcControlForm(
+                "While",
+                "While([initialVars]; condition; [updateVars]; result)",
+                "Iterates while condition is true and returns result.",
+                "While ( [ ${1:counter} = 0 ] ; ${2:condition} ; [ ${3:counter} = counter + 1 ] ; ${4:result} )"),
+            new FmCalcControlForm(
+                "Choose",
+                "Choose(test; result0 {; result1 ...})",
+                "Returns the Nth result based on test (0-indexed).",
+                "Choose ( ${1:test} ; ${2:result0} ; ${3:result1} )"),
+        });
+    }
+
+    /// <summary>
+    /// JSON value-type keywords accepted by <c>JSONSetElement</c>'s last argument.
+    /// </summary>
+    private static IReadOnlyList<FmCalcEnumValue> BuildJsonElementTypes() => new ReadOnlyCollection<FmCalcEnumValue>(new[]
+    {
+        new FmCalcEnumValue("JSONString",  "Quoted string."),
+        new FmCalcEnumValue("JSONNumber",  "Numeric value."),
+        new FmCalcEnumValue("JSONObject",  "Object literal."),
+        new FmCalcEnumValue("JSONArray",   "Array literal."),
+        new FmCalcEnumValue("JSONBoolean", "true or false."),
+        new FmCalcEnumValue("JSONNull",    "Null literal."),
+        new FmCalcEnumValue("JSONRaw",     "Raw, unquoted JSON fragment."),
+    });
+
+    /// <summary>
+    /// Style keywords accepted by <c>TextStyleAdd</c> / <c>TextStyleRemove</c>.
+    /// </summary>
+    private static IReadOnlyList<FmCalcEnumValue> BuildTextStyles() => new ReadOnlyCollection<FmCalcEnumValue>(new[]
+    {
+        new FmCalcEnumValue("Plain"),
+        new FmCalcEnumValue("Bold"),
+        new FmCalcEnumValue("Italic"),
+        new FmCalcEnumValue("Underline"),
+        new FmCalcEnumValue("Condense"),
+        new FmCalcEnumValue("Extend"),
+        new FmCalcEnumValue("Strikethrough"),
+        new FmCalcEnumValue("SmallCaps"),
+        new FmCalcEnumValue("Superscript"),
+        new FmCalcEnumValue("Subscript"),
+        new FmCalcEnumValue("Uppercase"),
+        new FmCalcEnumValue("Lowercase"),
+        new FmCalcEnumValue("Titlecase"),
+        new FmCalcEnumValue("WordUnderline"),
+        new FmCalcEnumValue("DoubleUnderline"),
+        new FmCalcEnumValue("AllStyles"),
+    });
+
+    /// <summary>
+    /// Hash algorithm keywords accepted by <c>CryptDigest</c>.
+    /// </summary>
+    private static IReadOnlyList<FmCalcEnumValue> BuildHashAlgorithms() => new ReadOnlyCollection<FmCalcEnumValue>(new[]
+    {
+        new FmCalcEnumValue("MD5"),
+        new FmCalcEnumValue("SHA1"),
+        new FmCalcEnumValue("SHA256"),
+        new FmCalcEnumValue("SHA512"),
+        new FmCalcEnumValue("SHA224"),
+        new FmCalcEnumValue("SHA384"),
+    });
+
+    /// <summary>
+    /// Selector keywords accepted by <c>Get(...)</c>. Common subset from
+    /// FileMaker's Get function reference; rare/edge keywords can be appended
+    /// without further wiring.
+    /// </summary>
+    private static IReadOnlyList<FmCalcEnumValue> BuildGetSelectorKeywords()
+    {
+        var list = new List<FmCalcEnumValue>();
+        void Add(string n, string d) => list.Add(new FmCalcEnumValue(n, d));
+
+        // Account / privileges
+        Add("AccountName", "Name of the account used to log in.");
+        Add("AccountPrivilegeSetName", "Privilege set name for the current account.");
+        Add("AccountExtendedPrivileges", "Extended privileges for the current account.");
+        Add("AccountGroupName", "Group name of the current externally authenticated account.");
+
+        // Active selection / field
+        Add("ActiveFieldName", "Name of the field with focus.");
+        Add("ActiveFieldContents", "Contents of the field with focus.");
+        Add("ActiveFieldTableName", "Table occurrence of the field with focus.");
+        Add("ActiveLayoutObjectName", "Object name of the layout object with focus.");
+        Add("ActiveModifierKeys", "Bitmask of modifier keys currently held.");
+        Add("ActivePortalRowNumber", "Row number of the active portal.");
+        Add("ActiveRecordNumber", "Record number of the active record in the found set.");
+        Add("ActiveRepetitionNumber", "Active repetition of a repeating field.");
+        Add("ActiveSelectionSize", "Size of the current text selection.");
+        Add("ActiveSelectionStart", "Start position of the current text selection.");
+
+        // App
+        Add("ApplicationArchitecture", "Architecture of the running FileMaker (x86_64, arm64, etc.).");
+        Add("ApplicationLanguage", "Language of the running FileMaker.");
+        Add("ApplicationVersion", "Version string of the running FileMaker.");
+
+        // Calculation / scripting
+        Add("CalculationRepetitionNumber", "Current repetition during calculation evaluation.");
+        Add("ScriptName", "Name of the currently running script.");
+        Add("ScriptParameter", "Parameter passed to the running script.");
+        Add("ScriptResult", "Result returned by the most recently completed sub-script.");
+        Add("ScriptAnimationState", "Whether script animations are currently allowed.");
+
+        // Connection
+        Add("ConnectionAttributes", "Attributes of the current network connection.");
+        Add("ConnectionState", "Encrypted/unencrypted state of the current connection.");
+
+        // Date / time
+        Add("CurrentDate", "Current date.");
+        Add("CurrentTime", "Current time.");
+        Add("CurrentTimestamp", "Current timestamp.");
+        Add("CurrentHostTimestamp", "Current timestamp from the host (sync-safe).");
+        Add("CurrentTimeUTCMilliseconds", "Current UTC time in milliseconds.");
+        Add("CurrentExtendedPrivileges", "Extended privileges for the current session.");
+        Add("CurrentPrivilegeSetName", "Privilege set name in effect for the current session.");
+
+        // Custom menus
+        Add("CustomMenuSetName", "Name of the active custom menu set.");
+
+        // Device / paths
+        Add("Device", "Type of the device running FileMaker.");
+        Add("DocumentsPath", "Path to the user's Documents folder.");
+        Add("DocumentsPathListing", "Listing of files in the Documents folder.");
+        Add("DesktopPath", "Path to the user's Desktop folder.");
+        Add("FileMakerPath", "Path to the running FileMaker application.");
+        Add("PreferencesPath", "Path to the FileMaker preferences folder.");
+        Add("TemporaryPath", "Path to a temporary folder unique to this session.");
+
+        // Encryption
+        Add("EncryptionState", "Encryption state of the current file.");
+
+        // Errors
+        Add("LastError", "Most recent script-step error number.");
+        Add("LastErrorDetail", "Detail string for the most recent error.");
+        Add("LastErrorLocation", "File/script/line of the most recent error.");
+        Add("LastExternalErrorDetail", "Detail from the most recent external error.");
+        Add("LastODBCError", "Most recent ODBC error.");
+        Add("LastMessageChoice", "User's choice from the most recent Show Custom Dialog.");
+        Add("ErrorCaptureState", "Whether error capture is enabled.");
+
+        // File
+        Add("FileName", "Name of the current file.");
+        Add("FilePath", "Full path to the current file.");
+        Add("FileSize", "Size of the current file in bytes.");
+        Add("FileLocaleName", "Locale name for the current file.");
+        Add("FileLocaleElements", "Locale elements for the current file.");
+
+        // Found set / records
+        Add("FoundCount", "Number of records in the current found set.");
+        Add("ModifiedCount", "Number of modified records in the current found set.");
+        Add("RecordID", "Internal record ID of the current record.");
+        Add("RecordNumber", "Record number of the current record.");
+        Add("RecordOpenCount", "Number of open records.");
+        Add("RecordOpenState", "Open state of the current record (0/1/2).");
+        Add("RecordModificationCount", "Number of times the current record has been modified.");
+        Add("RecordAccess", "Access privilege for the current record.");
+        Add("RequestCount", "Number of find requests in the current found set.");
+        Add("RequestOmitState", "Whether the current find request has the omit flag set.");
+        Add("TotalRecordCount", "Total record count for the current table.");
+
+        // Host / network
+        Add("HostApplicationVersion", "Version of the host FileMaker application.");
+        Add("HostIPAddress", "IP address of the host.");
+        Add("HostName", "Name of the host.");
+        Add("MultiUserState", "Multi-user (network sharing) state.");
+        Add("NetworkProtocol", "Network protocol in use.");
+        Add("NetworkType", "Type of network connection.");
+
+        // Layouts
+        Add("LayoutAccess", "Access privilege for the current layout.");
+        Add("LayoutCount", "Number of layouts in the file.");
+        Add("LayoutName", "Name of the current layout.");
+        Add("LayoutNumber", "Number of the current layout.");
+        Add("LayoutTableName", "Table occurrence of the current layout.");
+        Add("LayoutViewState", "Current view state (form/list/table).");
+
+        // Plugins
+        Add("InstalledFMPlugins", "List of installed FileMaker plugins.");
+
+        // Quick find
+        Add("QuickFindText", "Most recent quick find text.");
+
+        // Screen / printer / display
+        Add("ScreenDepth", "Color depth of the screen.");
+        Add("ScreenHeight", "Pixel height of the screen.");
+        Add("ScreenWidth", "Pixel width of the screen.");
+        Add("ScreenScaleFactor", "Scale factor of the screen.");
+        Add("HighContrastColor", "Current high-contrast color.");
+        Add("HighContrastState", "Whether high-contrast mode is enabled.");
+        Add("PrinterName", "Name of the default printer.");
+
+        // System
+        Add("SystemDrive", "Drive letter the OS is installed on.");
+        Add("SystemIPAddress", "IP address of the local machine.");
+        Add("SystemLanguage", "Language code of the OS.");
+        Add("SystemNICAddress", "NIC (MAC) address of the local machine.");
+        Add("SystemPlatform", "OS platform (1=Mac, -2=Windows, etc.).");
+        Add("SystemTimeZoneOffset", "Time zone offset from UTC, in seconds.");
+        Add("SystemVersion", "OS version string.");
+        Add("PersistentID", "Persistent device identifier.");
+        Add("UUID", "A new UUID string.");
+        Add("UUIDNumber", "A new UUID expressed as a number.");
+
+        // Sort / preview / status
+        Add("SortState", "Whether the found set is sorted.");
+        Add("StatusAreaState", "Visibility/locked state of the status area.");
+        Add("PreviewState", "Whether preview mode is active.");
+        Add("PageNumber", "Current page in preview/print.");
+
+        // Triggers
+        Add("TriggerCurrentPanel", "Index of the current panel for OnPanelSwitch triggers.");
+        Add("TriggerTargetPanel", "Index of the target panel for OnPanelSwitch triggers.");
+        Add("TriggerCurrentTabPanel", "Current tab panel index.");
+        Add("TriggerTargetTabPanel", "Target tab panel index.");
+        Add("TriggerKeystroke", "Keystroke that fired the trigger.");
+        Add("TriggerModifierKeys", "Modifiers held when the trigger fired.");
+        Add("TriggerExternalEvent", "External event that fired the trigger.");
+        Add("TriggerGestureInfo", "Gesture info for the trigger.");
+
+        // Window
+        Add("WindowContentHeight", "Height of the window content area.");
+        Add("WindowContentWidth", "Width of the window content area.");
+        Add("WindowDesktopHeight", "Height of the desktop area.");
+        Add("WindowDesktopWidth", "Width of the desktop area.");
+        Add("WindowHeight", "Height of the current window.");
+        Add("WindowWidth", "Width of the current window.");
+        Add("WindowLeft", "Left coordinate of the current window.");
+        Add("WindowTop", "Top coordinate of the current window.");
+        Add("WindowMode", "Mode of the current window.");
+        Add("WindowName", "Name of the current window.");
+        Add("WindowOrientation", "Orientation of the current window.");
+        Add("WindowStyle", "Style of the current window.");
+        Add("WindowTitle", "Title of the current window.");
+        Add("WindowVisible", "Whether the window is visible.");
+        Add("WindowZoomLevel", "Zoom level of the current window.");
+
+        // Misc
+        Add("AllowAbortState", "Whether script abort is currently allowed.");
+        Add("AllowFormattingBarState", "Whether the formatting bar is allowed.");
+        Add("AllowToolbarState", "Whether toolbars are allowed.");
+        Add("OpenDataFileInfo", "Information about open data files.");
+        Add("RegionMonitorEvents", "Region-monitor event flags.");
+        Add("TextRulerVisible", "Whether the text ruler is visible.");
+        Add("TimerEventsCount", "Count of timer events.");
+        Add("TouchKeyboardState", "Whether the touch keyboard is shown.");
+        Add("UserCount", "Count of users connected to the file.");
+        Add("UserName", "Name of the current user (FileMaker preferences).");
+
+        return new ReadOnlyCollection<FmCalcEnumValue>(list);
+    }
+}
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcControlForm.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcControlForm.cs
new file mode 100644
index 0000000..340f3e4
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcControlForm.cs
@@ -0,0 +1,13 @@
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// One of the FileMaker calculation control forms (<c>Let</c>, <c>Case</c>,
+/// etc.). <see cref="Snippet"/> uses Monaco-style <c>${N:placeholder}</c>
+/// tab-stops so completion accept inserts the full form with the first slot
+/// pre-selected.
+/// </summary>
+public sealed record FmCalcControlForm(
+    string Name,
+    string Signature,
+    string Description,
+    string Snippet);
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcEnumValue.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcEnumValue.cs
new file mode 100644
index 0000000..5a0a81d
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcEnumValue.cs
@@ -0,0 +1,8 @@
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// One valid value for a function parameter that takes an enumerated keyword.
+/// <see cref="Description"/> is optional and surfaces in completion tooltips
+/// when present (e.g. each <c>Get(...)</c> selector has its own one-liner).
+/// </summary>
+public sealed record FmCalcEnumValue(string Name, string? Description = null);
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcFunction.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcFunction.cs
new file mode 100644
index 0000000..992d495
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcFunction.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// One built-in FileMaker calculation function. <see cref="Signature"/> is a
+/// human-readable form (e.g. <c>Length(text)</c>) shown in completion
+/// tooltips; <see cref="Description"/> is a one-line summary.
+///
+/// <para><see cref="Params"/> describes each positional parameter. When a
+/// parameter has a <see cref="FmCalcFunctionParam.ValidValues"/> list, the
+/// completion provider offers those keywords when the caret is inside that
+/// argument position. Functions whose params are open-ended (numbers,
+/// fields, expressions) leave <see cref="Params"/> empty — the catalog only
+/// models keyword arguments.</para>
+/// </summary>
+public sealed record FmCalcFunction(
+    string Name,
+    FunctionCategory Category,
+    string Signature,
+    string Description,
+    IReadOnlyList<FmCalcFunctionParam> Params);
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcFunctionParam.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcFunctionParam.cs
new file mode 100644
index 0000000..add4005
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcFunctionParam.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// One parameter of a built-in calculation function. <see cref="ValidValues"/>
+/// is the keyword set the parameter accepts (e.g. <c>Get(parameter)</c>'s
+/// selectors, <c>JSONSetElement</c>'s <c>type</c> values); <c>null</c> when
+/// the parameter is open-ended (a number, string, field, expression, …).
+/// </summary>
+public sealed record FmCalcFunctionParam(
+    string Name,
+    string? Description = null,
+    IReadOnlyList<FmCalcEnumValue>? ValidValues = null);
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcGrammarBuilder.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcGrammarBuilder.cs
new file mode 100644
index 0000000..2e313ed
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcGrammarBuilder.cs
@@ -0,0 +1,207 @@
+using System;
+using System.Linq;
+using System.Text.Json.Nodes;
+
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// Builds the <c>source.fmcalc</c> TextMate grammar JSON from
+/// <see cref="FmCalcCatalog"/>. Called at runtime by the registry — there
+/// is no committed grammar file. The catalog is the single source of truth;
+/// the completion provider and the grammar both read from it.
+/// </summary>
+public static class FmCalcGrammarBuilder
+{
+    public static string Build()
+    {
+        var root = new JsonObject
+        {
+            ["name"] = "FileMaker Calculation",
+            ["scopeName"] = "source.fmcalc",
+            ["fileTypes"] = new JsonArray("fmcalc"),
+            ["patterns"] = new JsonArray(Include("#expression")),
+            ["repository"] = BuildRepository(),
+        };
+
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            WriteIndented = true,
+            Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        };
+        return root.ToJsonString(options);
+    }
+
+    private static JsonObject BuildRepository() => new()
+    {
+        ["expression"] = new JsonObject
+        {
+            ["patterns"] = new JsonArray(
+                Include("#comment-block"),
+                Include("#comment-line"),
+                Include("#string"),
+                Include("#number"),
+                Include("#constant"),
+                Include("#control-form"),
+                Include("#operator-word"),
+                Include("#variable"),
+                Include("#field-reference"),
+                Include("#builtin-function"),
+                Include("#custom-function"),
+                Include("#operator-symbol"),
+                Include("#punctuation")),
+        },
+        ["comment-block"] = new JsonObject
+        {
+            ["name"] = "comment.block.fmcalc",
+            ["begin"] = @"/\*",
+            ["beginCaptures"] = NamedCapture("0", "punctuation.definition.comment.fmcalc"),
+            ["end"] = @"\*/",
+            ["endCaptures"] = NamedCapture("0", "punctuation.definition.comment.fmcalc"),
+        },
+        ["comment-line"] = new JsonObject
+        {
+            ["name"] = "comment.line.double-slash.fmcalc",
+            ["begin"] = "//",
+            ["beginCaptures"] = NamedCapture("0", "punctuation.definition.comment.fmcalc"),
+            ["end"] = "$",
+        },
+        ["string"] = new JsonObject
+        {
+            ["name"] = "string.quoted.double.fmcalc",
+            ["begin"] = "\"",
+            ["beginCaptures"] = NamedCapture("0", "punctuation.definition.string.begin.fmcalc"),
+            ["end"] = "\"",
+            ["endCaptures"] = NamedCapture("0", "punctuation.definition.string.end.fmcalc"),
+            ["patterns"] = new JsonArray(new JsonObject
+            {
+                ["name"] = "constant.character.escape.fmcalc",
+                ["match"] = @"\\(""|\\|n|r|t)",
+            }),
+        },
+        ["number"] = new JsonObject
+        {
+            ["name"] = "constant.numeric.fmcalc",
+            ["match"] = @"\b\d+(\.\d+)?([eE][+-]?\d+)?\b",
+        },
+        ["constant"] = new JsonObject
+        {
+            ["name"] = "constant.language.fmcalc",
+            ["match"] = $@"\b({string.Join("|", FmCalcCatalog.Constants)})\b",
+        },
+        ["control-form"] = new JsonObject
+        {
+            ["name"] = "keyword.control.fmcalc",
+            ["match"] = $@"\b({string.Join("|", FmCalcCatalog.ControlForms.Select(c => c.Name))})(?=\s*\()",
+        },
+        ["operator-word"] = new JsonObject
+        {
+            ["name"] = "keyword.operator.word.fmcalc",
+            ["match"] = $@"\b({string.Join("|", FmCalcCatalog.WordOperators)})\b",
+        },
+        ["variable"] = new JsonObject
+        {
+            ["name"] = "variable.other.fmcalc",
+            ["match"] = @"\${1,2}[A-Za-z_][A-Za-z0-9_.]*",
+        },
+        ["field-reference"] = new JsonObject
+        {
+            ["match"] = @"\b([A-Za-z_][A-Za-z0-9_ ]*?)(::)([A-Za-z_][A-Za-z0-9_]*)",
+            ["captures"] = new JsonObject
+            {
+                ["1"] = ScopeNode("entity.name.type.fmcalc"),
+                ["2"] = ScopeNode("punctuation.separator.field.fmcalc"),
+                ["3"] = ScopeNode("variable.other.member.fmcalc"),
+            },
+        },
+        ["builtin-function"] = BuildBuiltinFunctions(),
+        ["custom-function"] = new JsonObject
+        {
+            ["match"] = @"\b([A-Za-z_][A-Za-z0-9_]*)\s*(?=\()",
+            ["captures"] = new JsonObject
+            {
+                ["1"] = ScopeNode("entity.name.function.fmcalc"),
+            },
+        },
+        ["operator-symbol"] = new JsonObject
+        {
+            ["name"] = "keyword.operator.fmcalc",
+            ["match"] = @"(\^|\*|/|\+|-|&|=|≠|<>|≤|<=|≥|>=|<|>)",
+        },
+        ["punctuation"] = new JsonObject
+        {
+            ["patterns"] = new JsonArray(
+                new JsonObject { ["match"] = @"\(", ["name"] = "punctuation.section.parens.begin.fmcalc" },
+                new JsonObject { ["match"] = @"\)", ["name"] = "punctuation.section.parens.end.fmcalc" },
+                new JsonObject { ["match"] = ";", ["name"] = "punctuation.separator.fmcalc" },
+                new JsonObject { ["match"] = ",", ["name"] = "punctuation.separator.fmcalc" },
+                new JsonObject { ["match"] = @"\[", ["name"] = "punctuation.section.brackets.begin.fmcalc" },
+                new JsonObject { ["match"] = @"\]", ["name"] = "punctuation.section.brackets.end.fmcalc" }),
+        },
+    };
+
+    private static JsonObject BuildBuiltinFunctions()
+    {
+        var patterns = new JsonArray();
+
+        // One alternation per category so each can carry its own
+        // support.function.<category>.fmcalc scope. Within a category,
+        // sort length-desc then alphabetical — the standard TextMate idiom
+        // that ensures longer alternatives win when one name prefixes another.
+        var groups = FmCalcCatalog.Functions
+            .GroupBy(f => f.Category)
+            .OrderBy(g => (int)g.Key);
+
+        foreach (var group in groups)
+        {
+            var names = group
+                .Select(f => f.Name)
+                .OrderByDescending(n => n.Length)
+                .ThenBy(n => n, StringComparer.Ordinal)
+                .ToList();
+
+            patterns.Add(new JsonObject
+            {
+                ["match"] = $@"\b({string.Join("|", names)})\s*(?=\()",
+                ["captures"] = new JsonObject
+                {
+                    ["1"] = ScopeNode($"support.function.{ScopeSegment(group.Key)}.fmcalc"),
+                },
+            });
+        }
+
+        return new JsonObject { ["patterns"] = patterns };
+    }
+
+    /// <summary>
+    /// Map a category enum to its TextMate scope segment. Hyphenated for
+    /// multi-word categories, matching VS Code grammar conventions.
+    /// </summary>
+    public static string ScopeSegment(FunctionCategory category) => category switch
+    {
+        FunctionCategory.Text => "text",
+        FunctionCategory.TextFormatting => "text-formatting",
+        FunctionCategory.Number => "number",
+        FunctionCategory.Date => "date",
+        FunctionCategory.Time => "time",
+        FunctionCategory.Aggregate => "aggregate",
+        FunctionCategory.Summary => "summary",
+        FunctionCategory.Financial => "financial",
+        FunctionCategory.Trigonometric => "trigonometric",
+        FunctionCategory.Logical => "logical",
+        FunctionCategory.Get => "get",
+        FunctionCategory.Container => "container",
+        FunctionCategory.Json => "json",
+        FunctionCategory.Sql => "sql",
+        FunctionCategory.External => "external",
+        FunctionCategory.Design => "design",
+        _ => throw new ArgumentOutOfRangeException(nameof(category), category, null),
+    };
+
+    private static JsonObject Include(string reference) => new() { ["include"] = reference };
+    private static JsonObject ScopeNode(string name) => new() { ["name"] = name };
+
+    private static JsonObject NamedCapture(string group, string scope) => new()
+    {
+        [group] = ScopeNode(scope),
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Calc/FmCalcSignatureParser.cs b/src/SharpFM.Model/Scripting/Calc/FmCalcSignatureParser.cs
new file mode 100644
index 0000000..bf598bb
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FmCalcSignatureParser.cs
@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// Parses the param list out of a function signature string like
+/// <c>JSONGetElement(json; keyOrIndexOrPath)</c> so completion items can
+/// tab through placeholders without us hand-authoring a per-function param
+/// list. Variadic markers like <c>{; field...}</c> are dropped — anything
+/// before the first <c>{</c> is taken as the named portion.
+/// </summary>
+public static class FmCalcSignatureParser
+{
+    public static IReadOnlyList<FmCalcFunctionParam> ParseParams(string signature)
+    {
+        if (string.IsNullOrWhiteSpace(signature)) return System.Array.Empty<FmCalcFunctionParam>();
+
+        var openParen = signature.IndexOf('(');
+        var closeParen = signature.LastIndexOf(')');
+        if (openParen < 0 || closeParen < openParen) return System.Array.Empty<FmCalcFunctionParam>();
+
+        var inner = signature.Substring(openParen + 1, closeParen - openParen - 1);
+
+        // Drop any variadic / optional region. Catalog signatures use
+        // {; ...} for "and more like this" — we don't model that as a
+        // separate stop, so trim it off.
+        var brace = inner.IndexOf('{');
+        if (brace >= 0) inner = inner.Substring(0, brace);
+
+        if (string.IsNullOrWhiteSpace(inner)) return System.Array.Empty<FmCalcFunctionParam>();
+
+        var result = new List<FmCalcFunctionParam>();
+        foreach (var part in inner.Split(';'))
+        {
+            var name = part.Trim().TrimStart('[').TrimEnd(']').Trim();
+            if (name.Length == 0) continue;
+            result.Add(new FmCalcFunctionParam(name));
+        }
+        return result;
+    }
+}
diff --git a/src/SharpFM.Model/Scripting/Calc/FunctionCategory.cs b/src/SharpFM.Model/Scripting/Calc/FunctionCategory.cs
new file mode 100644
index 0000000..0b12330
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Calc/FunctionCategory.cs
@@ -0,0 +1,26 @@
+namespace SharpFM.Model.Scripting.Calc;
+
+/// <summary>
+/// FileMaker calculation function categories. Mirrors the grouping in
+/// FileMaker's calculation dialog so completion menus and TextMate scopes
+/// (<c>support.function.&lt;category&gt;.fmcalc</c>) line up.
+/// </summary>
+public enum FunctionCategory
+{
+    Text,
+    TextFormatting,
+    Number,
+    Date,
+    Time,
+    Aggregate,
+    Summary,
+    Financial,
+    Trigonometric,
+    Logical,
+    Get,
+    Container,
+    Json,
+    Sql,
+    External,
+    Design,
+}
diff --git a/src/SharpFM/Editors/ScriptTextEditor.cs b/src/SharpFM/Editors/ScriptTextEditor.cs
index 4ee6c71..02e8905 100644
--- a/src/SharpFM/Editors/ScriptTextEditor.cs
+++ b/src/SharpFM/Editors/ScriptTextEditor.cs
@@ -32,7 +32,7 @@ public class ScriptTextEditor : TextEditor, IDisposable
     private static readonly RegistryOptions SharedRegistry =
         new((ThemeName)(int)ThemeName.DarkPlus);
 
-    private static readonly FmScriptRegistryOptions SharedFmRegistry =
+    private static readonly FmLanguageRegistryOptions SharedFmRegistry =
         new(SharedRegistry);
 
     private readonly TextMate.Installation _textMate;
@@ -41,7 +41,7 @@ public class ScriptTextEditor : TextEditor, IDisposable
     public ScriptTextEditor()
     {
         _textMate = this.InstallTextMate(SharedFmRegistry);
-        _textMate.SetGrammar(FmScriptRegistryOptions.ScopeName);
+        _textMate.SetGrammar(FmLanguageRegistryOptions.ScriptScopeName);
 
         _controller = new ScriptEditorController(this);
         _controller.StatusMessageRaised += OnStatusMessageRaised;
diff --git a/src/SharpFM/Schema/Editor/CalculationEditorWindow.axaml.cs b/src/SharpFM/Schema/Editor/CalculationEditorWindow.axaml.cs
index 1affbd8..916c015 100644
--- a/src/SharpFM/Schema/Editor/CalculationEditorWindow.axaml.cs
+++ b/src/SharpFM/Schema/Editor/CalculationEditorWindow.axaml.cs
@@ -1,10 +1,13 @@
 using System.Diagnostics.CodeAnalysis;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Interactivity;
 using AvaloniaEdit;
+using AvaloniaEdit.CodeCompletion;
 using AvaloniaEdit.TextMate;
 using SharpFM.Model.Schema;
 using SharpFM.Scripting;
+using SharpFM.Scripting.Editor;
 using TextMateSharp.Grammars;
 
 namespace SharpFM.Schema.Editor;
@@ -14,48 +17,130 @@ public partial class CalculationEditorWindow : Window
 {
     private readonly FmField _field;
     private readonly TextMate.Installation _textMateInstallation;
+    private readonly TextEditor _editor;
+    private readonly CalcCompletionContextProvider _completionContext;
+    private CompletionWindow? _completionWindow;
 
     public bool Saved { get; private set; }
 
     // Required by XAML loader
-    public CalculationEditorWindow() : this(new FmField()) { }
+    public CalculationEditorWindow() : this(new FmField(), null) { }
 
-    public CalculationEditorWindow(FmField field)
+    public CalculationEditorWindow(FmField field) : this(field, null) { }
+
+    public CalculationEditorWindow(FmField field, FmTable? currentTable)
     {
         InitializeComponent();
 
         _field = field;
 
-        // Set up FM script syntax highlighting for calculations
+        // Set up FM calculation syntax highlighting
         var registryOptions = new RegistryOptions((ThemeName)(int)ThemeName.DarkPlus);
-        var fmRegistry = new FmScriptRegistryOptions(registryOptions);
-        var editor = this.FindControl<TextEditor>("calcEditor")!;
-        _textMateInstallation = editor.InstallTextMate(fmRegistry);
-        _textMateInstallation.SetGrammar(FmScriptRegistryOptions.ScopeName);
+        var fmRegistry = new FmLanguageRegistryOptions(registryOptions);
+        _editor = this.FindControl<TextEditor>("calcEditor")!;
+        _textMateInstallation = _editor.InstallTextMate(fmRegistry);
+        _textMateInstallation.SetGrammar(FmLanguageRegistryOptions.CalcScopeName);
 
         // Populate fields
-        editor.Text = field.Calculation ?? "";
+        _editor.Text = field.Calculation ?? "";
         var contextBox = this.FindControl<TextBox>("contextTableBox")!;
         contextBox.Text = field.CalculationContext ?? "";
         var alwaysCheck = this.FindControl<CheckBox>("alwaysEvaluateCheck")!;
         alwaysCheck.IsChecked = field.AlwaysEvaluate;
 
+        _completionContext = new CalcCompletionContextProvider(
+            getDocumentText: () => _editor.Document.Text,
+            currentTable: currentTable);
+
+        // Completion: pop the menu on every text input. Same trigger model
+        // the script editor uses, kept inline rather than introducing a
+        // controller — calc editor has no other adornments to coordinate.
+        _editor.TextArea.TextEntered += OnTextEntered;
+        _editor.TextArea.TextEntering += OnTextEntering;
+
         // Wire buttons
         this.FindControl<Button>("okButton")!.Click += OnOk;
         this.FindControl<Button>("cancelButton")!.Click += OnCancel;
     }
 
+    private void OnTextEntered(object? sender, TextInputEventArgs e)
+    {
+        if (_completionWindow != null) return;
+        if (string.IsNullOrEmpty(e.Text)) return;
+
+        var ch = e.Text[0];
+        var isIdentifierTrigger = IsTriggerChar(ch);
+        // Argument-boundary characters: ( and ; should pop the menu *only*
+        // when we end up in a FunctionParam context (e.g. Get( →
+        // selectors, JSONSetElement(j;k;v; → JSON types). Without this,
+        // every ( and ; would spam the window with the full identifier
+        // catalog.
+        var isArgBoundary = ch == '(' || ch == ';';
+        if (!isIdentifierTrigger && !isArgBoundary) return;
+
+        var caret = _editor.TextArea.Caret;
+        var line = _editor.Document.GetLineByNumber(caret.Line);
+        var lineText = _editor.Document.GetText(line.Offset, line.Length);
+        var col = caret.Column - 1;
+
+        var (context, items) = FmCalcCompletionProvider.GetCompletions(lineText, col, _completionContext);
+        if (context == CalcCompletionContext.None || items.Count == 0) return;
+        if (isArgBoundary && context != CalcCompletionContext.FunctionParam) return;
+
+        // Anchor the completion window to the start of the identifier the
+        // user is typing so accepting an item replaces the partial prefix
+        // instead of appending after it.
+        var prefixStart = col;
+        while (prefixStart > 0 && IsIdentifierChar(lineText[prefixStart - 1]))
+            prefixStart--;
+
+        _completionWindow = new CompletionWindow(_editor.TextArea)
+        {
+            StartOffset = line.Offset + prefixStart,
+        };
+        foreach (var item in items)
+            _completionWindow.CompletionList.CompletionData.Add(item);
+
+        _completionWindow.Show();
+        _completionWindow.Closed += (_, _) => _completionWindow = null;
+    }
+
+    /// <summary>
+    /// Forward non-letter characters typed while the completion window is
+    /// open as accept-and-insert events. Mirrors AvaloniaEdit's standard
+    /// completion-binding pattern so typing <c>(</c> after <c>Lengt</c>
+    /// completes <c>Length</c> first then inserts the paren.
+    /// </summary>
+    private void OnTextEntering(object? sender, TextInputEventArgs e)
+    {
+        if (_completionWindow == null) return;
+        if (string.IsNullOrEmpty(e.Text)) return;
+        if (!IsIdentifierChar(e.Text[0]))
+            _completionWindow.CompletionList.RequestInsertion(e);
+    }
+
+    private static bool IsIdentifierChar(char c) =>
+        char.IsLetterOrDigit(c) || c == '_';
+
+    /// <summary>
+    /// Characters that should pop the completion window when typed in a
+    /// fresh editor with no window open. Letters and underscore start
+    /// identifiers; <c>$</c> starts a variable reference. Digits and other
+    /// punctuation never start a completion-worthy token, so we ignore them.
+    /// </summary>
+    private static bool IsTriggerChar(char c) =>
+        char.IsLetter(c) || c == '_' || c == '$';
+
     private void OnOk(object? sender, RoutedEventArgs e)
     {
-        var editor = this.FindControl<TextEditor>("calcEditor")!;
         var contextBox = this.FindControl<TextBox>("contextTableBox")!;
         var alwaysCheck = this.FindControl<CheckBox>("alwaysEvaluateCheck")!;
 
-        _field.Calculation = editor.Text;
+        _field.Calculation = _editor.Text;
         _field.CalculationContext = string.IsNullOrWhiteSpace(contextBox.Text) ? null : contextBox.Text;
         _field.AlwaysEvaluate = alwaysCheck.IsChecked == true;
 
-        if (_field.Kind == FieldKind.Normal && !string.IsNullOrWhiteSpace(editor.Text))
+        if (_field.Kind == FieldKind.Normal && !string.IsNullOrWhiteSpace(_editor.Text))
             _field.Kind = FieldKind.Calculated;
 
         Saved = true;
diff --git a/src/SharpFM/Schema/Editor/TableEditorViewModel.cs b/src/SharpFM/Schema/Editor/TableEditorViewModel.cs
index b67aecf..f9e1b43 100644
--- a/src/SharpFM/Schema/Editor/TableEditorViewModel.cs
+++ b/src/SharpFM/Schema/Editor/TableEditorViewModel.cs
@@ -81,7 +81,7 @@ public void RemoveSelectedField()
     public void OpenCalculationEditor()
     {
         if (SelectedField == null) return;
-        var window = new CalculationEditorWindow(SelectedField);
+        var window = new CalculationEditorWindow(SelectedField, Table);
         window.ShowDialog(Avalonia.Application.Current?.ApplicationLifetime
             is Avalonia.Controls.ApplicationLifetimes.IClassicDesktopStyleApplicationLifetime desktop
             ? desktop.MainWindow! : null!);
diff --git a/src/SharpFM/Scripting/Editor/CalcCompletionContextProvider.cs b/src/SharpFM/Scripting/Editor/CalcCompletionContextProvider.cs
new file mode 100644
index 0000000..ed710ba
--- /dev/null
+++ b/src/SharpFM/Scripting/Editor/CalcCompletionContextProvider.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using SharpFM.Model.Schema;
+
+namespace SharpFM.Scripting.Editor;
+
+/// <summary>
+/// Document-aware completion context for the calculation editor:
+///
+/// <list type="bullet">
+///   <item><description><b>Variables</b> — scrapes <c>$ident</c> and <c>$$ident</c>
+///   tokens from the current calculation text. Doesn't attempt proper
+///   <c>Let</c>-scope analysis; calcs are short enough that bag-of-names
+///   from the document covers the common case (reminding the user of names
+///   they've already introduced).</description></item>
+///   <item><description><b>Fields</b> — names from the table the field
+///   being edited belongs to. Cross-table refs would need the surrounding
+///   schema, which the calc editor isn't given today.</description></item>
+///   <item><description><b>Tables</b> — empty until a schema container
+///   exists that can enumerate table occurrences.</description></item>
+/// </list>
+/// </summary>
+internal sealed class CalcCompletionContextProvider : ICalcCompletionContextProvider
+{
+    private static readonly Regex VariableRegex =
+        new(@"\$\$?([A-Za-z_][A-Za-z0-9_.]*)", RegexOptions.Compiled);
+
+    private readonly Func<string> _getDocumentText;
+    private readonly FmTable? _currentTable;
+
+    public CalcCompletionContextProvider(Func<string> getDocumentText, FmTable? currentTable)
+    {
+        _getDocumentText = getDocumentText;
+        _currentTable = currentTable;
+    }
+
+    public IReadOnlyList<string> GetVariablesInScope(string lineText, int offset)
+    {
+        var doc = _getDocumentText();
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        var result = new List<string>();
+        foreach (Match m in VariableRegex.Matches(doc))
+        {
+            var name = m.Groups[1].Value;
+            if (seen.Add(name)) result.Add(name);
+        }
+        return result;
+    }
+
+    public IReadOnlyList<string> GetTableNames() => Array.Empty<string>();
+
+    public IReadOnlyList<string> GetFieldsForTable(string tableName)
+    {
+        if (_currentTable == null) return Array.Empty<string>();
+        if (!string.Equals(tableName, _currentTable.Name, StringComparison.OrdinalIgnoreCase))
+            return Array.Empty<string>();
+        return _currentTable.Fields.Select(f => f.Name).ToList();
+    }
+}
diff --git a/src/SharpFM/Scripting/Editor/FmCalcCompletionProvider.cs b/src/SharpFM/Scripting/Editor/FmCalcCompletionProvider.cs
new file mode 100644
index 0000000..d2e9b64
--- /dev/null
+++ b/src/SharpFM/Scripting/Editor/FmCalcCompletionProvider.cs
@@ -0,0 +1,367 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AvaloniaEdit.CodeCompletion;
+using SharpFM.Model.Scripting.Calc;
+
+namespace SharpFM.Scripting.Editor;
+
+public enum CalcCompletionContext
+{
+    None,
+    Identifier,
+    Variable,
+    FieldRef,
+    FunctionParam,
+    String,
+    Comment,
+}
+
+/// <summary>
+/// Completion provider for the FileMaker calculation editor. Reads exclusively
+/// from <see cref="FmCalcCatalog"/> — same source of truth that drives the
+/// TextMate grammar, so highlighting and completions can never disagree.
+///
+/// Completion items carry a signature + one-line description in their
+/// tooltip; control forms (<c>Let</c>, <c>Case</c>, …) expand from snippet
+/// templates with the first parameter pre-selected for editing.
+///
+/// <para>Phase-3 hooks: <see cref="GetCompletions(string, int, ICalcCompletionContextProvider?)"/>
+/// accepts an optional context provider that supplies <c>$variables</c>
+/// in scope and field references for the current calc. The window passes a
+/// real one; tests pass <c>null</c> and only exercise built-in completions.</para>
+/// </summary>
+public static class FmCalcCompletionProvider
+{
+    public static (CalcCompletionContext Context, IList<ICompletionData> Items) GetCompletions(
+        string lineText, int caretColumn, ICalcCompletionContextProvider? contextProvider = null)
+    {
+        if (caretColumn < 0) caretColumn = 0;
+        if (caretColumn > lineText.Length) caretColumn = lineText.Length;
+
+        var beforeCaret = lineText.Substring(0, caretColumn);
+
+        if (IsInsideString(beforeCaret))
+            return (CalcCompletionContext.String, Array.Empty<ICompletionData>());
+
+        if (IsInsideLineComment(beforeCaret))
+            return (CalcCompletionContext.Comment, Array.Empty<ICompletionData>());
+
+        // Walk back from caret over identifier characters to find the prefix
+        // we're currently typing. Then look at what comes immediately before
+        // it to decide whether we're naming a function (default), a $variable,
+        // or the field side of a Table::Field reference.
+        var prefixStart = caretColumn;
+        while (prefixStart > 0 && IsIdentifierChar(lineText[prefixStart - 1]))
+            prefixStart--;
+        var prefix = lineText.Substring(prefixStart, caretColumn - prefixStart);
+
+        // $variable or $$global
+        if (prefixStart >= 1 && lineText[prefixStart - 1] == '$')
+        {
+            var dollars = (prefixStart >= 2 && lineText[prefixStart - 2] == '$') ? "$$" : "$";
+            var vars = contextProvider?.GetVariablesInScope(lineText, prefixStart - dollars.Length) ?? Array.Empty<string>();
+            var items = vars
+                .Where(v => v.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                .Select(v => (ICompletionData)new FmScriptCompletionData(v, "variable"))
+                .ToList();
+            return (CalcCompletionContext.Variable, items);
+        }
+
+        // Field side of Table::Field — caret is right after `::`
+        if (prefixStart >= 2 && lineText[prefixStart - 1] == ':' && lineText[prefixStart - 2] == ':')
+        {
+            var tableNameStart = prefixStart - 2;
+            while (tableNameStart > 0 && IsIdentifierChar(lineText[tableNameStart - 1]))
+                tableNameStart--;
+            var tableName = lineText.Substring(tableNameStart, (prefixStart - 2) - tableNameStart);
+            var fields = contextProvider?.GetFieldsForTable(tableName) ?? Array.Empty<string>();
+            var items = fields
+                .Where(f => f.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                .Select(f => (ICompletionData)new FmScriptCompletionData(f, $"{tableName}::{f}"))
+                .ToList();
+            return (CalcCompletionContext.FieldRef, items);
+        }
+
+        // Inside Func(...) on an argument that takes enumerated keywords
+        // (e.g. Get(<here>) → AccountName, …; JSONSetElement(j;k;v;<here>)
+        // → JSONString, JSONNumber, …). Detection walks back through the
+        // line looking for an unmatched `(` and counting `;` separators.
+        var enclosing = DetectEnclosingCall(lineText, prefixStart);
+        if (enclosing.HasValue)
+        {
+            var key = (enclosing.Value.FunctionName.ToLowerInvariant(), enclosing.Value.ArgIndex);
+            if (ParamValueCompletions.TryGetValue(key, out var paramItems))
+            {
+                var filtered = new List<ICompletionData>();
+                foreach (var item in paramItems)
+                {
+                    if (Matches(item.Text, prefix)) filtered.Add(item);
+                }
+                return (CalcCompletionContext.FunctionParam, filtered);
+            }
+        }
+
+        // Default: identifier — functions, control forms, constants.
+        // (Plus tables for the head of a Table::Field, when phase-3 context
+        // is wired up.)
+        var identifierItems = BuildIdentifierCompletions(prefix, contextProvider);
+        return (CalcCompletionContext.Identifier, identifierItems);
+    }
+
+    /// <summary>
+    /// Walk backward from <paramref name="caretPos"/> through
+    /// <paramref name="text"/> tracking paren depth and string state to
+    /// find the call we're directly inside, plus which positional argument
+    /// (0-based) the caret sits in. Returns <c>null</c> if there's no
+    /// enclosing call on this line.
+    /// </summary>
+    internal static (string FunctionName, int ArgIndex)? DetectEnclosingCall(string text, int caretPos)
+    {
+        // Stack frames track each unmatched `(` we've passed and the arg
+        // index at that level. The top of stack at the caret is the call
+        // we're directly inside.
+        var stack = new Stack<(int Position, int ArgIndex)>();
+        bool inString = false;
+
+        for (int i = 0; i < caretPos && i < text.Length; i++)
+        {
+            char ch = text[i];
+
+            if (inString)
+            {
+                if (ch == '\\' && i + 1 < caretPos) { i++; continue; }
+                if (ch == '"') inString = false;
+                continue;
+            }
+
+            if (ch == '"') { inString = true; continue; }
+            if (ch == '/' && i + 1 < caretPos && text[i + 1] == '/') return null; // line comment kills detection
+
+            if (ch == '(')
+            {
+                stack.Push((i, 0));
+            }
+            else if (ch == ')')
+            {
+                if (stack.Count > 0) stack.Pop();
+            }
+            else if (ch == ';' && stack.Count > 0)
+            {
+                var top = stack.Pop();
+                stack.Push((top.Position, top.ArgIndex + 1));
+            }
+        }
+
+        if (stack.Count == 0) return null;
+        var enclosing = stack.Peek();
+
+        // Read function name immediately before the matching `(`. Skip
+        // whitespace then walk back over identifier characters.
+        int j = enclosing.Position - 1;
+        while (j >= 0 && char.IsWhiteSpace(text[j])) j--;
+        int nameEnd = j + 1;
+        while (j >= 0 && IsIdentifierChar(text[j])) j--;
+        int nameStart = j + 1;
+        if (nameStart == nameEnd) return null;
+
+        return (text.Substring(nameStart, nameEnd - nameStart), enclosing.ArgIndex);
+    }
+
+    /// <summary>
+    /// Per-(function, argIndex) prebuilt completion lists for parameters
+    /// that accept enumerated keywords. Built once at type init from the
+    /// catalog so per-trigger work is just a prefix filter.
+    /// </summary>
+    private static readonly Dictionary<(string FuncName, int ArgIndex), IReadOnlyList<ICompletionData>>
+        ParamValueCompletions = BuildParamValueCompletions();
+
+    private static Dictionary<(string, int), IReadOnlyList<ICompletionData>> BuildParamValueCompletions()
+    {
+        var d = new Dictionary<(string, int), IReadOnlyList<ICompletionData>>();
+        foreach (var fn in FmCalcCatalog.Functions)
+        {
+            for (int i = 0; i < fn.Params.Count; i++)
+            {
+                var p = fn.Params[i];
+                if (p.ValidValues == null || p.ValidValues.Count == 0) continue;
+
+                var items = new List<ICompletionData>(p.ValidValues.Count);
+                foreach (var v in p.ValidValues)
+                {
+                    items.Add(new FmScriptCompletionData(
+                        v.Name,
+                        v.Description ?? p.Name));
+                }
+                d[(fn.Name.ToLowerInvariant(), i)] = items;
+            }
+        }
+        return d;
+    }
+
+    /// <summary>
+    /// All built-in identifier completions (functions, control forms,
+    /// constants), built once at startup. The catalog is immutable after
+    /// type initialization, so this list is shared safely across every
+    /// calculation editor — no per-trigger allocations beyond the filtered
+    /// view we hand to the completion window.
+    ///
+    /// <para>Public so future consumers (e.g. embedded calc inside script
+    /// step brackets) can reuse the same list.</para>
+    /// </summary>
+    public static IReadOnlyList<ICompletionData> AllBuiltinIdentifierCompletions { get; } =
+        BuildAllBuiltinIdentifierCompletions();
+
+    private static IReadOnlyList<ICompletionData> BuildAllBuiltinIdentifierCompletions()
+    {
+        var items = new List<ICompletionData>(
+            FmCalcCatalog.ControlForms.Count
+            + FmCalcCatalog.Functions.Count
+            + FmCalcCatalog.Constants.Count);
+
+        // Control forms first — promoted via priority so Let/Case/If sort
+        // ahead of similarly-named functions when prefixes overlap.
+        foreach (var c in FmCalcCatalog.ControlForms)
+        {
+            items.Add(new FmScriptCompletionData(
+                c.Name,
+                $"{c.Signature} — {c.Description}",
+                priority: 1.0,
+                snippet: c.Snippet));
+        }
+
+        foreach (var f in FmCalcCatalog.Functions)
+        {
+            items.Add(new FmScriptCompletionData(
+                f.Name,
+                $"{f.Signature} — {f.Description}",
+                snippet: BuildFunctionSnippet(f)));
+        }
+
+        foreach (var k in FmCalcCatalog.Constants)
+        {
+            items.Add(new FmScriptCompletionData(k, "constant"));
+        }
+
+        return items;
+    }
+
+    /// <summary>
+    /// Build a Monaco-style snippet for a function so accepting its
+    /// completion inserts <c>Func ( ${1:p1} ; ${2:p2} )</c> with the first
+    /// param selected and Tab navigating through the rest. Functions with
+    /// no parsed params (e.g. <c>Random</c>) collapse to the bare name.
+    /// </summary>
+    private static string? BuildFunctionSnippet(FmCalcFunction f)
+    {
+        if (f.Params.Count == 0) return null;
+
+        var parts = new List<string>(f.Params.Count);
+        for (int i = 0; i < f.Params.Count; i++)
+        {
+            // Use the first valid value as the placeholder when the param
+            // takes an enumerated keyword — gives the user a real example
+            // (e.g. AccountName for Get) rather than the generic param name.
+            var p = f.Params[i];
+            var placeholder = p.ValidValues is { Count: > 0 } vs ? vs[0].Name : p.Name;
+            parts.Add($"${{{i + 1}:{placeholder}}}");
+        }
+        return $"{f.Name} ( {string.Join(" ; ", parts)} )";
+    }
+
+    private static IList<ICompletionData> BuildIdentifierCompletions(
+        string prefix, ICalcCompletionContextProvider? contextProvider)
+    {
+        // Filter the prebuilt list — no per-trigger allocations of completion
+        // data objects, just a List of references.
+        var items = new List<ICompletionData>();
+        foreach (var item in AllBuiltinIdentifierCompletions)
+        {
+            if (Matches(item.Text, prefix)) items.Add(item);
+        }
+
+        // Tables come from the document context, so they're built per-trigger.
+        // Empty in practice today (no schema container); the loop is a no-op
+        // until that hook is wired.
+        if (contextProvider != null)
+        {
+            foreach (var t in contextProvider.GetTableNames())
+            {
+                if (!Matches(t, prefix)) continue;
+                items.Add(new FmScriptCompletionData(t, "table"));
+            }
+        }
+
+        return items;
+    }
+
+    private static bool Matches(string candidate, string prefix) =>
+        prefix.Length == 0 || candidate.StartsWith(prefix, StringComparison.OrdinalIgnoreCase);
+
+    private static bool IsIdentifierChar(char c) =>
+        char.IsLetterOrDigit(c) || c == '_';
+
+    /// <summary>
+    /// True if the caret sits inside an unterminated double-quoted string
+    /// on this line. Counts unescaped quote characters — odd → inside.
+    /// </summary>
+    private static bool IsInsideString(string textBeforeCaret)
+    {
+        bool inside = false;
+        for (int i = 0; i < textBeforeCaret.Length; i++)
+        {
+            var ch = textBeforeCaret[i];
+            if (ch == '\\' && i + 1 < textBeforeCaret.Length)
+            {
+                i++;
+                continue;
+            }
+            if (ch == '"') inside = !inside;
+        }
+        return inside;
+    }
+
+    /// <summary>
+    /// True if the caret sits inside a <c>//</c> line comment that begins
+    /// before the caret on this line and is not itself inside a string.
+    /// </summary>
+    private static bool IsInsideLineComment(string textBeforeCaret)
+    {
+        bool insideString = false;
+        for (int i = 0; i < textBeforeCaret.Length - 1; i++)
+        {
+            var ch = textBeforeCaret[i];
+            if (ch == '\\' && i + 1 < textBeforeCaret.Length)
+            {
+                i++;
+                continue;
+            }
+            if (ch == '"') insideString = !insideString;
+            else if (!insideString && ch == '/' && textBeforeCaret[i + 1] == '/')
+                return true;
+        }
+        return false;
+    }
+}
+
+/// <summary>
+/// Phase-3 extension point: lets the calculation editor supply
+/// document-derived completions (<c>$Let</c> bindings in scope, table /
+/// field lists from the FmField context). Implementations can return empty
+/// lists to opt out.
+/// </summary>
+public interface ICalcCompletionContextProvider
+{
+    /// <summary>
+    /// Local and global variables visible at the given caret offset on the
+    /// supplied line. Names should be the bare identifier — no <c>$</c> or
+    /// <c>$$</c> prefix; the provider already knows from context.
+    /// </summary>
+    IReadOnlyList<string> GetVariablesInScope(string lineText, int offset);
+
+    /// <summary>Names of tables (or table occurrences) usable as the LHS of <c>Table::Field</c>.</summary>
+    IReadOnlyList<string> GetTableNames();
+
+    /// <summary>Field names for the named table.</summary>
+    IReadOnlyList<string> GetFieldsForTable(string tableName);
+}
diff --git a/src/SharpFM/Scripting/Editor/FmLanguageRegistryOptions.cs b/src/SharpFM/Scripting/Editor/FmLanguageRegistryOptions.cs
new file mode 100644
index 0000000..1812195
--- /dev/null
+++ b/src/SharpFM/Scripting/Editor/FmLanguageRegistryOptions.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using SharpFM.Model.Scripting.Calc;
+using TextMateSharp.Grammars;
+using TextMateSharp.Internal.Grammars.Reader;
+using TextMateSharp.Internal.Types;
+using TextMateSharp.Registry;
+using TextMateSharp.Themes;
+
+namespace SharpFM.Scripting.Editor;
+
+/// <summary>
+/// Serves the FileMaker TextMate grammars (<c>source.fmscript</c> and
+/// <c>source.fmcalc</c>) and delegates everything else to an inner
+/// <see cref="RegistryOptions"/>. The script grammar is hand-authored and
+/// embedded as a resource; the calc grammar is built at first use from
+/// <see cref="FmCalcCatalog"/> via <see cref="FmCalcGrammarBuilder"/> so the
+/// catalog is the single source of truth for both grammar and completions.
+/// Cross-grammar <c>include</c>s — e.g. the script grammar embedding the
+/// calc grammar inside <c>[ ... ]</c> — resolve through this method.
+/// </summary>
+[ExcludeFromCodeCoverage]
+public class FmLanguageRegistryOptions : IRegistryOptions
+{
+    public const string ScriptScopeName = "source.fmscript";
+    public const string CalcScopeName = "source.fmcalc";
+
+    private readonly RegistryOptions _inner;
+
+    private static readonly Lazy<IRawGrammar> ScriptGrammar =
+        new(LoadEmbeddedScriptGrammar, LazyThreadSafetyMode.ExecutionAndPublication);
+
+    private static readonly Lazy<IRawGrammar> CalcGrammar =
+        new(BuildCalcGrammar, LazyThreadSafetyMode.ExecutionAndPublication);
+
+    public FmLanguageRegistryOptions(RegistryOptions inner)
+    {
+        _inner = inner;
+    }
+
+    public IRawTheme GetDefaultTheme() => _inner.GetDefaultTheme();
+
+    public IRawTheme GetTheme(string scopeName) => _inner.GetTheme(scopeName);
+
+    public ICollection<string> GetInjections(string scopeName) => _inner.GetInjections(scopeName);
+
+    public IRawGrammar GetGrammar(string scopeName) => scopeName switch
+    {
+        ScriptScopeName => ScriptGrammar.Value,
+        CalcScopeName => CalcGrammar.Value,
+        _ => _inner.GetGrammar(scopeName),
+    };
+
+    private static IRawGrammar LoadEmbeddedScriptGrammar()
+    {
+        var assembly = Assembly.GetExecutingAssembly();
+        var resourceName = assembly.GetManifestResourceNames()
+            .FirstOrDefault(n => n.EndsWith("fmscript.tmLanguage.json", StringComparison.Ordinal))
+            ?? throw new InvalidOperationException("Embedded fmscript grammar resource not found.");
+
+        using var stream = assembly.GetManifestResourceStream(resourceName)!;
+        using var reader = new StreamReader(stream);
+        return GrammarReader.ReadGrammarSync(reader);
+    }
+
+    private static IRawGrammar BuildCalcGrammar()
+    {
+        var bytes = System.Text.Encoding.UTF8.GetBytes(FmCalcGrammarBuilder.Build());
+        using var stream = new MemoryStream(bytes);
+        using var reader = new StreamReader(stream);
+        return GrammarReader.ReadGrammarSync(reader);
+    }
+}
diff --git a/src/SharpFM/Scripting/Editor/FmScriptCompletionData.cs b/src/SharpFM/Scripting/Editor/FmScriptCompletionData.cs
index 6853a6d..69dd7f4 100644
--- a/src/SharpFM/Scripting/Editor/FmScriptCompletionData.cs
+++ b/src/SharpFM/Scripting/Editor/FmScriptCompletionData.cs
@@ -1,17 +1,20 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.RegularExpressions;
-using Avalonia.Controls;
 using Avalonia.Media;
+using AvaloniaEdit.CodeCompletion;
 using AvaloniaEdit.Document;
 using AvaloniaEdit.Editing;
-using AvaloniaEdit.CodeCompletion;
+using AvaloniaEdit.Snippets;
 
 namespace SharpFM.Scripting.Editor;
 
 [ExcludeFromCodeCoverage]
 public class FmScriptCompletionData : ICompletionData
 {
+    private static readonly Regex PlaceholderRegex =
+        new(@"\$\{(\d+):([^}]*)\}|\$0", RegexOptions.Compiled);
+
     private readonly string? _snippet;
 
     public FmScriptCompletionData(string text, string? description = null,
@@ -25,81 +28,75 @@ public FmScriptCompletionData(string text, string? description = null,
 
     public IImage? Image => null;
     public string Text { get; }
-    public object Content => new TextBlock { Text = Text };
+    // Return the bare string. ContentPresenter wraps it in a TextBlock
+    // automatically and that wrapper is owned by exactly one parent, so
+    // unlike a cached Control instance there's no "already has a visual
+    // parent" failure when the completion window reopens or virtualises.
+    public object Content => Text;
     public object Description { get; }
     public double Priority { get; }
 
     public void Complete(TextArea textArea, ISegment completionSegment, EventArgs insertionRequestEventArgs)
     {
-        if (_snippet != null)
-        {
-            // Convert Monaco snippet syntax to plain text with first placeholder selected
-            // ${1:placeholder} → placeholder (selected), ${2:text} → text, $0 removed
-            var (plainText, selectStart, selectLength) = ConvertSnippet(_snippet);
-            textArea.Document.Replace(completionSegment, plainText);
-
-            if (selectStart >= 0 && selectLength > 0)
-            {
-                var offset = completionSegment.Offset + selectStart;
-                textArea.Caret.Offset = offset;
-                textArea.Selection = Selection.Create(textArea, offset, offset + selectLength);
-            }
-        }
-        else
+        if (_snippet == null)
         {
             textArea.Document.Replace(completionSegment, Text);
+            return;
         }
+
+        // Use AvaloniaEdit's snippet engine for the insert — that gives us
+        // per-placeholder selection plus Tab-through navigation across all
+        // ${N:...} stops natively. Replacing the segment with empty first
+        // positions the caret where the snippet should expand.
+        var snippet = ParseMonacoSnippet(_snippet);
+        textArea.Document.Replace(completionSegment, "");
+        textArea.Caret.Offset = completionSegment.Offset;
+        snippet.Insert(textArea);
     }
 
     /// <summary>
-    /// Convert Monaco snippet syntax to plain text + first placeholder selection info.
+    /// Convert a Monaco-style snippet (<c>${N:placeholder}</c> / <c>$0</c>)
+    /// into an AvaloniaEdit <see cref="Snippet"/>. Each <c>${N:..}</c>
+    /// becomes a <see cref="SnippetReplaceableTextElement"/> — the engine
+    /// hooks Tab to advance through them. <c>$0</c> becomes a
+    /// <see cref="SnippetCaretElement"/> marking where the caret lands
+    /// after the user finishes the last replaceable.
     /// </summary>
-    private static (string Text, int SelectStart, int SelectLength) ConvertSnippet(string snippet)
+    private static Snippet ParseMonacoSnippet(string template)
     {
-        var selectStart = -1;
-        var selectLength = 0;
-
-        // Remove $0 (final cursor position marker)
-        var text = snippet.Replace("$0", "");
-
-        // Replace ${N:placeholder} with just the placeholder text
-        // Track the first placeholder (${1:...}) for selection
-        text = Regex.Replace(text, @"\$\{(\d+):([^}]*)\}", match =>
+        var snippet = new Snippet();
+        int pos = 0;
+        foreach (Match m in PlaceholderRegex.Matches(template))
         {
-            var index = int.Parse(match.Groups[1].Value);
-            var placeholder = match.Groups[2].Value;
-
-            if (index == 1 && selectStart < 0)
+            if (m.Index > pos)
             {
-                // Calculate position in the output string up to this point
-                selectStart = match.Index;
-                // Adjust for previous replacements — we need the position in the final string
-                selectLength = placeholder.Length;
+                snippet.Elements.Add(new SnippetTextElement
+                {
+                    Text = Unescape(template.Substring(pos, m.Index - pos)),
+                });
             }
-
-            return placeholder;
-        });
-
-        // Recalculate selectStart since Regex.Replace processes sequentially
-        // but match.Index is from the original string. Do it properly:
-        if (selectStart >= 0)
-        {
-            var firstPlaceholder = Regex.Match(snippet, @"\$\{1:([^}]*)\}");
-            if (firstPlaceholder.Success)
+            if (m.Value == "$0")
             {
-                // Count the plain text before the first placeholder
-                var beforeSnippet = snippet.Substring(0, firstPlaceholder.Index);
-                // Remove any snippet markers that come before it
-                var beforePlain = Regex.Replace(beforeSnippet, @"\$\{\d+:([^}]*)\}", "$1")
-                    .Replace("$0", "");
-                selectStart = beforePlain.Length;
-                selectLength = firstPlaceholder.Groups[1].Value.Length;
+                snippet.Elements.Add(new SnippetCaretElement());
             }
+            else
+            {
+                snippet.Elements.Add(new SnippetReplaceableTextElement
+                {
+                    Text = m.Groups[2].Value,
+                });
+            }
+            pos = m.Index + m.Length;
         }
-
-        // Clean up backslash escapes (e.g., \$ → $) and trailing whitespace
-        text = text.Replace("\\$", "$").TrimEnd('\t', '\n', '\r');
-
-        return (text, selectStart, selectLength);
+        if (pos < template.Length)
+        {
+            snippet.Elements.Add(new SnippetTextElement
+            {
+                Text = Unescape(template.Substring(pos)),
+            });
+        }
+        return snippet;
     }
+
+    private static string Unescape(string s) => s.Replace("\\$", "$");
 }
diff --git a/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs b/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
index 68b7000..b43ffa1 100644
--- a/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
+++ b/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
@@ -11,6 +11,21 @@ public enum CompletionContext
     StepName,
     ParamLabel,
     ParamValue,
+    /// <summary>
+    /// Caret is inside <c>[ ... ]</c> on a freeform value position — the
+    /// calculation provider is supplying functions, control forms,
+    /// constants, etc. Anchored at the identifier prefix.
+    /// </summary>
+    CalcExpression,
+    /// <summary>
+    /// Same as <see cref="CalcExpression"/> but the calc provider matched
+    /// a <see cref="FmCalcCompletionProvider"/> <c>FunctionParam</c>
+    /// context — i.e. enum keywords for the current arg
+    /// (<c>Get(...)</c>, <c>JSONSetElement</c>'s <c>type</c>, etc.).
+    /// Distinguished so the controller can pop on <c>(</c> and <c>;</c>
+    /// triggers without spamming bare identifier lists.
+    /// </summary>
+    CalcParamValue,
     None,
 }
 
@@ -49,6 +64,17 @@ public static (CompletionContext Context, IList<ICompletionData> Items) GetCompl
             return (CompletionContext.StepName, items);
         }
 
+        // Inside an unmatched `(...)` the `;` separators belong to that
+        // call, not to the step's bracket-param list. Hand off to the calc
+        // provider before we try to slice currentSegment on flat `;` —
+        // otherwise the script logic mis-attributes the call's args to
+        // step params and we never reach the labeled-value fallback.
+        if (FmCalcCompletionProvider.DetectEnclosingCall(lineText, caretColumn) != null)
+        {
+            var deferredEarly = DeferToCalc(lineText, caretColumn);
+            if (deferredEarly.Items.Count > 0) return deferredEarly;
+        }
+
         var afterStepName = forLookup.Substring(stepName.Length);
         var lastSemicolon = afterStepName.LastIndexOf(';');
         var currentSegment = lastSemicolon >= 0
@@ -67,6 +93,14 @@ public static (CompletionContext Context, IList<ICompletionData> Items) GetCompl
                 var items = GetParamValueCompletions(matchingParam);
                 if (items.Count > 0)
                     return (CompletionContext.ParamValue, items);
+
+                // Param exists but has no enum values — the user is typing
+                // a freeform calculation expression (e.g. `Value: Length(`,
+                // `Value: $myVar`, `Value: Get(AccountName)`). Hand off to
+                // the calc provider so functions, control forms, constants
+                // and per-arg keywords all light up here too.
+                var deferred = DeferToCalc(lineText, caretColumn);
+                if (deferred.Items.Count > 0) return deferred;
             }
         }
 
@@ -113,12 +147,20 @@ private static (string Name, StepMetadata? Metadata) FindStepName(string text)
         return bestMatch;
     }
 
-    private static IList<ICompletionData> GetStepNameCompletions(string prefix)
+    /// <summary>
+    /// Every step-name completion, built once at type initialisation. The
+    /// step registry is immutable after startup, so this list is reused
+    /// across every script editor — per-keystroke work is just a
+    /// prefix-filtered copy of references. Mirrors
+    /// <see cref="FmCalcCompletionProvider.AllBuiltinIdentifierCompletions"/>.
+    /// </summary>
+    public static IReadOnlyList<ICompletionData> AllStepNameCompletions { get; } =
+        BuildAllStepNameCompletions();
+
+    private static IReadOnlyList<ICompletionData> BuildAllStepNameCompletions()
     {
         return StepRegistry.All
-            .Where(s => s.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) ||
-                        string.IsNullOrEmpty(prefix))
-            .OrderBy(s => s.Name)
+            .OrderBy(s => s.Name, StringComparer.Ordinal)
             .Select(s =>
             {
                 var desc = s.Category;
@@ -131,6 +173,20 @@ private static IList<ICompletionData> GetStepNameCompletions(string prefix)
             .ToList();
     }
 
+    private static IList<ICompletionData> GetStepNameCompletions(string prefix)
+    {
+        var items = new List<ICompletionData>();
+        foreach (var item in AllStepNameCompletions)
+        {
+            if (string.IsNullOrEmpty(prefix) ||
+                item.Text.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                items.Add(item);
+            }
+        }
+        return items;
+    }
+
     /// <summary>
     /// Build a Monaco-style snippet (<c>${N:placeholder}</c> tab-stops)
     /// from the step's <see cref="ParamMetadata"/> so that accepting a
@@ -237,4 +293,24 @@ private static IList<ICompletionData> GetPositionalValueCompletions(
 
         return items;
     }
+
+    /// <summary>
+    /// Hand off completion to the calc provider for the same line/caret
+    /// position. Returns a script-side context so the controller can
+    /// distinguish identifier-prefix completions (anchored at the prefix)
+    /// from function-param keyword completions (whose triggers also
+    /// include <c>(</c> and <c>;</c>).
+    /// </summary>
+    private static (CompletionContext Context, IList<ICompletionData> Items) DeferToCalc(
+        string lineText, int caretColumn)
+    {
+        var (calcCtx, calcItems) = FmCalcCompletionProvider.GetCompletions(lineText, caretColumn);
+        if (calcCtx == CalcCompletionContext.None || calcItems.Count == 0)
+            return (CompletionContext.None, Array.Empty<ICompletionData>());
+
+        var scriptCtx = calcCtx == CalcCompletionContext.FunctionParam
+            ? CompletionContext.CalcParamValue
+            : CompletionContext.CalcExpression;
+        return (scriptCtx, calcItems);
+    }
 }
diff --git a/src/SharpFM/Scripting/Editor/FmScriptRegistryOptions.cs b/src/SharpFM/Scripting/Editor/FmScriptRegistryOptions.cs
deleted file mode 100644
index 9e057ec..0000000
--- a/src/SharpFM/Scripting/Editor/FmScriptRegistryOptions.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Reflection;
-using System.Threading;
-using TextMateSharp.Grammars;
-using TextMateSharp.Internal.Grammars.Reader;
-using TextMateSharp.Internal.Types;
-using TextMateSharp.Registry;
-using TextMateSharp.Themes;
-
-namespace SharpFM.Scripting.Editor;
-
-[ExcludeFromCodeCoverage]
-public class FmScriptRegistryOptions : IRegistryOptions
-{
-    public const string ScopeName = "source.fmscript";
-
-    private readonly RegistryOptions _inner;
-
-    // The embedded .tmLanguage.json is immutable; parsing it is not free. Cache
-    // the parsed grammar once per process so repeated TextMate installs (e.g.
-    // fresh script-editor instances) don't reparse ~KB of JSON each time.
-    private static readonly Lazy<IRawGrammar> CachedGrammar =
-        new(LoadFmScriptGrammar, LazyThreadSafetyMode.ExecutionAndPublication);
-
-    public FmScriptRegistryOptions(RegistryOptions inner)
-    {
-        _inner = inner;
-    }
-
-    public IRawTheme GetDefaultTheme() => _inner.GetDefaultTheme();
-
-    public IRawTheme GetTheme(string scopeName) => _inner.GetTheme(scopeName);
-
-    public ICollection<string> GetInjections(string scopeName) => _inner.GetInjections(scopeName);
-
-    public IRawGrammar GetGrammar(string scopeName)
-    {
-        if (scopeName == ScopeName)
-            return CachedGrammar.Value;
-
-        return _inner.GetGrammar(scopeName);
-    }
-
-    private static IRawGrammar LoadFmScriptGrammar()
-    {
-        var assembly = Assembly.GetExecutingAssembly();
-        var resourceName = assembly.GetManifestResourceNames()
-            [System.Array.FindIndex(assembly.GetManifestResourceNames(),
-                n => n.EndsWith("fmscript.tmLanguage.json"))];
-
-        using var stream = assembly.GetManifestResourceStream(resourceName)!;
-        using var reader = new StreamReader(stream);
-        return GrammarReader.ReadGrammarSync(reader);
-    }
-}
diff --git a/src/SharpFM/Scripting/Editor/ScriptEditorController.cs b/src/SharpFM/Scripting/Editor/ScriptEditorController.cs
index 46085bb..015a0e6 100644
--- a/src/SharpFM/Scripting/Editor/ScriptEditorController.cs
+++ b/src/SharpFM/Scripting/Editor/ScriptEditorController.cs
@@ -150,23 +150,68 @@ private void OnPointerMoved(object? sender, PointerEventArgs e)
         }
     }
 
+    /// <summary>
+    /// Minimum identifier-prefix length before the script editor pops the
+    /// completion window automatically. Two characters is enough for the
+    /// list to narrow meaningfully (Set, Sho, Lay…) and keeps the popup
+    /// out of the way on the first keystroke when the user often isn't
+    /// looking for a step name suggestion.
+    /// </summary>
+    private const int AutoCompleteMinPrefix = 2;
+
     private void OnTextEntered(object? sender, TextInputEventArgs e)
     {
         if (_completionWindow != null) return;
-
-        TryShowCompletions();
+        if (string.IsNullOrEmpty(e.Text)) return;
+
+        var ch = e.Text[0];
+        var isIdentifierTrigger = IsTriggerChar(ch);
+        // Argument-boundary characters: ( and ; should pop the menu *only*
+        // when we end up in a CalcParamValue context (e.g. Get( →
+        // selectors, JSONSetElement(j;k;v; → JSON types). Without this,
+        // every ( and ; would spam the window with the full identifier
+        // catalog. Mirrors the calculation editor's gating logic.
+        var isArgBoundary = ch == '(' || ch == ';';
+        if (!isIdentifierTrigger && !isArgBoundary) return;
+
+        TryShowCompletions(isArgBoundary);
     }
 
-    private void TryShowCompletions()
+    private static bool IsTriggerChar(char c) =>
+        char.IsLetter(c) || c == '_';
+
+    private static bool IsIdentifierChar(char c) =>
+        char.IsLetterOrDigit(c) || c == '_';
+
+    private void TryShowCompletions(bool isArgBoundaryTrigger = false)
     {
         var caret = _editor.TextArea.Caret;
         var line = _editor.Document.GetLineByNumber(caret.Line);
         var lineText = _editor.Document.GetText(line.Offset, line.Length);
         var col = caret.Column - 1;
 
+        // Walk back over the identifier prefix immediately before the
+        // caret. We need this in two places: the min-prefix gate below
+        // and the StartOffset anchor for calc-context completions.
+        var prefixStart = col;
+        while (prefixStart > 0 && IsIdentifierChar(lineText[prefixStart - 1]))
+            prefixStart--;
+
+        // Require AutoCompleteMinPrefix consecutive identifier characters
+        // before showing — skips the empty-prefix popup on the first
+        // keystroke. Skipped for ( / ; triggers because those are
+        // argument-boundary characters where the prefix is intentionally
+        // empty (e.g. `Get(` should pop the selector list immediately).
+        if (!isArgBoundaryTrigger && col - prefixStart < AutoCompleteMinPrefix) return;
+
         var (context, items) = FmScriptCompletionProvider.GetCompletions(lineText, col);
         if (context == CompletionContext.None || items.Count == 0) return;
 
+        // Only commit to opening the window on ( or ; triggers when the
+        // result is a function-param keyword list — anything else and the
+        // user just typed a separator and doesn't want a popup.
+        if (isArgBoundaryTrigger && context != CompletionContext.CalcParamValue) return;
+
         _completionWindow = new CompletionWindow(_editor.TextArea);
 
         if (context == CompletionContext.StepName)
@@ -178,6 +223,14 @@ private void TryShowCompletions()
         {
             _completionWindow.StartOffset = _editor.CaretOffset;
         }
+        else if (context == CompletionContext.CalcExpression
+                 || context == CompletionContext.CalcParamValue)
+        {
+            // Anchor at the start of the identifier prefix so accepting
+            // an item replaces the partial prefix rather than appending
+            // after it.
+            _completionWindow.StartOffset = line.Offset + prefixStart;
+        }
 
         foreach (var item in items)
             _completionWindow.CompletionList.CompletionData.Add(item);
diff --git a/tests/SharpFM.Tests/Scripting/CalcCompletionContextProviderTests.cs b/tests/SharpFM.Tests/Scripting/CalcCompletionContextProviderTests.cs
new file mode 100644
index 0000000..ef58b10
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/CalcCompletionContextProviderTests.cs
@@ -0,0 +1,67 @@
+using SharpFM.Model.Schema;
+using SharpFM.Scripting.Editor;
+using Xunit;
+
+namespace SharpFM.Tests.ScriptConverter;
+
+public class CalcCompletionContextProviderTests
+{
+    [Fact]
+    public void GetVariablesInScope_ReturnsAllUniqueDollarTokens()
+    {
+        var doc = "Let([$x = 1; $y = $x + 2]; $$global + $x)";
+        var provider = new CalcCompletionContextProvider(() => doc, currentTable: null);
+        var vars = provider.GetVariablesInScope("", 0);
+        Assert.Contains("x", vars);
+        Assert.Contains("y", vars);
+        Assert.Contains("global", vars);
+        // No duplicates — $x appears three times in source
+        Assert.Equal(3, vars.Count);
+    }
+
+    [Fact]
+    public void GetVariablesInScope_EmptyDocument_ReturnsEmpty()
+    {
+        var provider = new CalcCompletionContextProvider(() => "", currentTable: null);
+        Assert.Empty(provider.GetVariablesInScope("", 0));
+    }
+
+    [Fact]
+    public void GetFieldsForTable_MatchingTableName_ReturnsFieldNames()
+    {
+        var table = new FmTable("Customer");
+        table.AddField(new FmField { Name = "Name", Id = 1 });
+        table.AddField(new FmField { Name = "Email", Id = 2 });
+
+        var provider = new CalcCompletionContextProvider(() => "", currentTable: table);
+        var fields = provider.GetFieldsForTable("Customer");
+        Assert.Equal(new[] { "Name", "Email" }, fields);
+    }
+
+    [Fact]
+    public void GetFieldsForTable_DifferentTableName_ReturnsEmpty()
+    {
+        var table = new FmTable("Customer");
+        table.AddField(new FmField { Name = "Name", Id = 1 });
+
+        var provider = new CalcCompletionContextProvider(() => "", currentTable: table);
+        Assert.Empty(provider.GetFieldsForTable("Invoice"));
+    }
+
+    [Fact]
+    public void GetFieldsForTable_NoTable_ReturnsEmpty()
+    {
+        var provider = new CalcCompletionContextProvider(() => "", currentTable: null);
+        Assert.Empty(provider.GetFieldsForTable("Anything"));
+    }
+
+    [Fact]
+    public void GetTableNames_ReturnsEmpty()
+    {
+        // Until a schema container exists, table enumeration is unavailable
+        // — the provider returns empty rather than guess.
+        var table = new FmTable("Customer");
+        var provider = new CalcCompletionContextProvider(() => "", currentTable: table);
+        Assert.Empty(provider.GetTableNames());
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs b/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
index ff05732..eb1c282 100644
--- a/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
+++ b/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
@@ -147,4 +147,50 @@ public void StepNameCompletion_ZeroParamStep_InsertsBareName()
 
         Assert.Equal("Beep", snippet);
     }
+
+    [Fact]
+    public void SetVariable_AfterValueColon_DefersToCalcCompletion()
+    {
+        // Set Variable's Value param is freeform calc — script provider
+        // hands off to FmCalcCompletionProvider so the user gets functions,
+        // control forms, constants etc. mid-bracket.
+        var line = "Set Variable [ $x ; Value: Le";
+        var (context, items) = FmScriptCompletionProvider.GetCompletions(line, line.Length);
+        Assert.Equal(CompletionContext.CalcExpression, context);
+        Assert.Contains(items, i => i.Text == "Length");
+        Assert.Contains(items, i => i.Text == "Let");
+        // Sanity: param labels (Repetition) should not bleed into calc results.
+        Assert.DoesNotContain(items, i => i.Text == "Repetition: ");
+    }
+
+    [Fact]
+    public void SetVariable_GetCallInsideValue_DefersToFunctionParam()
+    {
+        // Inside Get(... and the script provider should recognise the calc
+        // sub-context as FunctionParam, surfacing Get's selector keywords.
+        var line = "Set Variable [ $x ; Value: Get(";
+        var (context, items) = FmScriptCompletionProvider.GetCompletions(line, line.Length);
+        Assert.Equal(CompletionContext.CalcParamValue, context);
+        Assert.Contains(items, i => i.Text == "AccountName");
+        Assert.Contains(items, i => i.Text == "CurrentDate");
+    }
+
+    [Fact]
+    public void SetVariable_JsonSetElementType_DefersToFunctionParam()
+    {
+        var line = "Set Variable [ $x ; Value: JSONSetElement(j;\"k\";v;";
+        var (context, items) = FmScriptCompletionProvider.GetCompletions(line, line.Length);
+        Assert.Equal(CompletionContext.CalcParamValue, context);
+        Assert.Contains(items, i => i.Text == "JSONString");
+    }
+
+    [Fact]
+    public void SetVariable_BeforeAnyColon_StillOffersLabelCompletions()
+    {
+        // Calc deferral should fire only after a labeled colon. Pre-colon
+        // mid-bracket positions keep the existing label/positional logic.
+        var line = "Set Variable [ ";
+        var (context, _) = FmScriptCompletionProvider.GetCompletions(line, line.Length);
+        Assert.Equal(CompletionContext.ParamLabel, context);
+    }
 }
diff --git a/tests/SharpFM.Tests/Scripting/FmCalcCatalogTests.cs b/tests/SharpFM.Tests/Scripting/FmCalcCatalogTests.cs
new file mode 100644
index 0000000..1af4a0f
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/FmCalcCatalogTests.cs
@@ -0,0 +1,59 @@
+using System.Linq;
+using SharpFM.Model.Scripting.Calc;
+using Xunit;
+
+namespace SharpFM.Tests.ScriptConverter;
+
+/// <summary>
+/// Sanity checks on the calculation catalog and the grammar built from it.
+/// The catalog is the single source of truth for the grammar and (next) the
+/// completion provider, so duplicates or empty groups would silently
+/// degrade both consumers.
+/// </summary>
+public class FmCalcCatalogTests
+{
+    [Fact]
+    public void Catalog_HasNoDuplicateFunctionNames()
+    {
+        var dupes = FmCalcCatalog.Functions
+            .GroupBy(f => f.Name)
+            .Where(g => g.Count() > 1)
+            .Select(g => g.Key)
+            .ToList();
+        Assert.Empty(dupes);
+    }
+
+    [Fact]
+    public void Catalog_EveryFunctionHasSignatureAndDescription()
+    {
+        Assert.All(FmCalcCatalog.Functions, f =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(f.Signature), $"{f.Name} signature");
+            Assert.False(string.IsNullOrWhiteSpace(f.Description), $"{f.Name} description");
+        });
+    }
+
+    [Fact]
+    public void Catalog_ControlFormSnippetsContainTabStops()
+    {
+        Assert.All(FmCalcCatalog.ControlForms, c =>
+            Assert.Contains("${1:", c.Snippet));
+    }
+
+    [Fact]
+    public void GrammarBuilder_ProducesValidJson()
+    {
+        var json = FmCalcGrammarBuilder.Build();
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.Equal("source.fmcalc", parsed.RootElement.GetProperty("scopeName").GetString());
+    }
+
+    [Fact]
+    public void GrammarBuilder_IncludesEveryFunctionNameInItsCategoryRegex()
+    {
+        var json = FmCalcGrammarBuilder.Build();
+        // Cheap check: every name should appear at least once in the JSON.
+        // Misses would mean a function silently dropped out of the grammar.
+        Assert.All(FmCalcCatalog.Functions, f => Assert.Contains(f.Name, json));
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/FmCalcCompletionProviderTests.cs b/tests/SharpFM.Tests/Scripting/FmCalcCompletionProviderTests.cs
new file mode 100644
index 0000000..ceb4add
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/FmCalcCompletionProviderTests.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SharpFM.Scripting.Editor;
+using Xunit;
+
+namespace SharpFM.Tests.ScriptConverter;
+
+public class FmCalcCompletionProviderTests
+{
+    [Fact]
+    public void EmptyInput_ReturnsAllIdentifierCompletions()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("", 0);
+        Assert.Equal(CalcCompletionContext.Identifier, ctx);
+        Assert.Contains(items, i => i.Text == "Length");
+        Assert.Contains(items, i => i.Text == "Let");
+        Assert.Contains(items, i => i.Text == "True");
+    }
+
+    [Fact]
+    public void Prefix_FiltersItemsCaseInsensitively()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("Le", 2);
+        Assert.Equal(CalcCompletionContext.Identifier, ctx);
+        var names = items.Select(i => i.Text).ToList();
+        Assert.Contains("Length", names);
+        Assert.Contains("Left", names);
+        Assert.Contains("Let", names);
+        Assert.DoesNotContain("Sum", names);
+    }
+
+    [Fact]
+    public void Prefix_LowerCase_StillMatchesCapitalizedFunctions()
+    {
+        var (_, items) = FmCalcCompletionProvider.GetCompletions("len", 3);
+        Assert.Contains(items, i => i.Text == "Length");
+    }
+
+    [Fact]
+    public void ControlForm_DescriptionIncludesSignature()
+    {
+        var (_, items) = FmCalcCompletionProvider.GetCompletions("Let", 3);
+        var let = items.First(i => i.Text == "Let");
+        var desc = let.Description.ToString()!;
+        Assert.Contains("Let([var = expr", desc);
+    }
+
+    [Fact]
+    public void Function_DescriptionIncludesSignature()
+    {
+        var (_, items) = FmCalcCompletionProvider.GetCompletions("Length", 6);
+        var fn = items.First(i => i.Text == "Length");
+        Assert.Contains("Length(text)", fn.Description.ToString()!);
+    }
+
+    [Fact]
+    public void InsideString_ReturnsNoCompletions()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("\"Le", 3);
+        Assert.Equal(CalcCompletionContext.String, ctx);
+        Assert.Empty(items);
+    }
+
+    [Fact]
+    public void AfterClosingQuote_ReturnsCompletionsAgain()
+    {
+        var (ctx, _) = FmCalcCompletionProvider.GetCompletions("\"text\" & Le", 11);
+        Assert.Equal(CalcCompletionContext.Identifier, ctx);
+    }
+
+    [Fact]
+    public void EscapedQuoteInString_StillTreatedAsInside()
+    {
+        var (ctx, _) = FmCalcCompletionProvider.GetCompletions("\"a\\\"b Le", 8);
+        Assert.Equal(CalcCompletionContext.String, ctx);
+    }
+
+    [Fact]
+    public void InsideLineComment_ReturnsNoCompletions()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("// Le", 5);
+        Assert.Equal(CalcCompletionContext.Comment, ctx);
+        Assert.Empty(items);
+    }
+
+    [Fact]
+    public void Variable_AfterDollarSign_ReturnsVariableContext()
+    {
+        var provider = new StubContext(variables: new[] { "myLocal", "counter" });
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("$my", 3, provider);
+        Assert.Equal(CalcCompletionContext.Variable, ctx);
+        Assert.Contains(items, i => i.Text == "myLocal");
+        Assert.DoesNotContain(items, i => i.Text == "counter");
+    }
+
+    [Fact]
+    public void Variable_AfterDoubleDollarSign_ReturnsVariableContext()
+    {
+        var provider = new StubContext(variables: new[] { "globalA", "globalB" });
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("$$g", 3, provider);
+        Assert.Equal(CalcCompletionContext.Variable, ctx);
+        Assert.Equal(2, items.Count);
+    }
+
+    [Fact]
+    public void Variable_NoContextProvider_ReturnsEmptyVariableList()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("$my", 3);
+        Assert.Equal(CalcCompletionContext.Variable, ctx);
+        Assert.Empty(items);
+    }
+
+    [Fact]
+    public void FieldRef_AfterDoubleColon_SuggestsFieldsForTable()
+    {
+        var provider = new StubContext(fields: new() { ["Customer"] = new[] { "Name", "Email" } });
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("Customer::N", 11, provider);
+        Assert.Equal(CalcCompletionContext.FieldRef, ctx);
+        Assert.Contains(items, i => i.Text == "Name");
+        Assert.DoesNotContain(items, i => i.Text == "Email");
+    }
+
+    [Fact]
+    public void TableNames_FromContext_AppearInIdentifierCompletions()
+    {
+        var provider = new StubContext(tables: new[] { "Customer", "Invoice" });
+        var (_, items) = FmCalcCompletionProvider.GetCompletions("Cus", 3, provider);
+        Assert.Contains(items, i => i.Text == "Customer");
+    }
+
+    [Fact]
+    public void GetCall_EmptyArg_SuggestsAllSelectorKeywords()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("Get(", 4);
+        Assert.Equal(CalcCompletionContext.FunctionParam, ctx);
+        Assert.Contains(items, i => i.Text == "AccountName");
+        Assert.Contains(items, i => i.Text == "CurrentDate");
+        Assert.Contains(items, i => i.Text == "SystemPlatform");
+    }
+
+    [Fact]
+    public void GetCall_PartialPrefix_FiltersKeywords()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("Get(Acc", 7);
+        Assert.Equal(CalcCompletionContext.FunctionParam, ctx);
+        var names = items.Select(i => i.Text).ToList();
+        Assert.Contains("AccountName", names);
+        Assert.Contains("AccountPrivilegeSetName", names);
+        Assert.DoesNotContain("CurrentDate", names);
+    }
+
+    [Fact]
+    public void GetCall_KeywordTooltipCarriesDescription()
+    {
+        var (_, items) = FmCalcCompletionProvider.GetCompletions("Get(AccountName", 15);
+        var item = items.First(i => i.Text == "AccountName");
+        Assert.Contains("account", item.Description.ToString()!, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void JsonSetElement_LastArg_SuggestsJsonTypes()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("JSONSetElement(j;\"k\";v;", 23);
+        Assert.Equal(CalcCompletionContext.FunctionParam, ctx);
+        Assert.Contains(items, i => i.Text == "JSONString");
+        Assert.Contains(items, i => i.Text == "JSONNumber");
+    }
+
+    [Fact]
+    public void JsonSetElement_EarlierArg_DoesNotSuggestJsonTypes()
+    {
+        // Caret is on arg 0 (json) — no enum values defined for that param.
+        var (ctx, _) = FmCalcCompletionProvider.GetCompletions("JSONSetElement(", 15);
+        Assert.NotEqual(CalcCompletionContext.FunctionParam, ctx);
+    }
+
+    [Fact]
+    public void TextStyleAdd_SecondArg_SuggestsStyleKeywords()
+    {
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("TextStyleAdd(text;", 18);
+        Assert.Equal(CalcCompletionContext.FunctionParam, ctx);
+        Assert.Contains(items, i => i.Text == "Bold");
+        Assert.Contains(items, i => i.Text == "Italic");
+    }
+
+    [Fact]
+    public void OpenParenInsideString_DoesNotTriggerFunctionParamContext()
+    {
+        var (ctx, _) = FmCalcCompletionProvider.GetCompletions("\"Get(\" & A", 10);
+        Assert.NotEqual(CalcCompletionContext.FunctionParam, ctx);
+    }
+
+    [Fact]
+    public void NestedCall_SuggestsForInnermostCall()
+    {
+        // Outer is JSONSetElement, inner is Get — caret is inside Get, so
+        // we should see Get's selector keywords, not JSON types.
+        var (ctx, items) = FmCalcCompletionProvider.GetCompletions("JSONSetElement(j;k;Get(Acc", 26);
+        Assert.Equal(CalcCompletionContext.FunctionParam, ctx);
+        Assert.Contains(items, i => i.Text == "AccountName");
+        Assert.DoesNotContain(items, i => i.Text == "JSONString");
+    }
+
+    [Fact]
+    public void DetectEnclosingCall_OutsideAnyCall_ReturnsNull()
+    {
+        Assert.Null(FmCalcCompletionProvider.DetectEnclosingCall("Length(x) + 1", 13));
+    }
+
+    [Fact]
+    public void DetectEnclosingCall_AfterClosingParen_ReturnsNull()
+    {
+        Assert.Null(FmCalcCompletionProvider.DetectEnclosingCall("Get(x)", 6));
+    }
+
+    [Fact]
+    public void DetectEnclosingCall_CountsArgsCorrectly()
+    {
+        var r = FmCalcCompletionProvider.DetectEnclosingCall("F(a;b;c", 7);
+        Assert.NotNull(r);
+        Assert.Equal("F", r.Value.FunctionName);
+        Assert.Equal(2, r.Value.ArgIndex);
+    }
+
+    [Fact]
+    public void DetectEnclosingCall_IgnoresSemicolonsInNestedCalls()
+    {
+        var r = FmCalcCompletionProvider.DetectEnclosingCall("F(G(a;b);c", 10);
+        Assert.NotNull(r);
+        Assert.Equal("F", r.Value.FunctionName);
+        Assert.Equal(1, r.Value.ArgIndex);
+    }
+
+    private sealed class StubContext : ICalcCompletionContextProvider
+    {
+        private readonly IReadOnlyList<string> _variables;
+        private readonly IReadOnlyList<string> _tables;
+        private readonly Dictionary<string, IReadOnlyList<string>> _fields;
+
+        public StubContext(
+            IReadOnlyList<string>? variables = null,
+            IReadOnlyList<string>? tables = null,
+            Dictionary<string, string[]>? fields = null)
+        {
+            _variables = variables ?? System.Array.Empty<string>();
+            _tables = tables ?? System.Array.Empty<string>();
+            _fields = fields?.ToDictionary(
+                kv => kv.Key,
+                kv => (IReadOnlyList<string>)kv.Value)
+                ?? new Dictionary<string, IReadOnlyList<string>>();
+        }
+
+        public IReadOnlyList<string> GetVariablesInScope(string lineText, int offset) => _variables;
+        public IReadOnlyList<string> GetTableNames() => _tables;
+        public IReadOnlyList<string> GetFieldsForTable(string tableName) =>
+            _fields.TryGetValue(tableName, out var fs) ? fs : System.Array.Empty<string>();
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/FmCalcSignatureParserTests.cs b/tests/SharpFM.Tests/Scripting/FmCalcSignatureParserTests.cs
new file mode 100644
index 0000000..81f1b71
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/FmCalcSignatureParserTests.cs
@@ -0,0 +1,96 @@
+using System.Linq;
+using SharpFM.Model.Scripting.Calc;
+using Xunit;
+
+namespace SharpFM.Tests.ScriptConverter;
+
+public class FmCalcSignatureParserTests
+{
+    [Fact]
+    public void SinglePositional_ParsesOneParam()
+    {
+        var ps = FmCalcSignatureParser.ParseParams("Length(text)");
+        Assert.Equal(new[] { "text" }, ps.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void MultiplePositional_ParsesEach()
+    {
+        var ps = FmCalcSignatureParser.ParseParams("Replace(text; start; numberOfCharacters; replacementText)");
+        Assert.Equal(
+            new[] { "text", "start", "numberOfCharacters", "replacementText" },
+            ps.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void VariadicTrailing_StopsAtBrace()
+    {
+        var ps = FmCalcSignatureParser.ParseParams("Average(field {; field...})");
+        Assert.Equal(new[] { "field" }, ps.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void NoParens_ReturnsEmpty()
+    {
+        // E.g. Random — written without parens in the catalog.
+        Assert.Empty(FmCalcSignatureParser.ParseParams("Random"));
+    }
+
+    [Fact]
+    public void EmptyParens_ReturnsEmpty()
+    {
+        Assert.Empty(FmCalcSignatureParser.ParseParams("Foo()"));
+    }
+
+    [Fact]
+    public void TrimsWhitespace()
+    {
+        var ps = FmCalcSignatureParser.ParseParams("Round(  number ;  precision )");
+        Assert.Equal(new[] { "number", "precision" }, ps.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void Catalog_EveryFunctionWithParensInSignature_HasAtLeastOneParam()
+    {
+        // The catalog's Add helper now derives Params from Signature when
+        // none are passed explicitly. This guards against a function whose
+        // signature contains `(...)` but somehow ends up with empty Params.
+        // Skip signatures whose only content is an optional region — e.g.
+        // WindowNames({fileName}) has no required positional params, so 0
+        // is correct.
+        var bad = FmCalcCatalog.Functions
+            .Where(f =>
+            {
+                if (!f.Signature.Contains('(')) return false;
+                if (f.Signature.EndsWith("()")) return false;
+                var open = f.Signature.IndexOf('(');
+                var inner = f.Signature.Substring(open + 1).TrimEnd(')');
+                if (inner.TrimStart().StartsWith("{")) return false;
+                return f.Params.Count == 0;
+            })
+            .Select(f => f.Name)
+            .ToList();
+        Assert.Empty(bad);
+    }
+
+    [Fact]
+    public void Catalog_JsonGetElement_HasJsonAndPathParams()
+    {
+        // JSONGetElement was the user-flagged regression — accepting it
+        // should give tab-stops, which requires Params from the parser.
+        var fn = FmCalcCatalog.Functions.First(f => f.Name == "JSONGetElement");
+        Assert.Equal(new[] { "json", "keyOrIndexOrPath" }, fn.Params.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void Catalog_ExplicitParamsTakePrecedenceOverSignature()
+    {
+        // Get's signature reads "Get(parameter)", but the catalog passes
+        // an explicit param with ValidValues. Verify the explicit one
+        // survived rather than being clobbered by the signature parse.
+        var fn = FmCalcCatalog.Functions.First(f => f.Name == "Get");
+        Assert.Single(fn.Params);
+        Assert.NotNull(fn.Params[0].ValidValues);
+        Assert.Contains(fn.Params[0].ValidValues!, v => v.Name == "AccountName");
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/GrammarTokenizationTests.cs b/tests/SharpFM.Tests/Scripting/GrammarTokenizationTests.cs
new file mode 100644
index 0000000..8e5ec80
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/GrammarTokenizationTests.cs
@@ -0,0 +1,177 @@
+using System.Linq;
+using SharpFM.Scripting.Editor;
+using TextMateSharp.Grammars;
+using TextMateSharp.Registry;
+using Xunit;
+
+namespace SharpFM.Tests.ScriptConverter;
+
+/// <summary>
+/// Loads the embedded FileMaker TextMate grammars through a real TextMateSharp
+/// Registry and asserts representative fixtures tokenize as expected. Guards
+/// against silent regressions from grammar edits, function-list churn, or
+/// cross-grammar include resolution failing.
+/// </summary>
+public class GrammarTokenizationTests
+{
+    private static IGrammar LoadGrammar(string scopeName)
+    {
+        var options = new FmLanguageRegistryOptions(new RegistryOptions((ThemeName)(int)ThemeName.DarkPlus));
+        var registry = new Registry(options);
+        return registry.LoadGrammar(scopeName);
+    }
+
+    private static string[] ScopesAt(IGrammar grammar, string line, int column)
+    {
+        var result = grammar.TokenizeLine(line);
+        var token = result.Tokens.First(t => column >= t.StartIndex && column < t.EndIndex);
+        return token.Scopes.ToArray();
+    }
+
+    private static bool LineHasScope(IGrammar grammar, string line, string scope)
+    {
+        var result = grammar.TokenizeLine(line);
+        return result.Tokens.Any(t => t.Scopes.Any(s => s == scope || s.StartsWith(scope + ".")));
+    }
+
+    [Fact]
+    public void FmCalc_LineComment_IsScopedAsComment()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "// hello", 3), s => s.StartsWith("comment.line"));
+    }
+
+    [Fact]
+    public void FmCalc_BlockComment_IsScopedAsBlockComment()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "/* note */ 1", 4), s => s.StartsWith("comment.block"));
+    }
+
+    [Fact]
+    public void FmCalc_StringWithEscape_HasEscapeScope()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        var line = "\"a\\\"b\"";
+        // Position of the backslash escape (index 2)
+        Assert.Contains(ScopesAt(g, line, 2), s => s.Contains("constant.character.escape"));
+    }
+
+    [Fact]
+    public void FmCalc_NumericLiteral_IsConstantNumeric()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "1.5e3", 0), s => s.StartsWith("constant.numeric"));
+    }
+
+    [Fact]
+    public void FmCalc_LetControlForm_IsKeywordControl()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "Let ( x = 1 ; x )", 0), s => s.StartsWith("keyword.control"));
+    }
+
+    [Fact]
+    public void FmCalc_NestedLet_BothLetTokensAreKeywords()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        var line = "Let([a=1;b=Let([c=2];c)];a+b)";
+        Assert.Contains(ScopesAt(g, line, 0), s => s.StartsWith("keyword.control"));
+        Assert.Contains(ScopesAt(g, line, 11), s => s.StartsWith("keyword.control"));
+    }
+
+    [Fact]
+    public void FmCalc_FieldReference_TablePartIsEntityName()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "Customer::Name", 0), s => s.StartsWith("entity.name.type"));
+        Assert.Contains(ScopesAt(g, "Customer::Name", 10), s => s.StartsWith("variable.other.member"));
+    }
+
+    [Fact]
+    public void FmCalc_DollarVariable_IsVariableScope()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "$myVar + $$global", 0), s => s.StartsWith("variable.other"));
+        Assert.Contains(ScopesAt(g, "$myVar + $$global", 9), s => s.StartsWith("variable.other"));
+    }
+
+    [Fact]
+    public void FmCalc_BuiltinFunction_HasCategoryScope()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "Length ( name )", 0), s => s.Contains("support.function.text"));
+        Assert.Contains(ScopesAt(g, "JSONGetElement ( j ; \"k\" )", 0), s => s.Contains("support.function.json"));
+    }
+
+    [Fact]
+    public void FmCalc_CustomFunction_IsEntityNameFunction()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "MyCustomFn ( 1 )", 0), s => s.StartsWith("entity.name.function"));
+    }
+
+    [Fact]
+    public void FmCalc_BlockComment_SpansMultipleLines()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        var first = g.TokenizeLine("/* opens");
+        Assert.Contains(first.Tokens, t => t.Scopes.Any(s => s.StartsWith("comment.block")));
+        var second = g.TokenizeLine("still inside */", first.RuleStack, System.TimeSpan.MaxValue);
+        Assert.True(LineHasScope(g, "still inside", "comment.block") ||
+                    second.Tokens.Any(t => t.Scopes.Any(s => s.StartsWith("comment.block"))));
+    }
+
+    [Fact]
+    public void FmCalc_BooleanConstants_AreConstantLanguage()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.CalcScopeName);
+        Assert.Contains(ScopesAt(g, "True", 0), s => s.StartsWith("constant.language"));
+        Assert.Contains(ScopesAt(g, "False", 0), s => s.StartsWith("constant.language"));
+        Assert.Contains(ScopesAt(g, "Pi", 0), s => s.StartsWith("constant.language"));
+    }
+
+    [Fact]
+    public void FmScript_StepName_IsEntityNameFunction()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.ScriptScopeName);
+        Assert.Contains(ScopesAt(g, "Set Variable [ $x ; Value: 1 ]", 0), s => s.StartsWith("entity.name.function"));
+    }
+
+    [Fact]
+    public void FmScript_BracketParams_FieldRefUsesScriptScope()
+    {
+        // The script grammar's bracket-params highlight calc fragments
+        // with its own native scopes — it intentionally does NOT include
+        // source.fmcalc, since the embedded grammar's pattern fan-out is
+        // measurably expensive on long scripts. The calc editor still
+        // uses source.fmcalc for full per-category function highlighting.
+        var g = LoadGrammar(FmLanguageRegistryOptions.ScriptScopeName);
+        var line = "Set Field [ Customer::Name ; \"Bob\" ]";
+        Assert.True(LineHasScope(g, line, "entity.name.type.fmscript"));
+        Assert.True(LineHasScope(g, line, "string.quoted.double.fmscript"));
+    }
+
+    [Fact]
+    public void FmScript_BracketParams_FunctionAndVariableUseScriptScope()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.ScriptScopeName);
+        var line = "Set Variable [ $x ; Value: Length ( $name ) ]";
+        Assert.True(LineHasScope(g, line, "support.function.fmscript"));
+        Assert.True(LineHasScope(g, line, "variable.other.fmscript"));
+    }
+
+    [Fact]
+    public void FmScript_ParamLabel_IsScriptScope()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.ScriptScopeName);
+        Assert.True(LineHasScope(g, "Set Variable [ $x ; Value: 1 ]", "support.type.property-name.fmscript"));
+    }
+
+    [Fact]
+    public void FmScript_HashCommentLine_IsScriptComment()
+    {
+        var g = LoadGrammar(FmLanguageRegistryOptions.ScriptScopeName);
+        Assert.True(LineHasScope(g, "# this is a script comment", "comment.line.number-sign.fmscript"));
+    }
+}