diff --git a/package-lock.json b/package-lock.json
index 82a28927c..c4eadcbaa 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "wordplay",
-    "version": "0.6.25",
+    "version": "0.6.26",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "wordplay",
-            "version": "0.6.25",
+            "version": "0.6.26",
             "bundleDependencies": [
                 "shared-types"
             ],
diff --git a/src/components/editor/EvaluateView.svelte b/src/components/editor/EvaluateView.svelte
index 25d60cb36..8b9efdcd5 100644
--- a/src/components/editor/EvaluateView.svelte
+++ b/src/components/editor/EvaluateView.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
     import Evaluate from '@nodes/Evaluate';
-    import Input from '@nodes/Input';
     import type Bind from '../../nodes/Bind';
     import Token from '../../nodes/Token';
     import { getCaret, getIsBlocks, getProject } from '../project/Contexts';
@@ -50,22 +49,13 @@
                     if (given === undefined) {
                         nextBind = expected;
                         if ($blocks) {
-                            const lastLeaf = node.getLastLeaf() ?? node.close;
-                            menuPosition =
-                                lastLeaf instanceof Token
-                                    ? $caret.source.getTokenTextPosition(
-                                          lastLeaf,
-                                      )
-                                    : undefined;
+                            menuPosition = typeof $caret.position === 'number' 
+                                ? $caret.position 
+                                : undefined;
                         } else {
-                            const lastLeaf = (
-                                node.getLastInput() ?? node.open
-                            ).getLastLeaf();
-                            menuPosition =
-                                lastLeaf instanceof Token
-                                    ? $caret.source.getTokenLastPosition(
-                                          lastLeaf,
-                                      )
+                                // Use the caret's current position instead of the last leaf
+                                menuPosition = typeof $caret.position === 'number' 
+                                    ? $caret.position 
                                     : undefined;
                         }
                         break;
@@ -81,9 +71,17 @@
         <NodeView node={node.fun} /><NodeView node={node.types} /><NodeView
             node={node.open}
         />
-        {#each node.inputs as input}<NodeView node={input} /><PlaceholderView
+        <!-- {#each node.inputs as input}<NodeView node={input} /><PlaceholderView
                 position={input instanceof Input ? input.value : input}
-            />{/each}<!-- {#if nextBind}
+            />{/each} -->
+        <!-- {#each node.inputs as input}<NodeView
+            node={input}
+        />{/each} -->
+        {#each node.inputs as input}<NodeView node={input} /><PlaceholderView
+                position={input}
+            />{/each}
+
+        <!-- {#if nextBind}
             <div class="hint"
                 ><div class="name"
                     ><RootView
@@ -102,9 +100,11 @@
 {:else}
     <NodeView node={node.fun} /><NodeView node={node.types} /><NodeView
         node={node.open}
-    />{#each node.inputs as input}<NodeView
-            node={input}
-        />{/each}<!-- {#if nextBind}
+    />{#each node.inputs as input}<NodeView node={input} /><PlaceholderView
+            position={input}
+        />{/each}
+
+    <!-- {#if nextBind}
         <div class="hint"
             ><div class="name"
                 ><RootView
diff --git a/src/edit/Append.ts b/src/edit/Append.ts
index 66079fd72..921681884 100644
--- a/src/edit/Append.ts
+++ b/src/edit/Append.ts
@@ -81,6 +81,15 @@ export default class Append<NodeType extends Node> extends Revision {
         // Does the insertion have a placeholder token? If so, place the caret at it's first placeholder instead of the end.
         const firstPlaceholder = newChild.getFirstPlaceholder();
         if (firstPlaceholder) newCaretPosition = firstPlaceholder;
+        
+        // // Keep the caret at the original insertion position
+        // let newCaretPosition: Node | number | undefined = this.position;
+
+        // // Only move to placeholder if explicitly requested (e.g., for completions)
+        // if (this.isCompletion()) {
+        //     const firstPlaceholder = newChild.getFirstPlaceholder();
+        //     if (firstPlaceholder) newCaretPosition = firstPlaceholder;
+        // }
 
         // Return the new source and put the caret immediately after the inserted new child.
         return [
diff --git a/src/edit/Assign.ts b/src/edit/Assign.ts
index e923f58e2..7cb5b72bf 100644
--- a/src/edit/Assign.ts
+++ b/src/edit/Assign.ts
@@ -47,8 +47,8 @@ export default class Assign<NodeType extends Node> extends Revision {
         return node === undefined
             ? undefined
             : node instanceof Node
-              ? node
-              : node.getNode(locales);
+                ? node
+                : node.getNode(locales);
     }
 
     getEditedNode(locales: Locales): [Node, Node] {
@@ -68,10 +68,10 @@ export default class Assign<NodeType extends Node> extends Revision {
         const existingChild = this.parent.getField(this.additions[0].field);
         const originalPosition = existingChild
             ? this.context.source.getNodeFirstPosition(
-                  Array.isArray(existingChild)
-                      ? existingChild[0]
-                      : existingChild,
-              )
+                Array.isArray(existingChild)
+                    ? existingChild[0]
+                    : existingChild,
+            )
             : undefined;
 
         // Split the space using the position, defaulting to the original space.
@@ -79,10 +79,10 @@ export default class Assign<NodeType extends Node> extends Revision {
             newNode === undefined
                 ? this.context.source.spaces
                 : Revision.splitSpace(
-                      this.context.source,
-                      this.position,
-                      newNode,
-                  );
+                    this.context.source,
+                    this.position,
+                    newNode,
+                );
 
         let newSource = this.context.source
             .replace(this.parent, newParent)
@@ -94,26 +94,35 @@ export default class Assign<NodeType extends Node> extends Revision {
                 getPreferredSpaces(newParent, newSource.spaces),
             );
 
-        // Place the caret at first placeholder or the end of the node in the source.
+        // // Place the caret at first placeholder or the end of the node in the source.
+        // const newCaretPosition =
+        //     newNode === undefined
+        //         ? (originalPosition ?? this.position)
+        //         : (newParent.getFirstPlaceholder() ??
+        //           newSource.getNodeLastPosition(newNode));
+
+        // Keep caret at original position unless this is a completion
         const newCaretPosition =
             newNode === undefined
                 ? (originalPosition ?? this.position)
-                : (newParent.getFirstPlaceholder() ??
-                  newSource.getNodeLastPosition(newNode));
+                : this.isCompletion()
+                    ? (newParent.getFirstPlaceholder() ??
+                        newSource.getNodeLastPosition(newNode))
+                    : this.position;
 
         // If we didn't find a caret position, bail. Otherwise, return the edit.
         return newCaretPosition === undefined
             ? undefined
             : [
-                  newSource,
-                  new Caret(
-                      newSource,
-                      newCaretPosition,
-                      undefined,
-                      undefined,
-                      newNode,
-                  ),
-              ];
+                newSource,
+                new Caret(
+                    newSource,
+                    newCaretPosition,
+                    undefined,
+                    undefined,
+                    newNode,
+                ),
+            ];
     }
 
     getDescription(locales: Locales) {
@@ -141,9 +150,9 @@ export default class Assign<NodeType extends Node> extends Revision {
                     (node === undefined
                         ? otherNode === undefined
                         : node instanceof Node
-                          ? otherNode instanceof Node &&
+                            ? otherNode instanceof Node &&
                             node.isEqualTo(otherNode)
-                          : otherNode instanceof Refer &&
+                            : otherNode instanceof Refer &&
                             node.equals(otherNode))
                 );
             })
diff --git a/src/edit/Autocomplete.ts b/src/edit/Autocomplete.ts
index 1831e993e..fa841fae8 100644
--- a/src/edit/Autocomplete.ts
+++ b/src/edit/Autocomplete.ts
@@ -228,8 +228,7 @@ function getNodeEdits(anchor: Node, context: Context) {
         const fieldValue = parent.getField(field.name);
 
         note(
-            `Finding possible replacement nodes for "${
-                field.name
+            `Finding possible replacement nodes for "${field.name
             }" with type ${expectedType?.toWordplay()}`,
             2,
         );
@@ -254,8 +253,8 @@ function getNodeEdits(anchor: Node, context: Context) {
                 .flat(),
             // Is this node in a list field? Offer to remove it if it can be empty or can't but has more than one element.
             ...(field.kind instanceof ListOf &&
-            (field.kind.allowsEmpty ||
-                (Array.isArray(fieldValue) && fieldValue.length > 1))
+                (field.kind.allowsEmpty ||
+                    (Array.isArray(fieldValue) && fieldValue.length > 1))
                 ? [new Remove(context, parent, node)]
                 : []),
         ];
@@ -374,15 +373,33 @@ function getRelativeFieldEdits(
                     )
                         // If not on an empty line, only include recommendations that "complete" the selection
                         .filter(
-                            (replacement) =>
-                                empty ||
-                                (replacement !== undefined &&
-                                    completes(
-                                        anchorNode,
-                                        replacement instanceof Node
-                                            ? replacement
-                                            : replacement.getNode(locales),
-                                    )),
+                            (replacement) => {
+                                // Original filter: completion check
+                                const passesCompletion = empty ||
+                                    (replacement !== undefined &&
+                                        completes(
+                                            anchorNode,
+                                            replacement instanceof Node
+                                                ? replacement
+                                                : replacement.getNode(locales),
+                                        ));
+        
+                                if (!passesCompletion) return false;
+        
+                                // Additional filter: remove Refer in Evaluate with unfilled required params
+                                if (replacement instanceof Refer && parent instanceof Evaluate) {
+                                    const mapping = parent.getInputMapping(context);
+                                    if (mapping) {
+                                        const hasUnfilledRequired = mapping.inputs.some(
+                                            ({ expected, given }) => 
+                                                given === undefined && expected.value === undefined
+                                        );
+                                        if (hasUnfilledRequired) return false;
+                                    }
+                                }
+        
+                                return true;
+                            }           
                         )
                         // Convert the matching nodes to replacements.
                         .map(
@@ -405,7 +422,7 @@ function getRelativeFieldEdits(
     const relativeFields = isAfterAnchor
         ? grammar.slice(fieldIndex)
         : // We reverse this so we can from most proximal to anchor to the beginning of the node.
-          grammar.slice(0, fieldIndex + 1).reverse();
+        grammar.slice(0, fieldIndex + 1).reverse();
 
     for (const relativeField of relativeFields) {
         note(
@@ -431,11 +448,20 @@ function getRelativeFieldEdits(
                 // Account for empty lists, as the node might not be in the list, as its an opening delimiter.
                 // If it's not in the list, it's either an empty list, in which we're inserting at the beginning,
                 // or it's not empty, and we're before the end.
+                // const index =
+                //     list.length === 0
+                //         ? 0
+                //         : Math.max(list.length - 1, list.indexOf(anchorNode)) +
+                //           1;
+
+                const anchorIndex = list.indexOf(anchorNode);
                 const index =
                     list.length === 0
                         ? 0
-                        : Math.max(list.length - 1, list.indexOf(anchorNode)) +
-                          1;
+                        : anchorIndex >= 0
+                            ? (isAfterAnchor ? anchorIndex + 1 : anchorIndex)
+                            : list.length;
+
                 if (index >= 0) {
                     // Find the expected type of the position in the list.
                     // Some lists don't care, other lists do (e.g., Evaluate has very specific type expectations based on it's function definnition).
@@ -443,6 +469,22 @@ function getRelativeFieldEdits(
                     const expectedType = relativeField.getType
                         ? relativeField.getType(context, index)
                         : undefined;
+                    // Special handling for Evaluate inputs: filter optional params if required ones are missing
+                    let shouldFilterOptional = false;
+                    if (parent instanceof Evaluate && relativeField.name === 'inputs') {
+                        const mapping = parent.getInputMapping(context);
+                        if (mapping) {
+                            // Check if there are any unfilled required inputs
+                            const hasUnfilledRequired = mapping.inputs.some(
+                                ({ expected, given }) => 
+                                    given === undefined && expected.value === undefined
+                            );
+        
+                            // If there are unfilled required inputs, we'll filter optional ones
+                            shouldFilterOptional = hasUnfilledRequired;
+                        }
+                    }
+
                     edits = [
                         ...edits,
                         ...relativeField.kind
@@ -461,6 +503,29 @@ function getRelativeFieldEdits(
                                         (kind): kind is Node | Refer =>
                                             kind !== undefined,
                                     )
+                                    .filter((insertion) => {
+                                        if (!shouldFilterOptional) return true;
+                                        if (insertion instanceof Refer) return false;
+                                        let nextReqName: string | undefined;
+                                        if (parent instanceof Evaluate) {
+                                            const mapping = parent.getInputMapping(context);
+                                            const nextReq = mapping?.inputs.find(
+                                                ({ expected, given }) => given === undefined && expected.value === undefined
+                                            )?.expected as any;
+
+                                            nextReqName =
+                                                (nextReq?.getName?.()) ??
+                                                (nextReq?.name?.getText?.());
+                                            }
+
+                                            if (insertion instanceof Bind || insertion instanceof PropertyBind) {
+                                                const insName =
+                                                    (insertion as any)?.getName?.() ??
+                                                    ((insertion as any)?.name?.getText?.());
+                                                if (nextReqName && insName && insName !== nextReqName) return false;
+                                                }
+                                          return true;
+                                    })
                                     .map(
                                         (insertion) =>
                                             new Append(
@@ -468,7 +533,7 @@ function getRelativeFieldEdits(
                                                 position,
                                                 parent,
                                                 list,
-                                                index + 1,
+                                                index,
                                                 insertion,
                                             ),
                                     ),
@@ -699,20 +764,51 @@ function getPossibleNodes(
             )
             // Flatten the list of possible nodes.
             .flat()
+
             .filter(
-                (node) =>
+                (node) => {
                     // Filter out nodes that don't match the given type, if provided.
-                    (expectedType === undefined ||
-                        !(node instanceof Expression) ||
-                        expectedType.accepts(node.getType(context), context)) &&
+                    if (expectedType !== undefined &&
+                        node instanceof Expression &&
+                        !expectedType.accepts(node.getType(context), context)) {
+                        return false;
+                    }
+        
                     // Filter out nodes that are equivalent to the selection node
-                    (anchor === undefined ||
-                        (node instanceof Refer &&
-                            (!(anchor instanceof Reference) ||
-                                (anchor instanceof Reference &&
-                                    node.definition !==
-                                        anchor.resolve(context)))) ||
-                        (node instanceof Node && !anchor.isEqualTo(node))),
+                    if (anchor !== undefined) {
+                        if (node instanceof Refer) {
+                            if (anchor instanceof Reference &&
+                                node.definition === anchor.resolve(context)) {
+                                return false;
+                            }
+                        } else if (node instanceof Node && anchor.isEqualTo(node)) {
+                            return false;
+                        }
+                    }
+        
+                    // CRITICAL: Filter out ALL Refer when in Evaluate with unfilled required params
+                    if (!selected && node instanceof Refer) {
+                        const parent = anchor.getParent(context);
+                        // Check if we're in an Evaluate context
+                        if (parent instanceof Evaluate) {
+                            const mapping = parent.getInputMapping(context);
+                            if (mapping) {
+                                const hasUnfilledRequired = mapping.inputs.some(
+                                    ({ expected, given }) => 
+                                        given === undefined && expected.value === undefined
+                                );
+                    
+                                // If there are unfilled required params, hide ALL references
+                                if (hasUnfilledRequired) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+        
+                    return true;
+
+                }
             )
-    );
-}
+        ); 
+    } 
diff --git a/src/nodes/Evaluate.ts b/src/nodes/Evaluate.ts
index 02f0db4fc..5f02d12a9 100644
--- a/src/nodes/Evaluate.ts
+++ b/src/nodes/Evaluate.ts
@@ -188,8 +188,26 @@ export default class Evaluate extends Expression {
                                     : undefined,
                             ),
                         def,
-                    ),
-            );
+                    )
+                )
+                .filter((refer) => {
+                // Filter out Refer objects when they represent optional parameters
+                // and there are unfilled required parameters
+                if (!replace && node instanceof Evaluate) {
+                    const mapping = node.getInputMapping(context);
+                    if (mapping) {
+                        const hasUnfilledRequired = mapping.inputs.some(
+                            ({ expected, given }) => 
+                                given === undefined && expected.value === undefined
+                        );
+                        // If there are unfilled required params, only show Refers that are required params
+                        if (hasUnfilledRequired && refer.definition instanceof Bind) {
+                            return refer.definition.value === undefined;
+                        }
+                    }
+                }
+                return true;    
+            });
     }
 
     static getPossibleReplacements({ node, type, context }: EditContext) {
diff --git a/src/nodes/FormattedLiteral.ts b/src/nodes/FormattedLiteral.ts
index 61b27d75f..ead2b28b4 100644
--- a/src/nodes/FormattedLiteral.ts
+++ b/src/nodes/FormattedLiteral.ts
@@ -27,6 +27,8 @@ import Token from './Token';
 import type Type from './Type';
 import type TypeSet from './TypeSet';
 import Words from './Words';
+import TextType from './TextType';
+
 
 export default class FormattedLiteral extends Literal {
     readonly texts: FormattedTranslation[];
@@ -40,10 +42,15 @@ export default class FormattedLiteral extends Literal {
     }
 
     static getPossibleReplacements({ type, context }: EditContext) {
-        return type !== undefined && type.accepts(FormattedType.make(), context)
+        const accepts =
+            type !== undefined &&
+            (type.accepts(new TextType(), context) ||
+            type.accepts(FormattedType.make(), context));
+        return accepts
             ? [new FormattedLiteral([FormattedTranslation.make()])]
             : [];
-    }
+        }
+
 
     static getPossibleAppends(context: EditContext) {
         return this.getPossibleReplacements(context);