@atomic-ehr/fhirpath 0.0.3 → 0.0.4

package/src/operations/is-operator.ts

@@ -14,9 +14,162 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const boxedItem = left[0];
   const item = unbox(boxedItem);
   const typeName = right[0] as string; // Should be a type name like 'String', 'Integer', etc.
-  
   // If we have a ModelProvider and typeInfo, use it for accurate type checking (handles subtypes)
   if (context.modelProvider && boxedItem?.typeInfo) {
+    // Check for namespace-qualified types (e.g., System.Boolean, FHIR.boolean)
+    let checkNamespace: string | undefined;
+    let checkType: string;
+    
+    if (typeName.includes('.')) {
+      const parts = typeName.split('.');
+      checkNamespace = parts[0];
+      checkType = parts.slice(1).join('.');
+    } else {
+      checkType = typeName;
+    }
+    
+    // If checking for System type, ensure it's NOT a FHIR type
+    if (checkNamespace === 'System') {
+      // System types should not match FHIR types
+      if (boxedItem.typeInfo.namespace === 'FHIR') {
+        return { 
+          value: [box(false, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+      // Check if the type matches (without namespace)
+      const normalizedType = checkType;
+      if (boxedItem.typeInfo.type === normalizedType) {
+        return { 
+          value: [box(true, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+    }
+    
+    // If checking for FHIR type
+    if (checkNamespace === 'FHIR') {
+      // Must be a FHIR namespaced type
+      if (boxedItem.typeInfo.namespace === 'FHIR') {
+        // Check the name field for FHIR types (e.g., 'boolean', 'integer')
+        if (boxedItem.typeInfo.name === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+        
+        // Check type hierarchy using schema if available
+        if (context.modelProvider && boxedItem.typeInfo.name) {
+          // Check if the item's type is derived from the check type
+          const itemSchema = await (context.modelProvider as any).getSchema(boxedItem.typeInfo.name);
+          if (itemSchema && itemSchema.base) {
+            // Extract the type name from the base URL
+            const baseTypeName = itemSchema.base.split('/').pop();
+            if (baseTypeName === checkType) {
+              return { 
+                value: [box(true, { type: 'Boolean', singleton: true })], 
+                context 
+              };
+            }
+            // Check recursively up the hierarchy
+            let currentBase = baseTypeName;
+            while (currentBase) {
+              if (currentBase === checkType) {
+                return { 
+                  value: [box(true, { type: 'Boolean', singleton: true })], 
+                  context 
+                };
+              }
+              const baseSchema = await (context.modelProvider as any).getSchema(currentBase);
+              if (!baseSchema || !baseSchema.base) break;
+              currentBase = baseSchema.base.split('/').pop();
+            }
+          }
+        }
+        
+        // Also check if asking for a resource type like FHIR.Patient
+        if (boxedItem.typeInfo.type === checkType || boxedItem.typeInfo.name === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+      }
+      return { 
+        value: [box(false, { type: 'Boolean', singleton: true })], 
+        context 
+      };
+    }
+    
+    // When no namespace is specified (e.g., just "Boolean", "String", "string", "code")
+    if (!checkNamespace) {
+      // Check for System primitive types (capitalized)
+      const systemPrimitiveTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time'];
+      if (systemPrimitiveTypes.includes(checkType)) {
+        // For System primitive types, only match if NOT a FHIR type
+        if (boxedItem.typeInfo.namespace === 'FHIR') {
+          return { 
+            value: [box(false, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+        // Check if the type matches
+        if (boxedItem.typeInfo.type === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+      }
+      
+      // Check for FHIR primitive types (lowercase) like string, code, id, etc.
+      const fhirPrimitiveTypes = ['string', 'code', 'id', 'uri', 'url', 'canonical', 'uuid', 'oid', 
+                                   'boolean', 'integer', 'decimal', 'base64Binary', 'instant', 
+                                   'date', 'dateTime', 'time', 'unsignedInt', 'positiveInt', 'markdown'];
+      if (fhirPrimitiveTypes.includes(checkType)) {
+        // For FHIR primitive types, check both the name and underlying type
+        if (boxedItem.typeInfo.namespace === 'FHIR') {
+          // Check if the name matches
+          if (boxedItem.typeInfo.name === checkType) {
+            return { 
+              value: [box(true, { type: 'Boolean', singleton: true })], 
+              context 
+            };
+          }
+          // For 'string', also match code, id, etc. (they are all string-based)
+          if (checkType === 'string') {
+            const stringBasedTypes = ['code', 'id', 'uri', 'url', 'canonical', 'uuid', 'oid', 'markdown'];
+            if (boxedItem.typeInfo.name && stringBasedTypes.includes(boxedItem.typeInfo.name)) {
+              return { 
+                value: [box(true, { type: 'Boolean', singleton: true })], 
+                context 
+              };
+            }
+            // Also check if underlying type is String
+            if (boxedItem.typeInfo.type === 'String') {
+              return { 
+                value: [box(true, { type: 'Boolean', singleton: true })], 
+                context 
+              };
+            }
+          }
+        }
+        return { 
+          value: [box(false, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+      
+      // For non-primitive types (like Patient, Observation), use model provider
+      const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, typeName as TypeName);
+      return { 
+        value: [box(matchingType !== undefined, { type: 'Boolean', singleton: true })], 
+        context 
+      };
+    }
+    
+    // Default case - use model provider's ofType for other checks
     const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, typeName as TypeName);
     return { 
       value: [box(matchingType !== undefined, { type: 'Boolean', singleton: true })], 
@@ -24,10 +177,24 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     };
   }
   
-  // Check if the box has type information (without ModelProvider, just check exact match)
+  // Check if the box has type information (without ModelProvider, check with normalization)
   if (boxedItem?.typeInfo) {
+    // Normalize both types for comparison
+    let boxedType = boxedItem.typeInfo.type;
+    let compareType = typeName;
+    
+    // Normalize System.X to X for primitive types
+    if (compareType.startsWith('System.')) {
+      compareType = compareType.substring(7);
+    }
+    
+    // Also check if boxedType needs normalization (unlikely but consistent)
+    if (boxedType.startsWith('System.')) {
+      boxedType = boxedType.substring(7);
+    }
+    
     return { 
-      value: [box(boxedItem.typeInfo.type === typeName, { type: 'Boolean', singleton: true })], 
+      value: [box(boxedType === compareType, { type: 'Boolean', singleton: true })], 
       context 
     };
   }
@@ -50,15 +217,30 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     };
   }
   
-  // Check primitive types
-  switch (typeName) {
+  // Normalize type names - strip namespace for System types
+  // System.Boolean -> Boolean, FHIR.boolean -> boolean, etc.
+  let normalizedTypeName = typeName;
+  if (typeName.startsWith('System.')) {
+    normalizedTypeName = typeName.substring(7); // Remove "System."
+  } else if (typeName.startsWith('FHIR.')) {
+    // For FHIR types, keep the namespace for model provider lookup
+    // but also check without namespace for primitive types
+    normalizedTypeName = typeName;
+  }
+  
+  // Check primitive types (with normalized names)
+  switch (normalizedTypeName) {
     case 'String':
+    case 'System.String':
       return { value: [box(typeof item === 'string', { type: 'Boolean', singleton: true })], context };
     case 'Boolean':
+    case 'System.Boolean':
       return { value: [box(typeof item === 'boolean', { type: 'Boolean', singleton: true })], context };
     case 'Integer':
+    case 'System.Integer':
       return { value: [box(typeof item === 'number' && Number.isInteger(item), { type: 'Boolean', singleton: true })], context };
     case 'Decimal':
+    case 'System.Decimal':
       return { value: [box(typeof item === 'number', { type: 'Boolean', singleton: true })], context };
     case 'Date':
       // Check if it's a FHIRDate instance or has Date type

package/src/operations/less-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../complex-types/quantity-value';
-import type { QuantityValue } from '../complex-types/quantity-value';
 import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,31 +16,14 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result < 0, { type: 'Boolean', singleton: true })] : [], context };
-  }
+  // Use the unified compare function which handles all types including FHIR Quantities
+  const comparisonResult = compare(l, r);
   
-  // Check if both are temporal values (Date, DateTime, Time)
-  if (l && typeof l === 'object' && 'kind' in l &&
-      r && typeof r === 'object' && 'kind' in r) {
-    const temporalL = l as any;
-    const temporalR = r as any;
-    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
-    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
-      const { compare } = await import('../complex-types/temporal');
-      const result = compare(temporalL, temporalR);
-      // null means incomparable (different precisions), returns empty
-      if (result === null) {
-        return { value: [], context };
-      }
-      return { value: [box(result < 0, { type: 'Boolean', singleton: true })], context };
-    }
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) < (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'less', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/less-or-equal-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../complex-types/quantity-value';
-import type { QuantityValue } from '../complex-types/quantity-value';
 import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,31 +16,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result <= 0, { type: 'Boolean', singleton: true })] : [], context };
-  }
+  const comparisonResult = compare(l, r);
   
-  // Check if both are temporal values (Date, DateTime, Time)
-  if (l && typeof l === 'object' && 'kind' in l &&
-      r && typeof r === 'object' && 'kind' in r) {
-    const temporalL = l as any;
-    const temporalR = r as any;
-    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
-    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
-      const { compare } = await import('../complex-types/temporal');
-      const result = compare(temporalL, temporalR);
-      // null means incomparable (different precisions), returns empty
-      if (result === null) {
-        return { value: [], context };
-      }
-      return { value: [box(result <= 0, { type: 'Boolean', singleton: true })], context };
-    }
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) <= (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'less' || comparisonResult.kind === 'equal', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessOrEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/less-than.ts

@@ -2,7 +2,7 @@ import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
 import { box, unbox } from '../interpreter/boxing';
-import { compareQuantities, type QuantityValue } from '../complex-types/quantity-value';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -18,19 +18,14 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const leftValue = unbox(boxedLeft);
   const rightValue = unbox(boxedRight);
   
-  // Handle quantity comparison
-  if (leftValue && typeof leftValue === 'object' && 'value' in leftValue && 'unit' in leftValue &&
-      rightValue && typeof rightValue === 'object' && 'value' in rightValue && 'unit' in rightValue) {
-    const comparison = compareQuantities(leftValue as QuantityValue, rightValue as QuantityValue);
-    if (comparison === null) {
-      // Incompatible units - return empty
-      return { value: [], context };
-    }
-    return { value: [box(comparison < 0, { type: 'Boolean', singleton: true })], context };
+  // Use the unified compare function which handles all types including FHIR Quantities
+  const comparisonResult = compare(leftValue, rightValue);
+  
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  // Regular comparison
-  return { value: [box((leftValue as any) < (rightValue as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'less', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessThanOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/ln-function.ts

@@ -0,0 +1,62 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // ln() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('ln', 0, args.length);
+  }
+
+  // If input is empty, return empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input has multiple items, error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('ln', input.length);
+  }
+
+  const boxedValue = input[0];
+  if (!boxedValue) return { value: [], context };
+  const value = unbox(boxedValue);
+
+  // Must be a number
+  if (typeof value !== 'number') {
+    throw Errors.invalidOperandType('ln', `${typeof value}`);
+  }
+
+  // If zero or negative, return empty (ln is undefined for non-positive numbers)
+  if (value <= 0) {
+    return { value: [], context };
+  }
+
+  return { value: [box(Math.log(value), { type: 'Decimal', singleton: true })], context };
+};
+
+export const lnFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'ln',
+  category: ['math'],
+  description: 'Returns the natural logarithm (base e) of the input number as a Decimal.',
+  examples: [
+    '1.ln()',
+    '2.71828.ln()',
+    '(-1).ln()'
+  ],
+  signatures: [
+    {
+      name: 'ln-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'ln-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/log-function.ts

@@ -0,0 +1,113 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // log() takes exactly one argument (base)
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('log', 1, args.length);
+  }
+
+  // If input is empty, return empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input has multiple items, error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('log', input.length);
+  }
+
+  const boxedNumber = input[0];
+  if (!boxedNumber) {
+    return { value: [], context };
+  }
+  
+  const number = unbox(boxedNumber);
+
+  // Number must be a number
+  if (typeof number !== 'number') {
+    throw Errors.invalidOperandType('log', `${typeof number}`);
+  }
+
+  // Evaluate base
+  const baseResult = await evaluator(args[0]!, input, context);
+  if (baseResult.value.length === 0) {
+    return { value: [], context };
+  }
+  if (baseResult.value.length > 1) {
+    throw Errors.invalidOperation('log base must be a single value');
+  }
+
+  const boxedBase = baseResult.value[0];
+  if (!boxedBase) {
+    return { value: [], context };
+  }
+  
+  const base = unbox(boxedBase);
+  if (typeof base !== 'number') {
+    throw Errors.invalidOperation('log base must be a number');
+  }
+
+  // Check for invalid inputs
+  if (number <= 0 || base <= 0 || base === 1) {
+    // Logarithm undefined for non-positive numbers or base 1
+    return { value: [], context };
+  }
+
+  // Calculate logarithm using change of base formula: log_b(x) = ln(x) / ln(b)
+  const result = Math.log(number) / Math.log(base);
+
+  // Check if result is valid (not NaN or Infinity)
+  if (!isFinite(result)) {
+    return { value: [], context };
+  }
+
+  // Always return as Decimal per spec
+  return { value: [box(result, { type: 'Decimal', singleton: true })], context };
+};
+
+export const logFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'log',
+  category: ['math'],
+  description: 'Returns the logarithm base base of the input number. When used with Integers, the arguments will be implicitly converted to Decimal.',
+  examples: [
+    '16.log(2)',
+    '100.0.log(10.0)'
+  ],
+  signatures: [
+    {
+      name: 'log-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'base', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'log-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'base', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'log-integer-decimal',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'base', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'log-decimal-integer',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'base', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/lowBoundary-function.ts

@@ -90,6 +90,20 @@ export const lowBoundaryEvaluator: FunctionEvaluator = async (input, context, ar
     };
   }
   
+  // Handle Quantity type
+  if (value && typeof value === 'object' && 'value' in value && 'unit' in value) {
+    const quantity = value as { value: number; unit: string };
+    const result = getDecimalLowBoundary(quantity.value, precision);
+    if (result === null) {
+      return { value: [], context };
+    }
+    // Return a new Quantity with the adjusted value and same unit
+    return {
+      value: [box({ value: result, unit: quantity.unit }, { type: 'Quantity', singleton: true })],
+      context
+    };
+  }
+  
   // Invalid type returns empty
   return { value: [], context };
 };

package/src/operations/minus-operator.ts

@@ -4,6 +4,7 @@ import type { OperationEvaluator } from '../types';
 import { subtractQuantities } from '../complex-types/quantity-value';
 import type { QuantityValue } from '../complex-types/quantity-value';
 import { box, unbox } from '../interpreter/boxing';
+import { normalizeDecimalResult } from '../utils/decimal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -87,7 +88,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   
   // Handle numeric subtraction
   if (typeof l === 'number' && typeof r === 'number') {
-    const result = l - r;
+    let result = l - r;
+    
+    // Normalize decimal result to handle floating point precision issues
+    if (!Number.isInteger(l) || !Number.isInteger(r)) {
+      result = normalizeDecimalResult(result, l, r);
+    }
+    
     const typeInfo = Number.isInteger(result) ? 
       { type: 'Integer' as const, singleton: true } : 
       { type: 'Decimal' as const, singleton: true };

package/src/operations/mod-operator.ts

@@ -2,6 +2,7 @@ import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
 import { box, unbox } from '../interpreter/boxing';
+import { normalizeModuloResult } from '../utils/decimal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -21,7 +22,12 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: [], context };
   }
   
-  const result = (leftValue as any) % (rightValue as any);
+  let result = (leftValue as any) % (rightValue as any);
+  
+  // Normalize decimal result to handle floating point precision issues
+  if (!Number.isInteger(leftValue) || !Number.isInteger(rightValue)) {
+    result = normalizeModuloResult(result, leftValue as number, rightValue as number);
+  }
   
   // Determine result type based on input types
   const resultType = Number.isInteger(leftValue) && Number.isInteger(rightValue) ? 'Integer' : 'Decimal';

package/src/operations/not-function.ts

@@ -9,6 +9,11 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     return { value: [], context };
   }
   
+  // Multiple values should throw an error per XML tests
+  if (input.length > 1) {
+    throw new Error('not() can only be applied to a single item');
+  }
+  
   const boxedValue = input[0];
   if (!boxedValue) {
     return { value: [], context };
@@ -24,8 +29,10 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
   
-  // Non-boolean values return empty
-  return { value: [], context };
+  // Non-boolean values: any non-empty collection is considered truthy
+  // So not() returns false for any non-boolean value
+  // This follows the XML test suite behavior
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
 };
 
 export const notFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/ofType-function.ts

@@ -44,6 +44,41 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
       throw Errors.invalidOperation(`ofType() requires a type name as argument, got ${typeArg.type}`);
     }
 
+    // Validate the type name using ModelProvider if available
+    if (context.modelProvider) {
+      // Try to get the type from the model provider
+      const typeInfo = await context.modelProvider.getType(targetTypeName);
+      if (!typeInfo) {
+        // Not a valid FHIR type, check if it's a System type
+        const systemTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Quantity'];
+        const fhirPrimitiveTypes = ['boolean', 'integer', 'string', 'decimal', 'uri', 'url', 'canonical', 
+                                     'base64Binary', 'instant', 'date', 'dateTime', 'time', 'code', 'oid', 
+                                     'id', 'markdown', 'unsignedInt', 'positiveInt', 'uuid', 'xhtml'];
+        
+        if (!systemTypes.includes(targetTypeName) && !fhirPrimitiveTypes.includes(targetTypeName)) {
+          throw Errors.invalidOperation(`Unknown type: ${targetTypeName}`);
+        }
+      }
+    } else {
+      // Without ModelProvider, only allow basic System types and reject obvious invalid names
+      const systemTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time'];
+      const fhirPrimitiveTypes = ['boolean', 'integer', 'string', 'decimal', 'uri', 'url', 'canonical', 
+                                   'base64Binary', 'instant', 'date', 'dateTime', 'time', 'code', 'oid', 
+                                   'id', 'markdown', 'unsignedInt', 'positiveInt', 'uuid'];
+      
+      // If it's not a known primitive type and looks invalid, reject it
+      if (!systemTypes.includes(targetTypeName) && !fhirPrimitiveTypes.includes(targetTypeName)) {
+        // Check if it looks like a valid type name
+        if (!/^[A-Z][A-Za-z0-9]*$/.test(targetTypeName) && !/^[a-z][a-z0-9]*$/i.test(targetTypeName)) {
+          throw Errors.invalidOperation(`Invalid type name: ${targetTypeName}`);
+        }
+        // If it contains numbers but isn't a known type, it's likely invalid
+        if (/\d/.test(targetTypeName) && targetTypeName !== 'base64Binary') {
+          throw Errors.invalidOperation(`Unknown type: ${targetTypeName}`);
+        }
+      }
+    }
+
     // If we have typeInfo from the analyzer (with ModelProvider), use it
     // NOTE: This optimization is currently disabled because currentNode refers to the ofType
     // function node, not the input navigation node. The correct type checking happens below