feat: defer script-step value completion to calc provider

When the caret sits in a freeform value position inside a step's
bracket params (e.g. Set Variable [ Value: Le... ]) hand completion
off to FmCalcCompletionProvider so the user gets the same functions,
control forms, constants, and per-arg keyword lists as the
calculation editor.

Two new contexts on the script side — CalcExpression (general
identifier completion) and CalcParamValue (function-arg keywords).
The controller anchors both at the identifier prefix start, and
treats CalcParamValue as the only context worth popping on ( and ;
triggers. Mirrors the calc editor's gating logic.

Detection: when DetectEnclosingCall finds an unmatched ( ahead of
the caret, defer immediately — those ; separators belong to the
call, not to the step's flat param list (otherwise something like
JSONSetElement(j;k;v; never reached the labeled-value fallback).
A second deferral fires for labeled params with no enum values.

Field-ref and $variable completions inside script step brackets are
still empty — wiring a CalcCompletionContextProvider through the
script editor (with document text and any current-table reference)
is a follow-up.

Author: fuzzzerd

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;
             }
         }
 
@@ -259,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);
+    }
 }

src/SharpFM/Scripting/Editor/ScriptEditorController.cs

@@ -162,14 +162,19 @@ private void OnPointerMoved(object? sender, PointerEventArgs e)
     private void OnTextEntered(object? sender, TextInputEventArgs e)
     {
         if (_completionWindow != null) return;
-
-        // Only auto-trigger on identifier-starting characters. Without this
-        // gate, every space, semicolon, bracket, etc. spawns a fresh
-        // CompletionWindow build — measurably laggy for catalogs of any
-        // size. Mirrors the calculation editor's gating logic.
-        if (string.IsNullOrEmpty(e.Text) || !IsTriggerChar(e.Text[0])) 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 static bool IsTriggerChar(char c) =>
@@ -178,24 +183,35 @@ private static bool IsTriggerChar(char c) =>
     private static bool IsIdentifierChar(char c) =>
         char.IsLetterOrDigit(c) || c == '_';
 
-    private void TryShowCompletions()
+    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;
 
-        // Require AutoCompleteMinPrefix consecutive identifier characters
-        // immediately before the caret before showing. Skips the
-        // 60-item-empty-prefix popup on the very first keystroke.
+        // 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--;
-        if (col - prefixStart < AutoCompleteMinPrefix) return;
+
+        // 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)
@@ -207,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);

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);
+    }
 }