diff --git a/.dockerignore b/.dockerignore
index 5756b9f9d..afea64e57 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -17,7 +17,6 @@
 !/.gitignore
 !/babel.config.json
 !/Dockerfile
-!/formulon.d.ts
 !/LICENSE.md
 !/next-sitemap.config.js
 !/nx.json
diff --git a/apps/jetstream-e2e/src/fixtures/fixtures.ts b/apps/jetstream-e2e/src/fixtures/fixtures.ts
index 098548355..46d5bed32 100644
--- a/apps/jetstream-e2e/src/fixtures/fixtures.ts
+++ b/apps/jetstream-e2e/src/fixtures/fixtures.ts
@@ -4,6 +4,7 @@ import * as dotenv from 'dotenv';
 import {
   ApiRequestUtils,
   AuthenticationPage,
+  FormulaEvaluatorPage,
   LoadSingleObjectPage,
   LoadWithoutFilePage,
   OrgGroupPage,
@@ -48,6 +49,7 @@ type MyFixtures = {
   playwrightPage: PlaywrightPage;
   authenticationPage: AuthenticationPage;
   newUser: Awaited<ReturnType<AuthenticationPage['signUpAndVerifyEmail']>>;
+  formulaEvaluatorPage: FormulaEvaluatorPage;
   queryPage: QueryPage;
   loadSingleObjectPage: LoadSingleObjectPage;
   orgGroupPage: OrgGroupPage;
@@ -115,6 +117,10 @@ export const test = base.extend<MyFixtures>({
   newUser: async ({ authenticationPage }, use) => {
     await use(await authenticationPage.signUpAndVerifyEmail());
   },
+  formulaEvaluatorPage: async ({ page, apiRequestUtils }, use) => {
+    await apiRequestUtils.selectDefaultOrg();
+    await use(new FormulaEvaluatorPage(page, apiRequestUtils));
+  },
   queryPage: async ({ page, apiRequestUtils }, use) => {
     await apiRequestUtils.selectDefaultOrg();
     await use(new QueryPage(page, apiRequestUtils));
diff --git a/apps/jetstream-e2e/src/tests/formula-evaluator/formula-evaluator.spec.ts b/apps/jetstream-e2e/src/tests/formula-evaluator/formula-evaluator.spec.ts
new file mode 100644
index 000000000..397ca393a
--- /dev/null
+++ b/apps/jetstream-e2e/src/tests/formula-evaluator/formula-evaluator.spec.ts
@@ -0,0 +1,295 @@
+import { expect, test } from '../../fixtures/fixtures';
+
+/**
+ * Tests use the record "A - formula test record" (Account 001al00002FzdpCAAR) which has:
+ * - Name: "A - formula test record"
+ * - AnnualRevenue: 350000000
+ * - NumberOfEmployees: 9000
+ * - NumberofLocations__c: 6
+ * - BillingCity: "Burlington", BillingState: "NC", BillingPostalCode: "27215", BillingCountry: "USA"
+ * - Phone: "(336) 222-7000"
+ * - Industry: "Apparel"
+ * - Type: "Customer - Direct"
+ * - SLA__c: "Silver"
+ * - SLAExpirationDate__c: "2022-01-22"
+ * - SLASerialNumber__c: "5367"
+ * - Website: "www.burlington.com"
+ * - Fax: "Burlington Textiles Corp of America"
+ * - TickerSymbol: "BTXT"
+ * - Ownership: "Public"
+ * - Rating: "Warm"
+ * - Owner.Name: "Integration Test", Owner.FirstName: "Integration", Owner.LastName: "Test"
+ * - Parent.Name: "University of Arizona"
+ * - Description: null, AccountSource: null, ShippingCity: null
+ */
+
+test('FORMULA EVALUATOR', async ({ formulaEvaluatorPage }) => {
+  await formulaEvaluatorPage.goto();
+  await formulaEvaluatorPage.selectObject('Account');
+  await formulaEvaluatorPage.searchAndSelectRecord('A - formula test record');
+  // Skip return type validation since tests cover multiple return types
+  await formulaEvaluatorPage.setReturnType('--Skip Type Validation--');
+
+  // ─── Text formulas ───────────────────────────────────────────
+
+  await test.step('string concatenation with &', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Name & " | " & Phone');
+    expect(result).toBe('A - formula test record | (336) 222-7000');
+  });
+
+  await test.step('UPPER and LOWER', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('UPPER(BillingCity) & ", " & LOWER(BillingState)');
+    expect(result).toBe('BURLINGTON, nc');
+  });
+
+  await test.step('LEFT and RIGHT', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('LEFT(TickerSymbol, 2) & RIGHT(TickerSymbol, 2)');
+    expect(result).toBe('BTXT');
+  });
+
+  await test.step('LEN', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('LEN(Phone)');
+    expect(result).toBe('14');
+  });
+
+  await test.step('CONTAINS', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(CONTAINS(Name, "formula"), "yes", "no")');
+    expect(result).toBe('yes');
+  });
+
+  await test.step('SUBSTITUTE', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('SUBSTITUTE(BillingCity, "Burlington", "Charlotte")');
+    expect(result).toBe('Charlotte');
+  });
+
+  await test.step('TRIM', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('TRIM("  hello  ")');
+    expect(result).toBe('hello');
+  });
+
+  await test.step('LPAD', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('LPAD(SLASerialNumber__c, 8, "0")');
+    expect(result).toBe('00005367');
+  });
+
+  await test.step('BEGINS', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(BEGINS(Website, "www"), "yes", "no")');
+    expect(result).toBe('yes');
+  });
+
+  await test.step('MID', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('MID(BillingPostalCode, 1, 3)');
+    expect(result).toBe('272');
+  });
+
+  await test.step('FIND', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('FIND("formula", Name)');
+    expect(result).toBe('5');
+  });
+
+  // ─── Logical formulas ────────────────────────────────────────
+
+  await test.step('IF with field comparison', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(AnnualRevenue > 1000000, "Enterprise", "SMB")');
+    expect(result).toBe('Enterprise');
+  });
+
+  await test.step('CASE on picklist', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('CASE(Rating, "Hot", 3, "Warm", 2, "Cold", 1, 0)');
+    expect(result).toBe('2');
+  });
+
+  await test.step('AND', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula(
+      'IF(AND(NumberOfEmployees > 1000, AnnualRevenue > 1000000), "Large", "Small")',
+    );
+    expect(result).toBe('Large');
+  });
+
+  await test.step('OR', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula(
+      'IF(OR(ISPICKVAL(Industry, "Apparel"), ISPICKVAL(Industry, "Technology")), "Target", "Other")',
+    );
+    expect(result).toBe('Target');
+  });
+
+  await test.step('NOT', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('NOT(IsDeleted)');
+    expect(result).toBe('true');
+  });
+
+  await test.step('BLANKVALUE on null field', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('BLANKVALUE(Description, "No description")');
+    expect(result).toBe('No description');
+  });
+
+  await test.step('BLANKVALUE on non-null field', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('BLANKVALUE(Website, "N/A")');
+    expect(result).toBe('www.burlington.com');
+  });
+
+  await test.step('ISBLANK', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(ISBLANK(Description), "blank", "not blank")');
+    expect(result).toBe('blank');
+  });
+
+  // ─── Number and math formulas ────────────────────────────────
+
+  await test.step('arithmetic with record fields', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('AnnualRevenue / NumberOfEmployees');
+    expect(Number(result)).toBeCloseTo(38888.89, 0);
+  });
+
+  await test.step('ROUND', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('ROUND(AnnualRevenue / NumberOfEmployees, 2)');
+    expect(result).toBe('38888.89');
+  });
+
+  await test.step('MOD', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('MOD(NumberOfEmployees, 7)');
+    expect(result).toBe('5');
+  });
+
+  await test.step('MAX and MIN', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula(
+      'MAX(NumberOfEmployees, NumberofLocations__c) & "/" & MIN(NumberOfEmployees, NumberofLocations__c)',
+    );
+    expect(result).toBe('9000/6');
+  });
+
+  await test.step('ABS', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('ABS(NumberofLocations__c - NumberOfEmployees)');
+    expect(result).toBe('8994');
+  });
+
+  await test.step('CEILING and FLOOR', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('CEILING(NumberOfEmployees / 7)');
+    expect(result).toBe('1286');
+  });
+
+  await test.step('SQRT', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('SQRT(144)');
+    expect(result).toBe('12');
+  });
+
+  await test.step('POWER', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('POWER(NumberofLocations__c, 2)');
+    expect(result).toBe('36');
+  });
+
+  // ─── Date formulas ───────────────────────────────────────────
+
+  await test.step('YEAR, MONTH, DAY on record date field', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula(
+      'YEAR(SLAExpirationDate__c) & "-" & MONTH(SLAExpirationDate__c) & "-" & DAY(SLAExpirationDate__c)',
+    );
+    expect(result).toBe('2022-1-22');
+  });
+
+  await test.step('TODAY returns current year', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('YEAR(TODAY())');
+    expect(Number(result)).toBeGreaterThanOrEqual(2025);
+  });
+
+  await test.step('ADDMONTHS', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('MONTH(ADDMONTHS(SLAExpirationDate__c, 3))');
+    expect(result).toBe('4');
+  });
+
+  await test.step('date comparison', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(SLAExpirationDate__c < TODAY(), "Expired", "Active")');
+    expect(result).toBe('Expired');
+  });
+
+  // ─── Related record formulas ─────────────────────────────────
+
+  await test.step('Owner.FirstName (related record)', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Owner.FirstName');
+    expect(result).toBe('Integration');
+  });
+
+  await test.step('Owner.LastName (related record)', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Owner.LastName');
+    expect(result).toBe('Test');
+  });
+
+  await test.step('Owner name concatenation', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Owner.FirstName & " " & Owner.LastName');
+    expect(result).toBe('Integration Test');
+  });
+
+  await test.step('Parent.Name (related record)', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Parent.Name');
+    expect(result).toBe('University of Arizona');
+  });
+
+  await test.step('mixed record and related fields', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('Name & " (owned by " & Owner.FirstName & ")"');
+    expect(result).toBe('A - formula test record (owned by Integration)');
+  });
+
+  // ─── Null handling ───────────────────────────────────────────
+
+  await test.step('treat blanks as zero for null field', async () => {
+    await formulaEvaluatorPage.setNullBehavior('ZERO');
+    // AccountSource is null, so BLANKVALUE should return the fallback
+    const result = await formulaEvaluatorPage.evaluateFormula('BLANKVALUE(AccountSource, "None")');
+    expect(result).toBe('None');
+    // Reset null behavior back to BLANK so later tests are not affected
+    await formulaEvaluatorPage.setNullBehavior('BLANK');
+  });
+
+  // ─── Picklist formulas ───────────────────────────────────────
+
+  await test.step('ISPICKVAL matching', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(ISPICKVAL(SLA__c, "Silver"), "match", "no match")');
+    expect(result).toBe('match');
+  });
+
+  await test.step('ISPICKVAL not matching', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(ISPICKVAL(SLA__c, "Gold"), "match", "no match")');
+    expect(result).toBe('no match');
+  });
+
+  // ─── Global variables ────────────────────────────────────────
+
+  await test.step('$User.FirstName', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('$User.FirstName');
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  await test.step('$Organization.Name', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('$Organization.Name');
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  // ─── Previously unsupported functions (broken in formulon) ──
+
+  await test.step('ISNULL on null field', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(ISNULL(Description), "null", "has value")');
+    expect(result).toBe('null');
+  });
+
+  await test.step('ISNULL on non-null field', async () => {
+    const result = await formulaEvaluatorPage.evaluateFormula('IF(ISNULL(Website), "null", "has value")');
+    expect(result).toBe('has value');
+  });
+
+  await test.step('NULLVALUE on null number field', async () => {
+    // YearStarted is null on this record
+    const result = await formulaEvaluatorPage.evaluateFormula('NULLVALUE(YearStarted, 1999)');
+    expect(result).toBe('1999');
+  });
+
+  // ─── Error handling ──────────────────────────────────────────
+
+  await test.step('syntax error shows error message', async () => {
+    const errorText = await formulaEvaluatorPage.evaluateFormulaExpectError('LEFT(Name');
+    expect(errorText.length).toBeGreaterThan(0);
+  });
+
+  await test.step('unknown function shows error message', async () => {
+    const errorText = await formulaEvaluatorPage.evaluateFormulaExpectError('NOTAFUNCTION(Name)');
+    expect(errorText.length).toBeGreaterThan(0);
+  });
+});
diff --git a/formulon.d.ts b/formulon.d.ts
deleted file mode 100644
index f9b9c1d13..000000000
--- a/formulon.d.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-declare module 'formulon' {
-  export type DataType = 'number' | 'text' | 'picklist' | 'multipicklist' | DataTypeNoOption;
-  export type DataTypeNoOption = 'checkbox' | 'date' | 'time' | 'datetime' | 'geolocation' | 'null';
-  export type DataType = 'number' | 'text' | 'checkbox' | 'date' | 'time' | 'datetime' | 'geolocation' | 'null';
-  export type FormulaData = Record<string, FormulaDataValue>;
-  export type FormulaDataValue = AstLiteral | AstLiteralText | AstLiteralNumber | AstLiteralPicklist;
-  export type FormulaResult = AstError | AstNotImplementedError | FormulaDataValue;
-  export type AstResult = AstCallExpression;
-  export type FunctionType =
-    | 'abs'
-    | 'add'
-    | 'addmonths'
-    | 'and'
-    | 'begins'
-    | 'blankvalue'
-    | 'br'
-    | 'case'
-    | 'casesafeid'
-    | 'ceiling'
-    | 'contains'
-    | 'currencyrate'
-    | 'date'
-    | 'datetimevalue'
-    | 'datevalue'
-    | 'day'
-    | 'distance'
-    | 'divide'
-    | 'equal'
-    | 'exp'
-    | 'exponentiate'
-    | 'find'
-    | 'floor'
-    | 'geolocation'
-    | 'getsessionid'
-    | 'greaterthan'
-    | 'greaterthanorequal'
-    | 'hour'
-    | 'hyperlink'
-    | 'if'
-    | 'image'
-    | 'includes'
-    | 'isblank'
-    | 'isnull'
-    | 'isnumber'
-    | 'ispickval'
-    | 'left'
-    | 'len'
-    | 'lessthan'
-    | 'lessthanorequal'
-    | 'ln'
-    | 'log'
-    | 'lower'
-    | 'lpad'
-    | 'max'
-    | 'mceiling'
-    | 'mfloor'
-    | 'mid'
-    | 'millisecond'
-    | 'min'
-    | 'minute'
-    | 'mod'
-    | 'month'
-    | 'multiply'
-    | 'not'
-    | 'now'
-    | 'nullvalue'
-    | 'or'
-    | 'regex'
-    | 'right'
-    | 'round'
-    | 'rpad'
-    | 'second'
-    | 'sqrt'
-    | 'substitute'
-    | 'subtract'
-    | 'text'
-    | 'timenow'
-    | 'timevalue'
-    | 'today'
-    | 'trim'
-    | 'unequal'
-    | 'upper'
-    | 'value'
-    | 'weekday'
-    | 'year';
-
-  export interface AstError {
-    type: 'error';
-    errorType: 'ArgumentError';
-    message: string;
-    name?: string;
-    FunctionType: string;
-    expected: number;
-    received: number;
-  }
-
-  export interface AstNotImplementedError {
-    type: 'error';
-    errorType: 'NotImplementedError';
-    message: string;
-    name: string;
-  }
-
-  export interface AstLiteral {
-    type: 'literal';
-    value: string | number | boolean | null | Date;
-    dataType: DataTypeNoOption;
-    options?: Record<string, any> | null;
-  }
-
-  export interface AstLiteralText {
-    type: 'literal';
-    value: string;
-    dataType: 'text';
-    options: {
-      length: number;
-    };
-  }
-
-  export interface AstLiteralNumber {
-    type: 'literal';
-    value: number;
-    dataType: 'number';
-    options: {
-      length: number;
-      scale: number;
-    };
-  }
-
-  export interface AstLiteralPicklist {
-    type: 'literal';
-    value: number;
-    dataType: 'picklist' | 'multipicklist';
-    options: { values: string[] };
-  }
-
-  export interface AstCallExpression {
-    type: 'callExpression';
-    id: string;
-    arguments: (FormulaResult | AstCallExpression)[];
-  }
-
-  export const parse: (formula: string, substitutions: FormulaData) => FormulaResult;
-  export const extract: (formula: string) => string[];
-  export const ast: (formula: string) => AstCallExpression;
-}
diff --git a/libs/features/create-object-and-fields/src/CreateFieldsFormulaEditor.tsx b/libs/features/create-object-and-fields/src/CreateFieldsFormulaEditor.tsx
index d3d037cc7..ceeda692d 100644
--- a/libs/features/create-object-and-fields/src/CreateFieldsFormulaEditor.tsx
+++ b/libs/features/create-object-and-fields/src/CreateFieldsFormulaEditor.tsx
@@ -2,7 +2,7 @@ import { css } from '@emotion/react';
 import { logger } from '@jetstream/shared/client-logger';
 import { ANALYTICS_KEYS } from '@jetstream/shared/constants';
 import { sanitizePastedEditorText, useDisposables } from '@jetstream/shared/ui-utils';
