@xano/xanoscript-language-server 11.11.0 → 11.12.1

package/.claude/memory/feedback_no_git.md

@@ -0,0 +1,11 @@
+---
+name: no-git-interactions
+description: User does not want Claude to interact with git (no commits, no staging, no git commands)
+type: feedback
+---
+
+Do not interact with git — no commits, no staging, no git commands. Focus purely on implementation and testing.
+
+**Why:** User manages their own git workflow.
+
+**How to apply:** Skip all git-related steps in plans. When dispatching subagents, explicitly tell them not to run any git commands. Remove commit steps from task instructions.

package/.claude/settings.local.json

@@ -2,35 +2,20 @@
   "permissions": {
     "allow": [
       "Bash(npm test:*)",
-      "Bash(npm run lint)",
-      "Bash(npm run test:*)",
-      "Bash(npx eslint:*)",
-      "Bash(node:*)",
-      "Bash(npm install)",
+      "Bash(git checkout:*)",
+      "Bash(ls:*)",
+      "Bash(npm run lint:*)",
       "Bash(grep:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all --pretty=format:\"%h %s\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all -S \"password\\\\|secret\\\\|api_key\\\\|token\" --oneline)",
-      "Bash(xargs file:*)",
       "Bash(find:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -p --all -S \"webhook\\\\|Bearer\\\\|discord\\\\|slack\\\\|xano_insiders\" -- \"*.xs\" \"*.js\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server ls-files:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server status)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server diff --stat)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --oneline -5)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server add README.md LICENSE package.json lexer/tests/query/valid_sources/basic_query.xs parser/functions/stream/streamFromRequestFn.js parser/functions/stream/streamFromRequestFn.spec.js parser/tests/function/valid_sources/discord_poll_send_to_slack.xs parser/tests/query/valid_sources/all_basics.xs)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server commit -m \"$\\(cat <<''EOF''\nPrepare package for public npm release as @xano/xanoscript-language-server\n\n- Rename package to @xano/xanoscript-language-server\n- Add MIT LICENSE file\n- Add npm metadata \\(description, repository, author, license, bugs, homepage\\)\n- Remove private flag to allow publishing\n- Sanitize test files: replace internal URLs, IDs, and env var names with placeholders\n- Simplify README maintainer section\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -1 --oneline)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push)",
-      "Bash(npm whoami:*)",
-      "Bash(npm view:*)",
-      "Bash(npm version:*)",
-      "Bash(npm publish:*)",
-      "Bash(wc:*)",
-      "Bash(git push:*)"
-    ],
-    "deny": [],
-    "ask": []
+      "Read(//tmp/**)",
+      "Bash(git stash:*)",
+      "Bash(do)",
+      "Bash(if ! grep -q \"guidFieldAttribute\" \"$f\")",
+      "Bash(then)",
+      "Bash(echo:*)",
+      "Bash(fi)",
+      "Bash(done)",
+      "Bash(npx eslint:*)"
+    ]
   }
 }

package/lexer/cast.js

@@ -23,14 +23,14 @@ export const BoolCastToken = createUniqToken({
 // !array
 export const ArrayCastToken = createUniqToken({
   name: "ArrayCast",
-  pattern: /!array/,
+  pattern: /!array(?!\.)/,
   label: "!array",
 });
 
 // !text
 export const TextCastToken = createUniqToken({
   name: "TextCast",
-  pattern: /!text/,
+  pattern: /!text(?!\.)/,
   label: "!text",
 });
 
@@ -51,7 +51,7 @@ export const DecimalCastToken = createUniqToken({
 // !object
 export const ObjectCastToken = createUniqToken({
   name: "ObjectCast",
-  pattern: /!object/,
+  pattern: /!object(?!\.)/,
   label: "!object",
 });
 

package/lexer/control.js

@@ -1,5 +1,4 @@
 import { Identifier } from "./identifier.js";
-import { IntegerLiteral } from "./literal.js";
 import { createTokenByName, createUniqToken } from "./utils.js";
 
 // conditional
@@ -173,7 +172,6 @@ export const Minus = createUniqToken({
   name: "Minus",
   pattern: /-/,
   label: "-",
-  longer_alt: IntegerLiteral,
 });
 
 // +

package/lexer/literal.js

@@ -24,13 +24,13 @@ export const SingleQuotedStringLiteral = createUniqToken({
 export const FloatLiteral = createUniqToken({
   name: "FloatLiteral",
   label: "floating point number",
-  pattern: /-?\d+\.\d+([eE][+-]?\d+)?/,
+  pattern: /\d+\.\d+([eE][+-]?\d+)?/,
 });
 
 export const IntegerLiteral = createUniqToken({
   name: "IntegerLiteral",
   label: "integer",
-  pattern: /-?\d+/,
+  pattern: /\d+/,
   longer_alt: FloatLiteral,
 });
 

package/lexer/security.js

@@ -51,13 +51,13 @@ export const CreateSecretKeyToken = createTokenByName("create_secret_key", {
 
 // decrypt
 export const DecryptToken = createTokenByName("decrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 
 // encrypt
 export const EncryptToken = createTokenByName("encrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.11.0",
+  "version": "11.12.1",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/addon_parser.js

@@ -26,10 +26,11 @@ export function addonDeclaration($) {
     // Allow leading comments and newlines before the addon declaration
     $.SUBRULE($.optionalCommentBlockFn);
     const parent = $.CONSUME(AddonToken);
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "addon");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/agent_parser.js

@@ -21,10 +21,11 @@ export function agentDeclaration($) {
     // Allow leading comments and newlines before the agent declaration
     $.SUBRULE($.optionalCommentBlockFn);
     const parent = $.CONSUME(AgentToken); // agent
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "agent");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/agent_trigger_parser.js

@@ -26,10 +26,11 @@ export function agentTriggerDeclaration($) {
     // Allow leading comments and newlines before the agent_trigger declaration
     $.SUBRULE($.optionalCommentBlockFn);
     const parent = $.CONSUME(AgentTriggerToken); // agent_trigger
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "agent_trigger");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/api_group_parser.js

@@ -27,10 +27,11 @@ export function apiGroupDeclaration($) {
     // Allow leading comments and newlines before the api_group declaration
     $.SUBRULE($.optionalCommentBlockFn);
     $.CONSUME(ApiGroupToken); // api_group
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "api_group");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));

package/parser/attributes/columnDefaultValueAttribute.js

@@ -1,4 +1,4 @@
-import { EqualToken } from "../../lexer/control.js";
+import { EqualToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -21,8 +21,15 @@ export function columnDefaultValueAttribute($) {
     $.CONSUME(EqualToken); // "="
     $.OR([
       { ALT: () => $.CONSUME(StringLiteral) }, // e.g., "default value"
-      { ALT: () => $.CONSUME(FloatLiteral) }, // e.g., 42.54
-      { ALT: () => $.CONSUME(IntegerLiteral) }, // e.g., 42
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(Minus));
+          return $.OR1([
+            { ALT: () => $.CONSUME(IntegerLiteral) },
+            { ALT: () => $.CONSUME(FloatLiteral) },
+          ]);
+        },
+      },
       { ALT: () => $.CONSUME(TrueToken) }, // true
       { ALT: () => $.CONSUME(FalseToken) }, // false
       { ALT: () => $.CONSUME(NowToken) }, // now

package/parser/attributes/inputFilterFn.js

@@ -1,5 +1,5 @@
 import { ExclamationToken } from "../../lexer/cast.js";
-import { ColonToken } from "../../lexer/control.js";
+import { ColonToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -36,8 +36,15 @@ export function inputFilterFn($) {
               { ALT: () => $.CONSUME2(Identifier) },
               { ALT: () => $.CONSUME1(StringLiteral) },
               { ALT: () => $.CONSUME1(RegExpToken) },
-              { ALT: () => $.CONSUME1(IntegerLiteral) },
-              { ALT: () => $.CONSUME1(FloatLiteral) },
+              {
+                ALT: () => {
+                  $.OPTION1(() => $.CONSUME(Minus));
+                  $.OR1([
+                    { ALT: () => $.CONSUME(IntegerLiteral) },
+                    { ALT: () => $.CONSUME(FloatLiteral) },
+                  ]);
+                },
+              },
               { ALT: () => $.CONSUME1(FalseToken) },
               { ALT: () => $.CONSUME1(TrueToken) },
             ]);
@@ -52,7 +59,7 @@ export function inputFilterFn($) {
           ) {
             $.addInvalidValueError(
               filter,
-              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`
+              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`,
             );
           }
         },

package/parser/base_parser.js

@@ -270,6 +270,17 @@ export class XanoBaseParser extends CstParser {
     this.SAVE_ERROR(new MismatchedTokenException(message, token));
   }
 
+  /**
+   * Validate that a declaration name token is not an empty string
+   * @param {import('chevrotain').IToken} nameToken
+   * @param {string} typeName the declaration type (e.g. "query", "function")
+   */
+  validateDeclarationName(nameToken, typeName) {
+    if (nameToken?.image === '""') {
+      this.addInvalidValueError(nameToken, `${typeName} name must not be empty`);
+    }
+  }
+
   /**
    * Setup all the required rules for the parser but without creating duplicates
    *

package/parser/branch_parser.js

@@ -9,10 +9,11 @@ export function branchDeclaration($) {
     $.SUBRULE($.optionalCommentBlockFn);
 
     const parent = $.CONSUME(BranchToken); // branch
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "branch");
 
     const middlewareSchema = {
       pre: [{ name: "[string]" }],

package/parser/clauses/flexibleStringClause.js

@@ -1,7 +1,7 @@
 import { EqualToken } from "../../lexer/control.js";
-import { Identifier } from "../../lexer/identifier.js";
 import { StringLiteral } from "../../lexer/literal.js";
 import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { InstructionsToken } from "../../lexer/tool.js";
 
 /**
  * @param {import('../base_parser.js').XanoBaseParser} $
@@ -14,7 +14,7 @@ export function flexibleStringClause($) {
   return (args) => {
     // During parser initialization, args is undefined
     // Use a placeholder token for grammar recording
-    const token = args?.[0] || Identifier;
+    const token = args?.[0] || InstructionsToken;
     const allowEmpty = args?.[1] ?? true;
 
     $.sectionStack.push(token.name + "Clause");

package/parser/clauses/nakedStackFn.js

@@ -20,46 +20,53 @@ export function nakedStackFn($) {
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // required new line before each clause
-      $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+      // $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
       $.OR([
         { ALT: () => $.CONSUME(CommentToken) },
-        { ALT: () => $.SUBRULE($.aiFn) },
-        { ALT: () => $.SUBRULE($.dbFn) },
-        { ALT: () => $.SUBRULE($.varFn) },
-        { ALT: () => $.SUBRULE($.arrayFn) },
-        { ALT: () => $.SUBRULE($.cloudFn) },
-        { ALT: () => $.SUBRULE($.securityFn) },
-        { ALT: () => $.SUBRULE($.mathFn) },
-        { ALT: () => $.SUBRULE($.textFn) },
-        { ALT: () => $.SUBRULE($.utilFn) },
-        { ALT: () => $.SUBRULE($.preconditionFn) },
-        { ALT: () => $.SUBRULE($.zipFn) },
-        { ALT: () => $.SUBRULE($.objectFn) },
-        { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.webflowFn) },
-        { ALT: () => $.SUBRULE($.redisFn) },
-        { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.debugFn) },
-        { ALT: () => $.SUBRULE($.storageFn) },
-        { ALT: () => $.SUBRULE($.streamFn) },
-        { ALT: () => $.SUBRULE($.actionCallFn) },
         {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.toolCallFn),
+          ALT: () => {
+            $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+            $.OR1([
+              { ALT: () => $.SUBRULE($.aiFn) },
+              { ALT: () => $.SUBRULE($.dbFn) },
+              { ALT: () => $.SUBRULE($.varFn) },
+              { ALT: () => $.SUBRULE($.arrayFn) },
+              { ALT: () => $.SUBRULE($.cloudFn) },
+              { ALT: () => $.SUBRULE($.securityFn) },
+              { ALT: () => $.SUBRULE($.mathFn) },
+              { ALT: () => $.SUBRULE($.textFn) },
+              { ALT: () => $.SUBRULE($.utilFn) },
+              { ALT: () => $.SUBRULE($.preconditionFn) },
+              { ALT: () => $.SUBRULE($.zipFn) },
+              { ALT: () => $.SUBRULE($.objectFn) },
+              { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.webflowFn) },
+              { ALT: () => $.SUBRULE($.redisFn) },
+              { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.debugFn) },
+              { ALT: () => $.SUBRULE($.storageFn) },
+              { ALT: () => $.SUBRULE($.streamFn) },
+              { ALT: () => $.SUBRULE($.actionCallFn) },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.toolCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.addonCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.middlewareCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.triggerCallFn),
+              },
+              { ALT: () => $.SUBRULE($.workflowExpectFn) },
+            ]);
+          },
         },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.addonCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.middlewareCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.triggerCallFn),
-        },
-        { ALT: () => $.SUBRULE($.workflowExpectFn) },
       ]);
     });
     $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken));

package/parser/clauses/nakedStackFn.spec.js

@@ -31,6 +31,16 @@ describe("nakedStack", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("nakedStack accepts a disabled array statement", () => {
+    const parser = parse(`{
+  !array.push $my_array { 
+    value = 1
+  }
+}`);
+    console.log(parser.errors);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("nakedStack accepts a multiline statement", () => {
     const parser = parse(`{
   var $some_var { 

package/parser/clauses/responseClause.spec.js

@@ -27,6 +27,11 @@ describe("responseClause", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("responseClause accepts a string", () => {
+    const parser = parse(`response = "no exception"`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("responseClause accepts an object", () => {
     const parser = parse(`response = {result1: $x1, x2: $x2}`);
     expect(parser.errors).to.be.empty;

package/parser/definitions/columnDefinition.js

@@ -115,7 +115,11 @@ export function columnDefinition($) {
 
     // Track table reference from FK column definition
     if (captured.table?.value) {
-      $.addReference("table", getVarName(captured.table.value), captured.table.value);
+      $.addReference(
+        "table",
+        getVarName(captured.table.value),
+        captured.table.value,
+      );
     }
 
     if (inputTypeToken.image == "vector" && !captured.size) {
@@ -126,7 +130,8 @@ export function columnDefinition($) {
     }
 
     const inTable = $.sectionStack.includes("tableDeclaration");
-    if (captured.visibility && !inTable) {
+    const inIntput = $.sectionStack.includes("inputClause");
+    if (captured.visibility && !inTable && !inIntput) {
       $.addInvalidValueError(
         nameToken,
         'The "visibility" attribute is only valid within a table schema definition.',

package/parser/function_parser.js

@@ -29,6 +29,7 @@ export function functionDeclaration($) {
       { ALT: () => $.CONSUME(StringLiteral) },
     ]);
 
+    $.validateDeclarationName(nameToken, "function");
     if (nameToken?.image && getVarName(nameToken).startsWith("/")) {
       $.addInvalidValueError(
         nameToken,

package/parser/function_parser.spec.js

@@ -16,6 +16,20 @@ describe("function_parser", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("should raise an error when a function name is empty", () => {
+    const parser = xanoscriptParser(`function "" {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+    expect(parser.errors).to.not.be.empty;
+    expect(parser.errors[0].message).to.include("must not be empty");
+  });
+
   it("should raise an error when a function name starts with /", () => {
     const parser = xanoscriptParser(`function "/foo" {
       input {

package/parser/functions/array/arrayNoValueAs.js

@@ -25,7 +25,7 @@ export function arrayNoValueAs($) {
       $.CONSUME(RCurly);
     });
     $.CONSUME(AsToken);
-    $.SUBRULE($.variableOnly);
+    $.SUBRULE($.assignableVariableAs);
     $.sectionStack.pop();
   };
 }

package/parser/functions/array/arrayPopFn.js

@@ -1,8 +1,6 @@
 import { PopToken } from "../../../lexer/arrays.js";
 
-// array.pop {
-//   value = "test"
-// } as test
+// array.pop $var as $unit
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
  */

package/parser/functions/controls/forEachFn.spec.js

@@ -19,6 +19,14 @@ describe("forEachFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("forEachFn should warn when using a reserved variable name", () => {
+    const parser = parse(`foreach ([]|push:1|push:2|push:3|push:4) {
+      each as $env
+    }`);
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+  });
+
   it("forEachFn can also be foreach.remove", () => {
     const parser = parse(`foreach.remove`);
     expect(parser.errors).to.be.empty;

package/parser/functions/controls/preconditionFn.js

@@ -1,4 +1,5 @@
 import { LParent, RParent } from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 import { PreconditionToken } from "../../../lexer/util.js";
 
 /**
@@ -13,7 +14,9 @@ export function preconditionFn($) {
     $.sectionStack.push("preconditionFn");
     const tokenFn = $.CONSUME(PreconditionToken); // "precondition"
     $.CONSUME(LParent);
+    $.MANY(() => $.CONSUME(NewlineToken));
     $.SUBRULE($.expressionFn);
+    $.MANY1(() => $.CONSUME1(NewlineToken));
     $.CONSUME(RParent);
     $.SUBRULE($.schemaParseAttributeFn, {
       ARGS: [

package/parser/functions/db/dbExternalDirectQueryFn.js

@@ -14,6 +14,7 @@ export function dbExternalDirectQueryFn($) {
         {
           sql: "[expression]",
           response_type: ["list", "single"],
+          "parser?": "template_engine",
           connection_string: "[expression]",
           "description?": "[string]",
           "disabled?": "[boolean]",

package/parser/functions/db/dbQueryFn.spec.js

@@ -346,4 +346,35 @@ describe("dbQueryFn", () => {
     const parser = parse(`query user as $user`);
     expect(parser.errors).to.be.empty;
   });
+
+  describe("aggregate eval with aggregator pipes", () => {
+    const aggregators = [
+      "avg",
+      "count",
+      "count_distinct",
+      "max",
+      "median",
+      "min",
+      "sum",
+      "to_distinct_list",
+      "to_distinct_list_asc",
+      "to_distinct_list_desc",
+      "to_list",
+      "to_list_asc",
+      "to_list_desc",
+    ];
+
+    for (const agg of aggregators) {
+      it(`dbQueryFn return eval accepts |${agg} aggregator`, () => {
+        const parser = parse(`query user {
+      return = {
+        type: "aggregate"
+        group: {user_name: $db.user.name}
+        eval: {result: $db.user.name|${agg}}
+      }
+    } as $user`);
+        expect(parser.errors).to.be.empty;
+      });
+    }
+  });
 });

package/parser/functions/schema/schemaParseConstantFn.js

@@ -1,4 +1,5 @@
 import { isArray, some } from "lodash-es";
+import { Minus } from "../../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -37,18 +38,18 @@ export function schemaParseConstantFn($) {
             return $.CONSUME(SingleQuotedStringLiteral); // e.g., 'field instructions'
           },
         },
+
         {
           ALT: () => {
+            $.OPTION(() => $.CONSUME(Minus));
             attributeCapturedType = "number";
-            return $.CONSUME(IntegerLiteral); // e.g., 42
-          },
-        },
-        {
-          ALT: () => {
-            attributeCapturedType = "number";
-            return $.CONSUME(FloatLiteral); // e.g., 42.54
+            return $.OR1([
+              { ALT: () => $.CONSUME(IntegerLiteral) },
+              { ALT: () => $.CONSUME(FloatLiteral) },
+            ]);
           },
         },
+
         {
           ALT: () => {
             attributeCapturedType = "boolean";
@@ -76,7 +77,7 @@ export function schemaParseConstantFn($) {
       const isMatch = matchValueToSchema(
         attributeCapturedType,
         capturedValue.image,
-        schema
+        schema,
       );
 
       if (!isMatch) {
@@ -92,7 +93,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
   // schema can be an array of type/values required
   if (isArray(schema)) {
     return some(schema, (s) =>
-      matchValueToSchema(attributeCapturedType, value, s)
+      matchValueToSchema(attributeCapturedType, value, s),
     );
   }
 
@@ -115,7 +116,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
       return schemaValue === null;
     default:
       throw new Error(
-        `schemaParseConstantFn called with non-constant attribute: ${schema}`
+        `schemaParseConstantFn called with non-constant attribute: ${schema}`,
       );
   }
 }