-import { getErrorMessage, getErrorMessageAndStackObj } from '@jetstream/shared/utils';
+import { NOOP, getErrorMessage, getErrorMessageAndStackObj } from '@jetstream/shared/utils';
 import { SplitWrapper as Split } from '@jetstream/splitjs';
 import { Field, FieldType, Maybe, NullNumberBehavior, SalesforceOrgUi } from '@jetstream/types';
 import { Grid, KeyboardShortcut, Modal, Spinner, Tabs, Textarea } from '@jetstream/ui';
@@ -13,15 +13,19 @@ import {
   FieldValues,
   FormulaEvaluatorRecordSearch,
   FormulaEvaluatorResults,
+  FormulaEvaluatorReturnTypeCombobox,
   FormulaEvaluatorUserSearch,
   ManualFormulaRecord,
   SalesforceFieldType,
+  convertFormulaSecondaryTypeToEvaluatorType,
+  fieldTypeToReturnType,
   getFormulaData,
   registerCompletions,
   useAmplitude,
 } from '@jetstream/ui-core';
+import type { FieldSchema, FormulaContext, FormulaValue } from '@jetstreamapp/sf-formula-parser';
+import { evaluateFormula, extractFields, extractFieldsByCategory } from '@jetstreamapp/sf-formula-parser';
 import Editor, { OnMount, useMonaco } from '@monaco-editor/react';
-import * as formulon from 'formulon';
 import type { editor } from 'monaco-editor';
 import { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
 import CreateFieldsFormulaEditorManualField from './CreateFieldsFormulaEditorManualField';
@@ -59,13 +63,19 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
     const [formulaFields, setFormulaFields] = useState<string[]>([]);
     const [formulaFieldValues, setFormulaFieldValues] = useState<ManualFormulaRecord>({});
 
-    const [results, setResults] = useState<{ formulaFields: formulon.FormulaData; parsedFormula: formulon.FormulaResult } | null>(null);
+    const [results, setResults] = useState<{
+      context: FormulaContext;
+      result: FormulaValue;
+      returnType: ReturnType<typeof fieldTypeToReturnType>;
+    } | null>(null);
 
     const [selectedUserId, setSelectedUserId] = useState('');
     const [recordId, setRecordId] = useState('');
 
     const monaco = useMonaco();
 
+    const formulaReturnType = convertFormulaSecondaryTypeToEvaluatorType(allValues.secondaryType.value as SalesforceFieldType);
+
     useEffect(() => {
       isMounted.current = true;
       return () => {
@@ -85,7 +95,7 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
     useEffect(() => {
       setFormulaFields((prevValue) => {
         try {
-          const fields = formulon.extract(formulaValue || '');
+          const fields = extractFields(formulaValue || '');
           return fields;
         } catch (ex) {
           return prevValue;
@@ -124,23 +134,25 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
           setFormulaErrorMessage(null);
           setResults(null);
 
-          let formulaFieldResults: formulon.FormulaData = {};
+          const categorizedFields = extractFieldsByCategory(value);
+          let context: FormulaContext = { record: {} };
+          let schema: Record<string, FieldSchema[]> | undefined;
+
           if (formulaFields.length) {
             let payload: Parameters<typeof getFormulaData>[0] = {
-              fields: formulaFields,
+              categorizedFields,
               recordId,
               selectedOrg,
               selectedUserId,
               sobjectName: selectedSObjects[0] || '',
-              numberNullBehavior: (allValues.formulaTreatBlanksAs.value as NullNumberBehavior) || 'BLANK',
             };
 
             if (testMethod === 'MANUAL' || !recordId) {
-              // ensure all fields are included in record
+              // Ensure all object fields are included in record with defaults
               const record = {
                 ...formulaFieldValues,
               };
-              formulaFields.forEach((field) => {
+              categorizedFields.objectFields.forEach((field) => {
                 if (!record[field]) {
                   record[field] = {
                     type: 'string',
@@ -149,13 +161,12 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
                 }
               });
               payload = {
-                fields: formulaFields,
+                categorizedFields,
                 type: 'PROVIDED_RECORD',
                 record,
                 selectedOrg,
                 selectedUserId,
                 sobjectName: selectedSObjects[0] || '',
-                numberNullBehavior: (allValues.formulaTreatBlanksAs.value as NullNumberBehavior) || 'BLANK',
               };
             }
 
@@ -164,14 +175,17 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
               setFieldErrorMessage(response.message);
               return;
             }
-            formulaFieldResults = response.formulaFields;
+            context = response.context;
+            schema = response.schema;
           }
-          const parsedFormula = formulon.parse(value, formulaFieldResults);
-          logger.log('results', parsedFormula);
-          setResults({
-            formulaFields: formulaFieldResults,
-            parsedFormula,
+
+          const result = evaluateFormula(value, context, {
+            treatBlanksAsZeroes: (allValues.formulaTreatBlanksAs.value as NullNumberBehavior) !== 'BLANK',
+            returnType: formulaReturnType || undefined,
+            schema,
           });
+          logger.log('results', result);
+          setResults({ context, result, returnType: formulaReturnType });
           trackEvent(ANALYTICS_KEYS.sobj_create_field_formula_execute, { success: true, fieldCount: formulaFields.length, testMethod });
         } catch (ex) {
           logger.warn(ex);
@@ -183,8 +197,9 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
       },
       [
         allValues.formulaTreatBlanksAs.value,
+        allValues.secondaryType.value,
         formulaFieldValues,
-        formulaFields,
+        formulaFields.length,
         recordId,
         selectedOrg,
         selectedSObjects,
@@ -360,6 +375,9 @@ export const CreateFieldsFormulaEditor = forwardRef<unknown, CreateFieldsFormula
                     ]}
                   ></Tabs>
                   <hr className="slds-m-vertical_small" />
+
+                  <FormulaEvaluatorReturnTypeCombobox comboboxProps={{ disabled: true }} returnType={formulaReturnType} onChange={NOOP} />
+
                   <FormulaEvaluatorUserSearch selectedOrg={selectedOrg} disabled={loading} onSelectedRecord={setSelectedUserId} />
                   <button className="slds-button slds-button_brand" onClick={() => handleTestFormula(formulaValue)}>
                     Test Formula
diff --git a/libs/features/formula-evaluator/src/FormulaEvaluator.tsx b/libs/features/formula-evaluator/src/FormulaEvaluator.tsx
index 7d8f1b1f8..a262dc7be 100644
--- a/libs/features/formula-evaluator/src/FormulaEvaluator.tsx
+++ b/libs/features/formula-evaluator/src/FormulaEvaluator.tsx
@@ -1,6 +1,6 @@
 import { css } from '@emotion/react';
 import { logger } from '@jetstream/shared/client-logger';
-import { ANALYTICS_KEYS, TITLES } from '@jetstream/shared/constants';
+import { ANALYTICS_KEYS, SFDC_BLANK_PICKLIST_VALUE, TITLES } from '@jetstream/shared/constants';
 import { clearCacheForOrg } from '@jetstream/shared/data';
 import {
   hasModifierKey,
@@ -12,7 +12,7 @@ import {
 } from '@jetstream/shared/ui-utils';
 import { getErrorMessage, getErrorMessageAndStackObj } from '@jetstream/shared/utils';
 import { SplitWrapper as Split } from '@jetstream/splitjs';
-import { DescribeGlobalSObjectResult } from '@jetstream/types';
+import { DescribeGlobalSObjectResult, Field } from '@jetstream/types';
 import {
   Alert,
   AutoFullHeightContainer,
@@ -36,15 +36,18 @@ import {
 import {
   FormulaEvaluatorRecordSearch,
   FormulaEvaluatorResults,
+  FormulaEvaluatorReturnTypeCombobox,
   FormulaEvaluatorUserSearch,
+  fieldTypeToReturnType,
   fromFormulaState,
   getFormulaData,
   registerCompletions,
   useAmplitude,
 } from '@jetstream/ui-core';
 import { selectedOrgState } from '@jetstream/ui/app-state';
+import type { FieldSchema, FormulaContext, FormulaValue } from '@jetstreamapp/sf-formula-parser';
+import { evaluateFormula, extractFieldsByCategory } from '@jetstreamapp/sf-formula-parser';
 import Editor, { OnMount, useMonaco } from '@monaco-editor/react';
-import * as formulon from 'formulon';
 import { useAtom, useAtomValue } from 'jotai';
 import type { editor } from 'monaco-editor';
 import { FunctionComponent, useCallback, useEffect, useRef, useState } from 'react';
@@ -89,10 +92,15 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
   const [sourceType, setSourceType] = useAtom(fromFormulaState.sourceTypeState);
   const [recordId, setRecordId] = useAtom(fromFormulaState.recordIdState);
   const [numberNullBehavior, setNumberNullBehavior] = useAtom(fromFormulaState.numberNullBehaviorState);
+  const [returnType, setReturnType] = useAtom(fromFormulaState.returnTypeState);
   const [bannerDismissed, setBannerDismissed] = useAtom(fromFormulaState.bannerDismissedState);
   const [deployModalOpen, setDeployModalOpen] = useState(false);
 
-  const [results, setResults] = useState<{ formulaFields: formulon.FormulaData; parsedFormula: formulon.FormulaResult } | null>(null);
+  const [results, setResults] = useState<{
+    context: FormulaContext;
+    result: FormulaValue;
+    returnType: fromFormulaState.FormulaReturnTypeWithEmptyState;
+  } | null>(null);
 
   const deployFormulaDisabled = loading || !selectedSObject || !formulaValue;
   const testFormulaDisabled = loading || !selectedSObject || !selectedUserId || !recordId || !formulaValue;
@@ -117,8 +125,19 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
   useEffect(() => {
     if (sourceType === 'EXISTING' && selectedField) {
       editorRef.current?.setValue(selectedField.calculatedFormula || '');
+      setReturnType(fieldTypeToReturnType(selectedField.type));
     }
-  }, [sourceType, selectedSObject, selectedField]);
+  }, [sourceType, selectedSObject, selectedField, setReturnType]);
+
+  const handleSelectedFieldChange = useCallback(
+    (field: Field | null) => {
+      setSelectedField(field);
+      if (field) {
+        setReturnType(fieldTypeToReturnType(field.type));
+      }
+    },
+    [setSelectedField, setReturnType],
+  );
 
   const handleTestFormula = useCallback(
     async (value: string) => {
@@ -132,32 +151,46 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
         setErrorMessage(null);
         setResults(null);
 
-        const fields = formulon.extract(value);
-        let formulaFields: formulon.FormulaData = {};
+        const categorizedFields = extractFieldsByCategory(value);
+        let context: FormulaContext = { record: {} };
+        let schema: Record<string, FieldSchema[]> | undefined;
 
-        if (fields.length) {
+        const hasFields =
+          categorizedFields.objectFields.length > 0 ||
+          categorizedFields.customMetadata.length > 0 ||
+          categorizedFields.customLabels.length > 0 ||
+          categorizedFields.customSettings.length > 0 ||
+          categorizedFields.customPermissions.length > 0 ||
+          Object.values(categorizedFields.globals).some((fields) => fields.length > 0);
+
+        if (hasFields) {
           const response = await getFormulaData({
-            fields,
+            categorizedFields,
             recordId,
             selectedOrg,
             selectedUserId,
             sobjectName: selectedSObject?.name || '',
-            numberNullBehavior,
           });
           if (response.type === 'error') {
             setFieldErrorMessage(response.message);
             return;
           }
-          formulaFields = response.formulaFields;
+          context = response.context;
+          schema = response.schema;
         }
 
-        const parsedFormula = formulon.parse(value, formulaFields);
-        logger.log('results', parsedFormula);
-        setResults({
-          formulaFields,
-          parsedFormula,
+        const result = evaluateFormula(value, context, {
+          treatBlanksAsZeroes: numberNullBehavior === 'ZERO',
+          returnType: !returnType || returnType === SFDC_BLANK_PICKLIST_VALUE ? undefined : returnType,
+          schema,
+        });
+        logger.log('results', result);
+        setResults({ context, result, returnType });
+        trackEvent(ANALYTICS_KEYS.formula_execute, {
+          success: true,
+          fieldCount: categorizedFields.objectFields.length,
+          objectPrefix: recordId.substring(0, 3),
         });
-        trackEvent(ANALYTICS_KEYS.formula_execute, { success: true, fieldCount: fields.length, objectPrefix: recordId.substring(0, 3) });
       } catch (ex) {
         logger.error(ex);
         setErrorMessage(getErrorMessage(ex));
@@ -166,7 +199,7 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
         setLoading(false);
       }
     },
-    [testFormulaDisabled, trackEvent, recordId, selectedOrg, selectedSObject?.name, numberNullBehavior],
+    [testFormulaDisabled, numberNullBehavior, returnType, trackEvent, recordId, selectedOrg, selectedUserId, selectedSObject?.name],
   );
 
   const onKeydown = useCallback(
@@ -214,7 +247,7 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
   const handleFormatRef = useRef(handleFormat);
   handleFormatRef.current = handleFormat;
 
-  function handleEditorChange(value?: string, event?: unknown) {
+  function handleEditorChange(value?: string) {
     setFormulaValue(value || '');
   }
 
@@ -281,7 +314,7 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
       >
         {!bannerDismissed && (
           <Alert type="info" leadingIcon="info" className="slds-m-bottom_xx-small" allowClose onClose={() => setBannerDismissed(true)}>
-            Formulas in Jetstream may evaluate different from Salesforce and not every formula function is supported.
+            Formulas in Jetstream may evaluate differently from Salesforce, and not every formula function is supported.
           </Alert>
         )}
         <Split
@@ -371,11 +404,16 @@ export const FormulaEvaluator: FunctionComponent<FormulaEvaluatorProps> = () =>
                         selectedField={selectedField}
                         disabled={loading}
                         filterFn={(field) => !!field.calculatedFormula}
-                        onSelectField={setSelectedField}
+                        onSelectField={handleSelectedFieldChange}
                       />
                     )}
                   </Grid>
                 )}
+                <FormulaEvaluatorReturnTypeCombobox
+                  comboboxProps={{ disabled: loading }}
+                  returnType={returnType}
+                  onChange={setReturnType}
+                />
               </Grid>
 
               <Grid className="slds-m-top_x-small" align="spread">
diff --git a/libs/features/query/src/QueryResults/QueryResults.tsx b/libs/features/query/src/QueryResults/QueryResults.tsx
index 5f7a903ab..a6033fdc0 100644
--- a/libs/features/query/src/QueryResults/QueryResults.tsx
+++ b/libs/features/query/src/QueryResults/QueryResults.tsx
@@ -511,7 +511,7 @@ export const QueryResults = React.memo(() => {
 
   function handleGetAsApex(record: any) {
     setGetRecordAsApex({
-      record: record,
+      record,
       sobjectName: getSObjectNameFromAttributes(record),
     });
   }
diff --git a/libs/shared/ui-core/src/create-fields/create-fields-utils.tsx b/libs/shared/ui-core/src/create-fields/create-fields-utils.tsx
index 9ca5e8999..fbd370d4d 100644
--- a/libs/shared/ui-core/src/create-fields/create-fields-utils.tsx
+++ b/libs/shared/ui-core/src/create-fields/create-fields-utils.tsx
@@ -12,6 +12,7 @@ import {
   SalesforceOrgUi,
   ToolingApiResponse,
 } from '@jetstream/types';
+import { FormulaReturnType } from '@jetstreamapp/sf-formula-parser';
 import { composeQuery, getField } from '@jetstreamapp/soql-parser-js';
 import isBoolean from 'lodash/isBoolean';
 import isNil from 'lodash/isNil';
@@ -74,6 +75,18 @@ export function ensureValidSecondaryType(type: string): string {
   return 'Text';
 }
 
+export function convertFormulaSecondaryTypeToEvaluatorType(type: SalesforceFieldType): FormulaReturnType {
+  return ({
+    checkbox: 'boolean',
+    currency: 'number',
+    date: 'date',
+    datetime: 'datetime',
+    number: 'number',
+    percent: 'number',
+    time: 'time',
+  }[type.toLowerCase()] || 'string') as FormulaReturnType;
+}
+
 export const fieldDefinitions: FieldDefinitions = {
   type: {
     label: 'Type',
diff --git a/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorResults.tsx b/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorResults.tsx
index a7c5a1d4c..89e37ffe3 100644
--- a/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorResults.tsx
+++ b/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorResults.tsx
@@ -1,29 +1,95 @@
 import { Maybe } from '@jetstream/types';
 import { Grid, ScopedNotification } from '@jetstream/ui';
+import type { FormulaContext, FormulaRecord, FormulaValue } from '@jetstreamapp/sf-formula-parser';
+import { isFormulaValue } from '@jetstreamapp/sf-formula-parser';
 import { formatISO } from 'date-fns/formatISO';
 import { isValid } from 'date-fns/isValid';
-import * as formulon from 'formulon';
 import { FunctionComponent } from 'react';
+import { FormulaReturnTypeWithEmptyState } from '../state-management/formula-evaluator.state';
 
 export interface FormulaEvaluatorResultsProps {
   errorMessage?: Maybe<string>;
   results: {
-    formulaFields: formulon.FormulaData;
-    parsedFormula: formulon.FormulaResult;
+    context: FormulaContext;
+    result: FormulaValue;
+    returnType: FormulaReturnTypeWithEmptyState;
   } | null;
 }
 
-function getValue(value: string | number | boolean | null | Date): string {
+function formatValue(value: FormulaValue, returnType: FormulaReturnTypeWithEmptyState): string | null {
   try {
+    if (value == null) {
+      return null;
+    }
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
       return String(value);
     }
     if (value instanceof Date && isValid(value)) {
-      return formatISO(value, { representation: 'date' });
+      if (returnType === 'date') {
+        return formatISO(value, { representation: 'date' });
+      }
+      return formatISO(value);
+    }
+    if (typeof value === 'object') {
+      if ('timeInMillis' in value) {
+        const totalMs = value.timeInMillis;
+        const hours = Math.floor(totalMs / 3600000);
+        const minutes = Math.floor((totalMs % 3600000) / 60000);
+        const seconds = Math.floor((totalMs % 60000) / 1000);
+        return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+      }
+      if ('latitude' in value && 'longitude' in value) {
+        return `(${value.latitude}, ${value.longitude})`;
+      }
     }
-    return 'null';
+    return null;
   } catch {
-    return 'null';
+    return null;
+  }
+}
+
+/**
+ * Flatten a FormulaContext into a list of display-friendly key/value pairs.
+ * Record fields are shown as-is, globals are prefixed with their category.
+ */
+function flattenContextForDisplay(
+  context: FormulaContext,
+  returnType: FormulaReturnTypeWithEmptyState,
+): { field: string; value: string | null }[] {
+  const entries: { field: string; value: string | null }[] = [];
+
+  // Record fields (may contain nested relationships like Owner.FirstName)
+  for (const [key, val] of Object.entries(context.record)) {
+    if (isFormulaValue(val)) {
+      entries.push({ field: key, value: formatValue(val, returnType) });
+    } else {
+      flattenRecord(key, val, entries, returnType);
+    }
+  }
+
+  // Global fields
+  if (context.globals) {
+    for (const [prefix, record] of Object.entries(context.globals)) {
+      flattenRecord(prefix, record, entries, returnType);
+    }
+  }
+
+  return entries;
+}
+
+function flattenRecord(
+  prefix: string,
+  record: FormulaRecord,
+  entries: { field: string; value: string | null }[],
+  returnType: FormulaReturnTypeWithEmptyState,
+) {
+  for (const [key, val] of Object.entries(record)) {
+    const fullKey = `${prefix}.${key}`;
+    if (isFormulaValue(val)) {
+      entries.push({ field: fullKey, value: formatValue(val, returnType) });
+    } else {
+      flattenRecord(fullKey, val, entries, returnType);
+    }
   }
 }
 
@@ -31,7 +97,7 @@ export const FormulaEvaluatorResults: FunctionComponent<FormulaEvaluatorResultsP
   return (
     <>
       {errorMessage && (
-        <div className="slds-m-around-medium">
+        <div className="slds-m-around-medium" data-testid="formula-error">
           <ScopedNotification theme="error" className="slds-m-top_medium">
             {errorMessage}
           </ScopedNotification>
@@ -39,34 +105,29 @@ export const FormulaEvaluatorResults: FunctionComponent<FormulaEvaluatorResultsP
       )}
       {results && (
         <Grid vertical>
-          {!!Object.keys(results.formulaFields).length && (
-            <>
-              <div className="slds-text-heading_small slds-m-top_small">Record Fields</div>
-              <div className="slds-m-top_xx-small slds-m-bottom_small slds-p-left_small">
-                {Object.keys(results.formulaFields).map((field) => {
-                  const { value } = results.formulaFields[field];
-                  return (
+          {(() => {
+            const displayFields = flattenContextForDisplay(results.context, results.returnType);
+            if (!displayFields.length) {
+              return null;
+            }
+            return (
+              <>
+                <div className="slds-text-heading_small slds-m-top_small">Record Fields</div>
+                <div className="slds-m-top_xx-small slds-m-bottom_small slds-p-left_small" data-testid="formula-record-fields">
+                  {displayFields.map(({ field, value }) => (
                     <div key={field}>
-                      <span className="text-bold">{field}</span>: {String(value) || '<blank>'}
+                      <span className="text-bold">{field}</span>: {value ?? '<blank>'}
                     </div>
-                  );
-                })}
-              </div>
-            </>
-          )}
+                  ))}
+                </div>
+              </>
+            );
+          })()}
           <div className="slds-text-heading_small slds-m-top_small">Formula Results</div>
           <div className="slds-m-top_xx-small slds-m-bottom_small slds-p-left_small">
-            {results.parsedFormula.type === 'error' ? (
-              <Grid vertical className="slds-text-color_error">
-                <div>{results.parsedFormula.errorType}</div>
-                <div>{results.parsedFormula.message}</div>
-                {results.parsedFormula.errorType === 'NotImplementedError' && results.parsedFormula.name === 'isnull' && (
-                  <div>Use ISBLANK instead</div>
-                )}
-              </Grid>
-            ) : (
-              <div className="slds-text-color_success">{getValue(results.parsedFormula.value) ?? '<blank>'}</div>
-            )}
+            <div className="slds-text-color_success" data-testid="formula-result">
+              {formatValue(results.result, results.returnType) ?? '<blank>'}
+            </div>
           </div>
         </Grid>
       )}
diff --git a/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorReturnTypeCombobox.tsx b/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorReturnTypeCombobox.tsx
new file mode 100644
index 000000000..825469566
--- /dev/null
+++ b/libs/shared/ui-core/src/formula-evaluator/FormulaEvaluatorReturnTypeCombobox.tsx
@@ -0,0 +1,42 @@
+import { SFDC_BLANK_PICKLIST_VALUE } from '@jetstream/shared/constants';
+import { ListItem } from '@jetstream/types';
+import { ComboboxSharedProps, ComboboxWithItems } from '@jetstream/ui';
+import { FunctionComponent } from 'react';
+import { FormulaReturnTypeWithEmptyState } from '../state-management/formula-evaluator.state';
+
+const RETURN_TYPE_ITEMS: ListItem[] = [
+  { id: 'string', label: 'Text', value: 'string' },
+  { id: 'number', label: 'Number', value: 'number' },
+  { id: 'boolean', label: 'Checkbox', value: 'boolean' },
+  { id: 'date', label: 'Date', value: 'date' },
+  { id: 'datetime', label: 'Date/Time', value: 'datetime' },
+  { id: 'time', label: 'Time', value: 'time' },
+  { id: SFDC_BLANK_PICKLIST_VALUE, label: '--Skip Type Validation--', value: SFDC_BLANK_PICKLIST_VALUE },
+];
+
+export interface FormulaEvaluatorReturnTypeComboboxProps {
+  comboboxProps?: Partial<ComboboxSharedProps>;
+  returnType: FormulaReturnTypeWithEmptyState;
+  onChange: (returnType: FormulaReturnTypeWithEmptyState) => void;
+}
+
+export const FormulaEvaluatorReturnTypeCombobox: FunctionComponent<FormulaEvaluatorReturnTypeComboboxProps> = ({
+  comboboxProps,
+  returnType,
+  onChange,
+}) => {
+  return (
+    <ComboboxWithItems
+      comboboxProps={{
+        label: 'Output Type',
+        helpText: 'The expected return type of the formula. Validates the result matches this type.',
+        placeholder: 'Select output type...',
+        onClear: () => onChange(null),
+        ...comboboxProps,
+      }}
+      items={RETURN_TYPE_ITEMS}
+      selectedItemId={returnType}
+      onSelected={(item) => onChange(item.value as FormulaReturnTypeWithEmptyState)}
+    />
+  );
+};
diff --git a/libs/shared/ui-core/src/formula-evaluator/formula-evaluator.utils.ts b/libs/shared/ui-core/src/formula-evaluator/formula-evaluator.utils.ts
index 8428015f1..e3a325196 100644
--- a/libs/shared/ui-core/src/formula-evaluator/formula-evaluator.utils.ts
+++ b/libs/shared/ui-core/src/formula-evaluator/formula-evaluator.utils.ts
@@ -1,336 +1,305 @@
 import { logger } from '@jetstream/shared/client-logger';
-import { query, queryAll, readMetadata } from '@jetstream/shared/data';
+import { describeSObject, query, queryAll, readMetadata } from '@jetstream/shared/data';
 import { groupByFlat } from '@jetstream/shared/utils';
 import {
   Field,
-  FormulaFieldsByType,
+  FieldType,
   Maybe,
-  NullNumberBehavior,
   PermissionSetMetadataRecord,
   ProfileMetadataRecord,
   QueryResultsColumn,
   QueryResultsColumns,
   SalesforceOrgUi,
 } from '@jetstream/types';
-import { fetchMetadataFromSoql } from '@jetstream/ui-core/shared';
+import type {
+  ExtractedFields,
+  FieldSchema,
+  FormulaContext,
+  FormulaRecord,
+  FormulaReturnType,
+  FormulaValue,
+  SfTime,
+} from '@jetstreamapp/sf-formula-parser';
 import { composeQuery, getField } from '@jetstreamapp/soql-parser-js';
 import { parseISO } from 'date-fns/parseISO';
 import { startOfDay } from 'date-fns/startOfDay';
-import * as formulon from 'formulon';
-import { DataType, FormulaDataValue } from 'formulon';
 import lodashGet from 'lodash/get';
-import isNil from 'lodash/isNil';
-import isString from 'lodash/isString';
-import { ManualFormulaRecord } from '../create-fields/create-fields-types';
-
-const MATCH_FORMULA_SPECIAL_LABEL = /^\$[a-zA-Z]+\./;
-
-export function getFormulonTypeFromColumnType(col: QueryResultsColumn): DataType {
-  if (col.booleanType) {
-    return 'checkbox';
-  } else if (col.numberType) {
-    return 'number';
-  } else if (col.apexType === 'Date') {
-    return 'date';
-  } else if (col.apexType === 'Time') {
-    return 'time';
-  } else if (col.apexType === 'Datetime') {
-    return 'datetime';
-  } else if (col.apexType === 'Location') {
-    return 'geolocation';
-  }
-  return 'text';
+import lodashSet from 'lodash/set';
+import { ManualFormulaFieldType, ManualFormulaRecord } from '../create-fields/create-fields-types';
+
+const MATCH_FORMULA_SPECIAL_PREFIX = /^\$[a-zA-Z]+\./;
+
+const FIELD_TYPE_TO_RETURN_TYPE: Partial<Record<FieldType, FormulaReturnType>> = {
+  string: 'string',
+  textarea: 'string',
+  phone: 'string',
+  url: 'string',
+  email: 'string',
+  picklist: 'string',
+  multipicklist: 'string',
+  encryptedstring: 'string',
+  id: 'string',
+  reference: 'string',
+  combobox: 'string',
+  boolean: 'boolean',
+  int: 'number',
+  double: 'number',
+  currency: 'number',
+  percent: 'number',
+  date: 'date',
+  datetime: 'datetime',
+  time: 'time',
+};
+
+/** Map a Salesforce field type to a formula return type for the returnType option. */
+export function fieldTypeToReturnType(fieldType: FieldType): FormulaReturnType | null {
+  return FIELD_TYPE_TO_RETURN_TYPE[fieldType] ?? null;
 }
 
-export function getFormulonTypeFromMetadata<T extends { type: Field['type'] }>(col: T): DataType {
-  if (col.type === 'boolean') {
-    return 'checkbox';
-  } else if (col.type === 'double' || col.type === 'currency' || col.type === 'percent' || col.type === 'int') {
-    return 'number';
-  } else if (col.type === 'date') {
-    return 'date';
-  } else if (col.type === 'time') {
-    return 'time';
-  } else if (col.type === 'datetime') {
-    return 'datetime';
-  } else if (col.type === 'location') {
-    return 'geolocation';
-  } else if (col.type === 'picklist') {
-    return 'picklist';
-  } else if (col.type === 'multipicklist') {
-    return 'multipicklist';
-  }
-  return 'text';
-}
+/** The global variable keys that map to describable SObjects. */
+const GLOBAL_SOBJECT_MAP: Record<string, string> = {
+  $User: 'User',
+  $Organization: 'Organization',
+  $Profile: 'Profile',
+  $UserRole: 'UserRole',
+};
 
 /**
- * Function that determines if the provided value is of type QueryResultsColumn or Field
+ * Convert a SOQL query result value to a FormulaValue based on column type.
+ * Dates and times need explicit conversion from ISO strings; everything else passes through.
  */
-function isQueryResultsColumn(col: QueryResultsColumn | Field | { type: Field['type'] }): col is QueryResultsColumn {
-  return (col as QueryResultsColumn).booleanType !== undefined;
-}
-
-export function getFormulonData(
-  col: QueryResultsColumn | Field | { type: Field['type'] },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  value: any,
-  numberNullBehavior = 'ZERO',
-): FormulaDataValue {
-  const dataType = isQueryResultsColumn(col) ? getFormulonTypeFromColumnType(col) : getFormulonTypeFromMetadata(col);
-  if (dataType === 'text') {
-    return {
-      type: 'literal',
-      dataType,
-      value: value || '',
-      options: {
-        length: value?.length || 0,
-      },
-    };
+function convertQueryValue(col: QueryResultsColumn, value: unknown): FormulaValue {
+  if (value == null) {
+    return null;
   }
-  if (dataType === 'number') {
-    const { length, scale } =
-      isQueryResultsColumn(col) || !('precision' in col) || !('scale' in col)
-        ? {
-            length: getPrecision(value) - 18,
-            scale: getPrecision(value),
-          }
-        : {
-            length: (isNil(col.precision) ? getPrecision(value) : col.precision) - col.scale,
-            scale: col.scale,
-          };
-    return {
-      type: 'literal',
-      dataType,
-      value: isNil(value) ? (numberNullBehavior === 'ZERO' ? 0 : '') : value,
-      options: {
-        length,
-        scale,
-      },
-    };
-  }
-  if (dataType === 'date') {
-    return {
-      type: 'literal',
-      dataType,
-      value: isNil(value) ? null : startOfDay(parseISO(value)),
-      options: {},
-    };
+  if (col.apexType === 'Date' && typeof value === 'string') {
+    return startOfDay(parseISO(value));
   }
-  if (dataType === 'datetime') {
-    return {
-      type: 'literal',
-      dataType,
-      value: isNil(value) ? null : parseISO(value),
-      options: {},
-    };
+  if (col.apexType === 'Datetime' && typeof value === 'string') {
+    return parseISO(value);
   }
-  if (dataType === 'picklist' || dataType === 'multipicklist') {
-    return {
-      type: 'literal',
-      dataType,
-      value: value || '',
-      options: {
-        values: (col as Field).picklistValues?.map(({ value }) => value) || [],
-      },
-    };
+  if (col.apexType === 'Time' && typeof value === 'string') {
+    return parseSfTime(value);
   }
-  return {
-    type: 'literal',
-    dataType,
-    value,
-  };
+  return value as FormulaValue;
 }
 
-function getPrecision(a: number | string) {
-  a = isString(a) ? Number(a) : a;
-  if (!isFinite(a)) {
-    return 0;
+/**
+ * Convert a manually-provided field value based on its Salesforce field type.
+ */
+function convertManualValue(fieldType: ManualFormulaFieldType, value: unknown): FormulaValue {
+  if (value == null) {
+    return null;
+  }
+  if (fieldType === 'date' && typeof value === 'string') {
+    return startOfDay(parseISO(value));
   }
-  let e = 1;
-  let p = 0;
-  while (Math.round(a * e) / e !== a) {
-    e *= 10;
-    p++;
+  if (fieldType === 'datetime' && typeof value === 'string') {
+    return parseISO(value);
   }
-  return p;
+  if (fieldType === 'time' && typeof value === 'string') {
+    return parseSfTime(value);
+  }
+  return value as FormulaValue;
+}
+
+/** Parse a Salesforce time string (HH:mm:ss.SSS[Z]) to an SfTime object */
+function parseSfTime(value: string): SfTime {
+  const parts = value.split(':');
+  const hours = Number(parts[0] || 0);
+  const minutes = Number(parts[1] || 0);
+  const secondsParts = (parts[2] || '0').split('.');
+  const seconds = Number((secondsParts[0] || '0').replace(/\D/g, '') || 0);
+  const fractionDigits = (secondsParts[1] || '').replace(/\D/g, '');
+  const ms = fractionDigits ? Number((fractionDigits + '000').slice(0, 3)) : 0;
+  return { timeInMillis: (hours * 3600 + minutes * 60 + seconds) * 1000 + ms };
 }
 
 interface FormulaDataProps {
   selectedOrg: SalesforceOrgUi;
   selectedUserId: string;
-  fields: string[];
+  categorizedFields: ExtractedFields;
   /**
-   * If recordId is provided, the record will be queried from the org
-   * In this case, type can be omitted, if provided it should be 'QUERY_RECORD'
+   * If recordId is provided, the record will be queried from the org.
+   * In this case, type can be omitted, if provided it should be 'QUERY_RECORD'.
    */
   type?: 'QUERY_RECORD';
   recordId: string;
   record?: never;
   sobjectName: string;
-  numberNullBehavior: NullNumberBehavior;
 }
 
 interface FormulaDataProvidedRecordProps {
   selectedOrg: SalesforceOrgUi;
   selectedUserId: string;
-  fields: string[];
+  categorizedFields: ExtractedFields;
   /**
-   * If record is provided, the record will be used directly instead of querying from the org
+   * If record is provided, the record will be used directly instead of querying from the org.
    */
   type: 'PROVIDED_RECORD';
   recordId?: never;
   record: ManualFormulaRecord;
   sobjectName: string;
-  numberNullBehavior: NullNumberBehavior;
 }
 
 export async function getFormulaData({
   selectedOrg,
   selectedUserId,
-  fields,
+  categorizedFields,
   type = 'QUERY_RECORD',
   recordId,
   record,
   sobjectName,
-  numberNullBehavior = 'ZERO',
 }: FormulaDataProps | FormulaDataProvidedRecordProps): Promise<
   | { type: 'error'; message: string }
-  | { type: 'success'; formulaFields: formulon.FormulaData; warnings: { type: string; message: string }[] }
+  | { type: 'success'; context: FormulaContext; schema: Record<string, FieldSchema[]>; warnings: { type: string; message: string }[] }
 > {
   try {
-    const formulaFields: formulon.FormulaData = {};
-    const warnings = [];
-
-    const {
-      objectFields,
-      apiFields,
-      customMetadata,
-      customLabels,
-      organization,
-      customPermissions,
-      profile,
-      customSettings,
-      system,
-      user,
-      userRole,
-    } = fields.reduce(
-      (output: FormulaFieldsByType, field) => {
-        if (!field.startsWith('$')) {
-          output.objectFields.push(field);
-        } else {
-          const identifier = field.toLowerCase().split('.')[0];
-          switch (identifier) {
-            case '$api':
-              output.apiFields.push(field);
-              break;
-            case '$custommetadata':
-              output.customMetadata.push(field);
-              break;
-            case '$label':
-              output.customLabels.push(field);
-              break;
-            case '$organization':
-              output.organization.push(field);
-              break;
-            case '$permission':
-              output.customPermissions.push(field);
-              break;
-            case '$profile':
-              output.profile.push(field);
-              break;
-            case '$setup':
-              output.customSettings.push(field);
-              break;
-            case '$system':
-              output.system.push(field);
-              break;
-            case '$user':
-              output.user.push(field);
-              break;
-            case '$userrole':
-              output.userRole.push(field);
-              break;
-            default:
-              break;
-          }
-        }
-        return output;
-      },
-      {
-        objectFields: [],
-        apiFields: [],
-        customMetadata: [],
-        customLabels: [],
-        organization: [],
-        customPermissions: [],
-        profile: [],
-        customSettings: [],
-        system: [],
-        user: [],
-        userRole: [],
-      },
-    );
+    const formulaRecord: FormulaRecord = {};
+    const globals: Record<string, FormulaRecord> = {};
+    const warnings: { type: string; message: string }[] = [];
+    const schema: Record<string, FieldSchema[]> = {};
+
+    const { objectFields, globals: globalFields, customMetadata, customLabels, customSettings, customPermissions } = categorizedFields;
+
+    const userFields = globalFields['$User'] || [];
+    const organizationFields = globalFields['$Organization'] || [];
+    const profileFields = globalFields['$Profile'] || [];
+    const userRoleFields = globalFields['$UserRole'] || [];
+    const apiFields = globalFields['$Api'] || [];
+    const systemFields = globalFields['$System'] || [];
+
+    // Collect schema metadata for the root SObject and any related/global objects
+    await collectSchema({ selectedOrg, sobjectName, objectFields, globalFields, schema });
 
-    // TODO: this is a good candidate for unit tests
-    // TODO: collect warnings
-    // These should also be somewhat forgiving
     if (type === 'QUERY_RECORD' && recordId) {
-      await collectBaseQueriedRecordFields({ selectedOrg, fields: objectFields, recordId, sobjectName, formulaFields, numberNullBehavior });
+      await collectBaseQueriedRecordFields({ selectedOrg, fields: objectFields, recordId, sobjectName, output: formulaRecord });
     } else {
-      await collectBaseRecordFields({
-        fields,
-        record: record || {},
-        formulaFields,
-        numberNullBehavior,
-      });
+      collectBaseRecordFields({ fields: objectFields, manualRecord: record || {}, output: formulaRecord });
     }
 
-    collectApiFields({ selectedOrg, fields: apiFields, formulaFields, numberNullBehavior });
-    await collectCustomMetadata({ selectedOrg, fields: customMetadata, formulaFields, numberNullBehavior });
-    await collectCustomSettingFields({ selectedOrg, selectedUserId, fields: customSettings, formulaFields, numberNullBehavior });
-    await collectCustomPermissions({ selectedOrg, selectedUserId, fields: customPermissions, formulaFields, numberNullBehavior });
-    await collectLabels({ selectedOrg, fields: customLabels, formulaFields, numberNullBehavior });
-    await collectOrganizationFields({ selectedOrg, fields: organization, formulaFields, numberNullBehavior });
+    collectApiFields({ selectedOrg, fields: apiFields, globals });
+    await collectCustomMetadata({ selectedOrg, fields: customMetadata, globals });
+    await collectCustomSettingFields({ selectedOrg, selectedUserId, fields: customSettings, globals });
+    await collectCustomPermissions({ selectedOrg, selectedUserId, fields: customPermissions, globals });
+    await collectLabels({ selectedOrg, fields: customLabels, globals });
+    await collectOrganizationFields({ selectedOrg, fields: organizationFields, globals });
     await collectUserProfileAndRoleFields({
       selectedOrg,
       selectedUserId,
-      userFields: user,
-      profileFields: profile,
-      roleFields: userRole,
-      formulaFields,
-      numberNullBehavior,
+      userFields,
+      profileFields,
+      roleFields: userRoleFields,
+      globals,
     });
-    await collectSystemFields({ fields: system, formulaFields });
+    collectSystemFields({ fields: systemFields, globals });
 
-    logger.log({ formulaFields, warnings });
+    const context: FormulaContext = { record: formulaRecord };
+    if (Object.keys(globals).length) {
+      context.globals = globals;
+    }
+
+    logger.log({ context, schema, warnings });
 
-    return { type: 'success', formulaFields, warnings };
+    return { type: 'success', context, schema, warnings };
   } catch (ex) {
     logger.error(ex);
     throw ex;
   }
 }
 
+/**
+ * Collect schema metadata for the root SObject, any related objects referenced in objectFields,
+ * and any global variables ($User, $Organization, etc.) referenced in globalFields.
+ *
+ * The schema map uses '$record' for the root object, relationship names for related objects,
+ * and '$'-prefixed names for globals — matching the sf-formula-parser SchemaInput format.
+ */
+async function collectSchema({
+  selectedOrg,
+  sobjectName,
+  objectFields,
+  globalFields,
+  schema,
+}: {
+  selectedOrg: SalesforceOrgUi;
+  sobjectName: string;
+  objectFields: string[];
+  globalFields: Record<string, string[]>;
+  schema: Record<string, FieldSchema[]>;
+}) {
+  const describeCache: Record<string, Field[]> = {};
+
+  async function describeFields(sObjectName: string): Promise<Field[]> {
+    if (describeCache[sObjectName]) {
+      return describeCache[sObjectName];
+    }
+    try {
+      const { data } = await describeSObject(selectedOrg, sObjectName);
+      describeCache[sObjectName] = data.fields;
+      return data.fields;
+    } catch (ex) {
+      logger.warn(`Could not describe ${sObjectName} for schema validation`, ex);
+      return [];
+    }
+  }
+
+  // Root SObject — always describe so we can validate direct field references
+  const rootFields = await describeFields(sobjectName);
+  if (rootFields.length) {
+    schema['$record'] = rootFields;
+  }
+
+  // Related objects referenced via dot-notation in objectFields (e.g. "Account.Name", "Owner.Profile.Name")
+  const relationshipNames = new Set<string>();
+  for (const field of objectFields) {
+    const dotIndex = field.indexOf('.');
+    if (dotIndex > -1) {
+      relationshipNames.add(field.substring(0, dotIndex));
+    }
+  }
+
+  for (const relationshipName of relationshipNames) {
+    const relField = rootFields.find(
+      (field) => field.relationshipName && field.relationshipName.toLowerCase() === relationshipName.toLowerCase(),
+    );
+    if (relField?.referenceTo?.length) {
+      const relatedFields = await describeFields(relField.referenceTo[0]);
+      if (relatedFields.length) {
+        schema[relationshipName] = relatedFields;
+      }
+    }
+  }
+
+  // Global variables that map to describable SObjects
+  for (const [globalKey, sObjectName] of Object.entries(GLOBAL_SOBJECT_MAP)) {
+    if (globalFields[globalKey]?.length) {
+      const fields = await describeFields(sObjectName);
+      if (fields.length) {
+        schema[globalKey] = fields;
+      }
+    }
+  }
+}
+
 async function collectBaseQueriedRecordFields({
   selectedOrg,
   fields,
   recordId,
   sobjectName,
-  formulaFields,
-  numberNullBehavior,
+  output,
 }: {
   selectedOrg: SalesforceOrgUi;
   fields: string[];
   recordId: string;
   sobjectName: string;
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  output: FormulaRecord;
 }) {
   if (!fields.length) {
     return;
   }
 
-  const { queryResults, columns, parsedQuery } = await query(
+  const { queryResults, columns } = await query(
     selectedOrg,
     composeQuery({
       fields: fields.map(getField),
@@ -351,69 +320,55 @@ async function collectBaseQueriedRecordFields({
   }
 
   const fieldsByName = getFieldsByName(columns);
-  let lowercaseFieldMap: Record<string, Field> = {};
-  if (parsedQuery) {
-    lowercaseFieldMap = (await fetchMetadataFromSoql(selectedOrg, parsedQuery)).lowercaseFieldMap;
-  }
 
+  output['Id'] = recordId;
   fields.forEach((field) => {
-    // Prefer to get field from actual metadata, otherwise picklist is not handled and can cause formula errors
-    const column = lowercaseFieldMap[field.toLowerCase()] || fieldsByName[field.toLowerCase()];
-    if (!column || !fieldsByName[field.toLowerCase()]) {
+    const column = fieldsByName[field.toLowerCase()];
+    if (!column) {
       throw new Error(`Field ${field} does not exist on ${sobjectName}.`);
     }
-    formulaFields['Id'] = { type: 'literal', dataType: 'text', value: recordId, options: { length: 18 } };
-    formulaFields[field] = getFormulonData(
-      column,
-      lodashGet(queryResults.records[0], fieldsByName[field.toLowerCase()].columnFullPath),
-      numberNullBehavior,
-    );
+    lodashSet(output, field, convertQueryValue(column, lodashGet(queryResults.records[0], column.columnFullPath)));
   });
 }
 
-async function collectBaseRecordFields({
+function collectBaseRecordFields({
   fields,
-  record,
-  formulaFields,
-  numberNullBehavior,
+  manualRecord,
+  output,
 }: {
   fields: string[];
-  record: ManualFormulaRecord;
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  manualRecord: ManualFormulaRecord;
+  output: FormulaRecord;
 }) {
   if (!fields.length) {
     return;
   }
 
   fields.forEach((field) => {
-    // Prefer to get field from actual metadata, otherwise picklist is not handled and can cause formula errors
-    const recordValue = record[field];
+    const recordValue = manualRecord[field];
     if (!recordValue) {
       throw new Error(`Field ${field} does not exist in provided record data.`);
     }
-    const { type, value } = recordValue;
-
-    formulaFields[field] = getFormulonData({ type }, value, numberNullBehavior);
+    output[field] = convertManualValue(recordValue.type, recordValue.value);
   });
 }
 
 function collectApiFields({
   selectedOrg,
   fields,
-  formulaFields,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
   }
 
+  const apiGlobals: FormulaRecord = {};
   fields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
+    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
     let value: string;
     if (field.toLowerCase() === 'session_id') {
       value = '*****';
@@ -425,21 +380,19 @@ function collectApiFields({
         apiVersion.length - 1,
       )}.0/${selectedOrg.organizationId.substring(0, 15)}`;
     }
-
-    formulaFields[fieldWithIdentifier] = { type: 'literal', dataType: 'text', value, options: { length: value.length } };
+    apiGlobals[field] = value;
   });
+  globals['$Api'] = apiGlobals;
 }
 
 async function collectCustomMetadata({
   selectedOrg,
   fields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
@@ -462,13 +415,13 @@ async function collectCustomMetadata({
     {},
   );
 
-  // Query each metadata object, extract fields, and add to formulaFields
+  const customMetadataGlobals: FormulaRecord = {};
+
   for (const metadataObject of Object.keys(data)) {
     const { records } = data[metadataObject];
-    const { queryResults, parsedQuery, columns } = await query(
+    const { queryResults, columns } = await query(
       selectedOrg,
       composeQuery({
-        // we could use actual fields instead of all if these has performance issues
         fields: [{ type: 'FieldFunctionExpression', functionName: 'FIELDS', parameters: ['ALL'], rawValue: 'FIELDS(ALL)' }],
         sObject: metadataObject,
         where: {
@@ -483,42 +436,37 @@ async function collectCustomMetadata({
       }),
     );
 
-    // Group records by Api name, then get value of each used field in record
     const fieldsByName = getFieldsByName(columns);
-    let lowercaseFieldMap: Record<string, Field> = {};
-    if (parsedQuery) {
-      lowercaseFieldMap = (await fetchMetadataFromSoql(selectedOrg, parsedQuery)).lowercaseFieldMap;
-    }
     const recordsByApiName = getRecordsByLowercaseField(queryResults.records, 'QualifiedApiName');
 
+    // Build nested structure: Type__mdt → Record → Field__c
+    const objectRecord: FormulaRecord = {};
     Object.values(records).forEach(({ fields, record }) => {
       const metadataRecord = recordsByApiName[record.toLowerCase()];
-      fields.forEach(({ field, fullField }) => {
-        // Prefer to get field from actual metadata, otherwise picklist is not handled and can cause formula errors
-        const column = lowercaseFieldMap[field.toLowerCase()] || fieldsByName[field.toLowerCase()];
-        if (!column || !fieldsByName[field.toLowerCase()]) {
+      const recordFields: FormulaRecord = {};
+      fields.forEach(({ field }) => {
+        const column = fieldsByName[field.toLowerCase()];
+        if (!column) {
           throw new Error(`Field ${field} does not exist on ${metadataObject}.`);
         }
-        formulaFields[fullField] = getFormulonData(
-          column,
-          lodashGet(metadataRecord, fieldsByName[field.toLowerCase()].columnFullPath),
-          numberNullBehavior,
-        );
+        recordFields[field] = convertQueryValue(column, lodashGet(metadataRecord, column.columnFullPath));
       });
+      objectRecord[record] = recordFields;
     });
+    customMetadataGlobals[metadataObject] = objectRecord;
   }
+
+  globals['$CustomMetadata'] = customMetadataGlobals;
 }
 
 async function collectLabels({
   selectedOrg,
   fields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
@@ -527,7 +475,6 @@ async function collectLabels({
   const { queryResults } = await query(
     selectedOrg,
     composeQuery({
-      // we could use actual fields instead of all if these has performance issues
       fields: [getField('Name'), getField('Value')],
       sObject: 'ExternalString',
       where: {
@@ -544,35 +491,31 @@ async function collectLabels({
   );
 
   const recordsByApiName = getRecordsByLowercaseField(queryResults.records, 'Name');
+  const labelGlobals: FormulaRecord = {};
 
   fields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
-    const recordName = field.toLowerCase();
+    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const record: Record<string, any> | undefined = recordsByApiName[recordName];
-    formulaFields[fieldWithIdentifier] = {
-      type: 'literal',
-      dataType: 'text',
-      value: record?.Value || '',
-      options: { length: record?.Value?.length || 0 },
-    };
+    const record: Record<string, any> | undefined = recordsByApiName[field.toLowerCase()];
+    labelGlobals[field] = record?.Value || '';
   });
+
+  globals['$Label'] = labelGlobals;
 }
 
 async function collectOrganizationFields({
   selectedOrg,
   fields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
   }
+
   const { queryResults, columns } = await query(
     selectedOrg,
     composeQuery({
@@ -583,17 +526,18 @@ async function collectOrganizationFields({
   );
 
   const fieldsByName = getFieldsByName(columns);
+  const orgGlobals: FormulaRecord = {};
 
   fields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
-    const fieldName = field.toLowerCase();
-    const column = fieldsByName[fieldName];
-    formulaFields[fieldWithIdentifier] = getFormulonData(
-      column,
-      lodashGet(queryResults.records[0], column.columnFullPath),
-      numberNullBehavior,
-    );
+    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
+    const column = fieldsByName[field.toLowerCase()];
+    if (!column) {
+      throw new Error(`Invalid Organization field in formula: ${field}`);
+    }
+    orgGlobals[field] = convertQueryValue(column, lodashGet(queryResults.records[0], column.columnFullPath));
   });
+
+  globals['$Organization'] = orgGlobals;
 }
 
 async function collectUserProfileAndRoleFields({
@@ -602,20 +546,19 @@ async function collectUserProfileAndRoleFields({
   userFields,
   profileFields,
   roleFields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   selectedUserId: string;
   userFields: string[];
   profileFields: string[];
   roleFields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!userFields.length && !profileFields.length && !roleFields.length) {
     return;
   }
+
   const { queryResults, columns } = await query(
     selectedOrg,
     composeQuery({
@@ -643,49 +586,64 @@ async function collectUserProfileAndRoleFields({
   );
 
   const { Profile, UserRole, ...User } = queryResults.records[0];
-
   const fieldsByName = getFieldsByName(columns);
 
-  userFields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
-    const fieldName = field.toLowerCase();
-    const column = fieldsByName[fieldName];
-    formulaFields[fieldWithIdentifier] = getFormulonData(column, lodashGet(User, column.columnName), numberNullBehavior);
-  });
+  if (userFields.length) {
+    const userGlobals: FormulaRecord = {};
+    userFields.forEach((fieldWithIdentifier) => {
+      const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
+      const column = fieldsByName[field.toLowerCase()];
+      if (!column) {
+        throw new Error(`Invalid User field in formula: ${field}`);
+      }
+      userGlobals[field] = convertQueryValue(column, lodashGet(User, column.columnName));
+    });
+    globals['$User'] = userGlobals;
+  }
 
-  profileFields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
-    const fieldName = field.toLowerCase();
-    const column = fieldsByName[`profile.${fieldName}`];
-    formulaFields[fieldWithIdentifier] = getFormulonData(column, lodashGet(Profile, column.columnName), numberNullBehavior);
-  });
+  if (profileFields.length) {
+    const profileGlobals: FormulaRecord = {};
+    profileFields.forEach((fieldWithIdentifier) => {
+      const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
+      const column = fieldsByName[`profile.${field.toLowerCase()}`];
+      if (!column) {
+        throw new Error(`Invalid Profile field in formula: ${field}`);
+      }
+      profileGlobals[field] = convertQueryValue(column, lodashGet(Profile, column.columnName));
+    });
+    globals['$Profile'] = profileGlobals;
+  }
 
-  roleFields.forEach((fieldWithIdentifier) => {
-    const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_LABEL, '');
-    const fieldName = field.toLowerCase();
-    const column = fieldsByName[`userrole.${fieldName}`];
-    formulaFields[fieldWithIdentifier] = getFormulonData(column, lodashGet(UserRole, column.columnName), numberNullBehavior);
-  });
+  if (roleFields.length) {
+    const roleGlobals: FormulaRecord = {};
+    roleFields.forEach((fieldWithIdentifier) => {
+      const field = fieldWithIdentifier.replace(MATCH_FORMULA_SPECIAL_PREFIX, '');
+      const column = fieldsByName[`userrole.${field.toLowerCase()}`];
+      if (!column) {
+        throw new Error(`Invalid UserRole field in formula: ${field}`);
+      }
+      roleGlobals[field] = convertQueryValue(column, lodashGet(UserRole, column.columnName));
+    });
+    globals['$UserRole'] = roleGlobals;
+  }
 }
 
 /**
- * Fetch all assigned permission sets (which also include the user's profile)
- * read metadata for each assigned permission set (slow)
- * Get all the customPermissions assigned to the profile/permission sets
- * compare with the formula's custom permission
+ * Fetch all assigned permission sets (which also include the user's profile),
+ * read metadata for each assigned permission set,
+ * get all the customPermissions assigned to the profile/permission sets,
+ * and compare with the formula's custom permission.
  */
 async function collectCustomPermissions({
   selectedOrg,
   selectedUserId,
   fields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   selectedUserId: string;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
@@ -754,35 +712,30 @@ async function collectCustomPermissions({
   );
 
   // Calculate if custom permission is enabled
+  const permissionGlobals: FormulaRecord = {};
   fields.forEach((field) => {
     const permissionName = field.split('.')[1];
-    formulaFields[field] = {
-      type: 'literal',
-      dataType: 'checkbox',
-      value: customPermissions.has(permissionName),
-    };
+    permissionGlobals[permissionName] = customPermissions.has(permissionName);
   });
+  globals['$Permission'] = permissionGlobals;
 }
 
 async function collectCustomSettingFields({
   selectedOrg,
   selectedUserId,
   fields,
-  formulaFields,
-  numberNullBehavior,
+  globals,
 }: {
   selectedOrg: SalesforceOrgUi;
   selectedUserId: string;
   fields: string[];
-  formulaFields: formulon.FormulaData;
-  numberNullBehavior: NullNumberBehavior;
+  globals: Record<string, FormulaRecord>;
 }) {
   if (!fields.length) {
     return;
   }
-  // going to be similar to custom metadata BUT will need to apply hierarchy
 
-  const { queryResults } = await query(
+  const { queryResults: userQueryResults } = await query(
     selectedOrg,
     composeQuery({
       fields: Array.from(new Set([getField('Id'), getField('ProfileId')])),
@@ -799,7 +752,7 @@ async function collectCustomSettingFields({
     }),
   );
 
-  const { Id, ProfileId } = queryResults.records[0];
+  const { Id, ProfileId } = userQueryResults.records[0];
 
   const data = fields.reduce((output: Record<string, { object: string; fields: { field: string; fullField: string }[] }>, fullField) => {
     const [, object, field] = fullField.split('.');
@@ -808,13 +761,14 @@ async function collectCustomSettingFields({
     return output;
   }, {});
 
-  // Query each metadata object, extract fields, and add to formulaFields
+  const setupGlobals: FormulaRecord = {};
+
+  // Query each custom setting, apply hierarchy logic, and extract fields
   for (const customSettingObject of Object.keys(data)) {
     const { fields } = data[customSettingObject];
     const { queryResults, columns } = await query(
       selectedOrg,
       composeQuery({
-        // we could use actual fields instead of all if these has performance issues
         fields: [{ type: 'FieldFunctionExpression', functionName: 'FIELDS', parameters: ['ALL'], rawValue: 'FIELDS(ALL)' }],
         sObject: customSettingObject,
         where: {
@@ -833,28 +787,29 @@ async function collectCustomSettingFields({
     const recordsBySetupId = groupByFlat(queryResults.records, 'SetupOwnerId');
     const record = recordsBySetupId[Id] || recordsBySetupId[ProfileId] || recordsBySetupId[selectedOrg.organizationId];
 
-    fields.forEach(({ field, fullField }) => {
-      const column = fieldsByName[field];
-      formulaFields[fullField] = getFormulonData(column, lodashGet(record, field), numberNullBehavior);
+    const settingRecord: FormulaRecord = {};
+    fields.forEach(({ field }) => {
+      const column = fieldsByName[field.toLowerCase()];
+      if (!column) {
+        throw new Error(`Invalid custom setting field in formula: ${customSettingObject}.${field}`);
+      }
+      settingRecord[field] = convertQueryValue(column, lodashGet(record, column.columnName));
     });
+    setupGlobals[customSettingObject] = settingRecord;
   }
+
+  globals['$Setup'] = setupGlobals;
 }
 
-async function collectSystemFields({ fields, formulaFields }: { fields: string[]; formulaFields: formulon.FormulaData }) {
+function collectSystemFields({ fields, globals }: { fields: string[]; globals: Record<string, FormulaRecord> }) {
   if (!fields.length) {
     return;
   }
-  // hard-code date
-  formulaFields['$System.OriginDateTime'] = {
-    type: 'literal',
-    dataType: 'datetime',
-    value: new Date(1900, 1, 1),
-  };
+  globals['$System'] = { OriginDateTime: new Date(1900, 1, 1) };
 }
 
-/** get columns by field name in lowercase */
+/** Get columns by field name in lowercase */
 function getFieldsByName(columns: Maybe<QueryResultsColumns>) {
-  // get columns by field name in lowercase
   return (
     columns?.columns?.reduce((output: Record<string, QueryResultsColumn>, item) => {
       output[item.columnFullPath.toLowerCase()] = item;
@@ -872,45 +827,49 @@ function getRecordsByLowercaseField(records: Record<string, string>[], field: st
 
 export const formulaFunctions = [
   'ABS',
-  'ADD',
   'ADDMONTHS',
   'AND',
+  'ASCII',
   'BEGINS',
   'BLANKVALUE',
   'BR',
   'CASE',
   'CASESAFEID',
   'CEILING',
+  'CHR',
   'CONTAINS',
-  // 'CURRENCYRATE', // NOT IMPLEMENTED
   'DATE',
   'DATETIMEVALUE',
   'DATEVALUE',
   'DAY',
+  'DAYOFYEAR',
   'DISTANCE',
-  'DIVIDE',
-  'EQUAL',
   'EXP',
-  'EXPONENTIATE',
   'FIND',
   'FLOOR',
+  'FROMUNIXTIME',
   'GEOLOCATION',
   'GETSESSIONID',
-  'GREATERTHAN',
-  'GREATERTHANOREQUAL',
   'HOUR',
+  'HTMLENCODE',
   'HYPERLINK',
   'IF',
+  'IFERROR',
+  'IFS',
   'IMAGE',
   'INCLUDES',
+  'INITCAP',
   'ISBLANK',
-  // 'ISNULL', // NOT IMPLEMENTED
-  // 'ISNUMBER', // NOT IMPLEMENTED
+  'ISCHANGED',
+  'ISCLONE',
+  'ISNEW',
+  'ISNULL',
+  'ISNUMBER',
   'ISPICKVAL',
+  'JSENCODE',
+  'JSINHTMLENCODE',
   'LEFT',
   'LEN',
-  'LESSTHAN',
-  'LESSTHANOREQUAL',
   'LN',
   'LOG',
   'LOWER',
@@ -924,11 +883,14 @@ export const formulaFunctions = [
   'MINUTE',
   'MOD',
   'MONTH',
-  'MULTIPLY',
   'NOT',
   'NOW',
-  // 'NULLVALUE', // NOT IMPLEMENTED
+  'NULLVALUE',
   'OR',
+  'PI',
+  'POWER',
+  'PRIORVALUE',
+  'RAND',
   'REGEX',
   'RIGHT',
   'ROUND',
@@ -936,14 +898,15 @@ export const formulaFunctions = [
   'SECOND',
   'SQRT',
   'SUBSTITUTE',
-  'SUBTRACT',
   'TEXT',
   'TIMENOW',
   'TIMEVALUE',
   'TODAY',
   'TRIM',
-  'UNEQUAL',
+  'TRUNC',
+  'UNIXTIMESTAMP',
   'UPPER',
+  'URLENCODE',
   'VALUE',
   'WEEKDAY',
   'YEAR',
diff --git a/libs/shared/ui-core/src/index.ts b/libs/shared/ui-core/src/index.ts
index 8460a73f9..fa0e41a7b 100644
--- a/libs/shared/ui-core/src/index.ts
+++ b/libs/shared/ui-core/src/index.ts
@@ -29,6 +29,7 @@ export * from './formula-evaluator/formula-evaluator.types';
 export * from './formula-evaluator/formula-evaluator.utils';
 export * from './formula-evaluator/FormulaEvaluatorRecordSearch';
 export * from './formula-evaluator/FormulaEvaluatorResults';
+export * from './formula-evaluator/FormulaEvaluatorReturnTypeCombobox';
 export * from './formula-evaluator/FormulaEvaluatorUserSearch';
 export * from './icons/JetstreamIcon';
 export * from './icons/JetstreamLogo';
diff --git a/libs/shared/ui-core/src/state-management/formula-evaluator.state.ts b/libs/shared/ui-core/src/state-management/formula-evaluator.state.ts
index b491d3726..ab6ab49a2 100644
--- a/libs/shared/ui-core/src/state-management/formula-evaluator.state.ts
+++ b/libs/shared/ui-core/src/state-management/formula-evaluator.state.ts
@@ -1,7 +1,11 @@
+import { SFDC_BLANK_PICKLIST_VALUE } from '@jetstream/shared/constants';
 import { DescribeGlobalSObjectResult, Field, NullNumberBehavior } from '@jetstream/types';
+import type { FormulaReturnType } from '@jetstreamapp/sf-formula-parser';
 import { atom } from 'jotai';
 import { atomWithReset } from 'jotai/utils';
 
+export type FormulaReturnTypeWithEmptyState = FormulaReturnType | null | typeof SFDC_BLANK_PICKLIST_VALUE;
+
 export const sourceTypeState = atomWithReset<'NEW' | 'EXISTING'>('NEW');
 
 export const selectedSObjectState = atomWithReset<DescribeGlobalSObjectResult | null>(null);
@@ -16,4 +20,6 @@ export const formulaValueState = atomWithReset<string>('');
 
 export const numberNullBehaviorState = atomWithReset<NullNumberBehavior>('BLANK');
 
+export const returnTypeState = atomWithReset<FormulaReturnTypeWithEmptyState>('string');
+
 export const bannerDismissedState = atomWithReset<boolean>(false);
diff --git a/libs/test/e2e-utils/src/index.ts b/libs/test/e2e-utils/src/index.ts
index 445f538b7..13e1b1dc6 100644
--- a/libs/test/e2e-utils/src/index.ts
+++ b/libs/test/e2e-utils/src/index.ts
@@ -1,6 +1,7 @@
 export * from './lib/ApiRequestUtils';
 export * from './lib/e2e-database-validation.utils';
 export * from './lib/pageObjectModels/AuthenticationPage.model';
+export * from './lib/pageObjectModels/FormulaEvaluatorPage.model';
 export * from './lib/pageObjectModels/LoadSingleObjectPage.model';
 export * from './lib/pageObjectModels/LoadWithoutFilePage.model';
 export * from './lib/pageObjectModels/OrgGroupPage.model';
diff --git a/libs/test/e2e-utils/src/lib/pageObjectModels/FormulaEvaluatorPage.model.ts b/libs/test/e2e-utils/src/lib/pageObjectModels/FormulaEvaluatorPage.model.ts
new file mode 100644
index 000000000..561302222
--- /dev/null
+++ b/libs/test/e2e-utils/src/lib/pageObjectModels/FormulaEvaluatorPage.model.ts
@@ -0,0 +1,100 @@
+import { Locator, Page } from '@playwright/test';
+import type { editor } from 'monaco-editor';
+import { ApiRequestUtils } from '../ApiRequestUtils';
+
+declare global {
+  interface Window {
+    monaco: { editor: typeof editor };
+  }
+}
+
+export class FormulaEvaluatorPage {
+  readonly apiRequestUtils: ApiRequestUtils;
+  readonly page: Page;
+  readonly testBtn: Locator;
+  readonly formulaResult: Locator;
+  readonly formulaError: Locator;
+  readonly recordFields: Locator;
+
+  constructor(page: Page, apiRequestUtils: ApiRequestUtils) {
+    this.apiRequestUtils = apiRequestUtils;
+    this.page = page;
+    this.testBtn = page.getByRole('button', { name: 'Test' });
+    this.formulaResult = page.getByTestId('formula-result');
+    this.formulaError = page.getByTestId('formula-error');
+    this.recordFields = page.getByTestId('formula-record-fields');
+  }
+
+  async goto() {
+    await this.page.goto('/app/formula-evaluator');
+    await this.page.waitForURL('**/formula-evaluator');
+  }
+
+  async selectObject(sobjectName: string) {
+    const dropdown = this.page.getByTestId('dropdown-Select an Object');
+    const input = dropdown.getByRole('textbox');
+    await input.click();
+    await input.fill(sobjectName);
+    await dropdown.getByRole('option', { name: sobjectName }).first().click();
+  }
+
+  async searchAndSelectRecord(searchTerm: string) {
+    const dropdown = this.page.getByTestId('dropdown-Record');
+    const input = dropdown.getByRole('textbox');
+    await input.click();
+    // Use pressSequentially to fire proper keyUp events that the combobox listens for
+    await input.pressSequentially(searchTerm, { delay: 50 });
+    // Wait for debounced search (300ms) to complete and results to render
+    const listItem = dropdown.locator('.slds-listbox__item').first();
+    await listItem.waitFor({ state: 'visible', timeout: 15000 });
+    await listItem.click();
+  }
+
+  async setFormula(formula: string) {
+    await this.page.evaluate((formulaText) => {
+      window.monaco.editor
+        .getEditors()
+        .find((editor) => !editor.getRawOptions().readOnly)
+        ?.setValue(formulaText);
+    }, formula);
+  }
+
+  async clickTest() {
+    await this.testBtn.click();
+  }
+
+  async setReturnType(label: string) {
+    const dropdown = this.page.getByTestId('dropdown-Output Type');
+    const input = dropdown.getByRole('textbox');
+    await input.click();
+    await dropdown.getByRole('option', { name: label }).click();
+  }
+
+  async setNullBehavior(behavior: 'ZERO' | 'BLANK') {
+    if (behavior === 'ZERO') {
+      await this.page.getByRole('radio', { name: 'Treat as zero' }).click({ force: true });
+    } else {
+      await this.page.getByRole('radio', { name: 'Treat as blank' }).click({ force: true });
+    }
+  }
+
+  /**
+   * Set formula, click Test, wait for results, and return the result text.
+   */
+  async evaluateFormula(formula: string): Promise<string> {
+    await this.setFormula(formula);
+    await this.clickTest();
+    await this.formulaResult.waitFor({ state: 'visible', timeout: 30000 });
+    return (await this.formulaResult.textContent()) || '';
+  }
+
+  /**
+   * Set formula, click Test, and expect an error message.
+   */
+  async evaluateFormulaExpectError(formula: string): Promise<string> {
+    await this.setFormula(formula);
+    await this.clickTest();
+    await this.formulaError.waitFor({ state: 'visible', timeout: 30000 });
+    return (await this.formulaError.textContent()) || '';
+  }
+}
diff --git a/libs/ui/src/lib/data-table/SalesforceRecordDataTable.tsx b/libs/ui/src/lib/data-table/SalesforceRecordDataTable.tsx
index 1030fbc82..409266e4d 100644
--- a/libs/ui/src/lib/data-table/SalesforceRecordDataTable.tsx
+++ b/libs/ui/src/lib/data-table/SalesforceRecordDataTable.tsx
@@ -320,7 +320,7 @@ export const SalesforceRecordDataTable = memo<SalesforceRecordDataTableProps>(
       (
         allRows: RowSalesforceRecordWithKey[],
         filteredRows: RowSalesforceRecordWithKey[],
-        data: RowsChangeData<RowSalesforceRecordWithKey>,
+        _data: RowsChangeData<RowSalesforceRecordWithKey>,
       ) => {
         const rowsByKey = groupByFlat(filteredRows, '_key');
         const newRows = allRows.map((row) => rowsByKey[row._key] || row);
diff --git a/package.json b/package.json
index d1a8dda26..2c7e7db82 100644
--- a/package.json
+++ b/package.json
@@ -267,6 +267,7 @@
     "@fullhuman/postcss-purgecss": "^2.2.0",
     "@heroicons/react": "^2.2.0",
     "@hookform/resolvers": "^5.2.2",
+    "@jetstreamapp/sf-formula-parser": "^2.1.0",
     "@jetstreamapp/soql-parser-js": "^7.1.0",
     "@marsidev/react-turnstile": "^1.4.2",
     "@mdx-js/react": "^1.6.21",
@@ -317,7 +318,6 @@
     "fast-xml-parser": "^5.5.8",
     "file-saver": "^2.0.5",
     "filesize": "^11.0.13",
-    "formulon": "^6.25.6",
     "fs-extra": "^9.0.1",
     "fuse.js": "^7.0.0",
     "helmet": "^4.1.1",
diff --git a/yarn.lock b/yarn.lock
index 99ee4e438..98a8f576e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6401,6 +6401,11 @@
     "@types/yargs" "^17.0.33"
     chalk "^4.1.2"
 
+"@jetstreamapp/sf-formula-parser@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@jetstreamapp/sf-formula-parser/-/sf-formula-parser-2.1.0.tgz#8acbd247f6f3133d8bcd1097805b0c316fa9cc64"
+  integrity sha512-yTS00P0+lIyShSTq6Pn+hPAMmxGF2m2OjiFH6l4dbNa8NI5DYqQILl3X9/qsA1py3dDOPt4Q5b10Ix7wEjkItQ==
+
 "@jetstreamapp/soql-parser-js@^7.1.0":
   version "7.1.0"
   resolved "https://registry.yarnpkg.com/@jetstreamapp/soql-parser-js/-/soql-parser-js-7.1.0.tgz#0560996a38aeb409f9c4043edd995660f1d247cd"
@@ -14822,11 +14827,6 @@ decamelize@^1.2.0:
   resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz"
   integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
 
-decimal.js@^10.3.1:
-  version "10.4.3"
-  resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.4.3.tgz#1044092884d245d1b7f65725fa4ad4c6f781cc23"
-  integrity sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==
-
 decimal.js@^10.6.0:
   version "10.6.0"
   resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.6.0.tgz#e649a43e3ab953a72192ff5983865e509f37ed9a"
@@ -17546,13 +17546,6 @@ form-data@^4.0.5:
     hasown "^2.0.2"
     mime-types "^2.1.12"
 
-formulon@^6.25.6:
-  version "6.25.6"
-  resolved "https://registry.yarnpkg.com/formulon/-/formulon-6.25.6.tgz#a35d9aa03aed620790e64e6e2c64aaa2a5f1e4af"
-  integrity sha512-4t0c5gu6v5NR0um+kGLuSvl80WNsMaJWx7GpfIWVgAoGwrMXVTp5s3E+YL/kNs0EKUXqxD0ESOIB4NlUteSzIw==
-  dependencies:
-    decimal.js "^10.3.1"
-
 forwarded@0.2.0:
   version "0.2.0"
   resolved "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz"