@atomic-ehr/fhirpath 0.0.1 → 0.0.2-canary.2fee5d9.20250808110507

package/src/operations/abs-function.ts

@@ -1,9 +1,11 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // abs() takes no arguments
   if (args.length !== 0) {
-    throw new Error('abs() takes no arguments');
+    throw Errors.wrongArgumentCount('abs', 0, args.length);
   }
 
   // If input is empty, return empty
@@ -13,29 +15,36 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
 
   // If input has multiple items, error
   if (input.length > 1) {
-    throw new Error('abs() can only be applied to a single item');
+    throw Errors.singletonRequired('abs', input.length);
   }
 
-  const value = input[0];
+  const boxedValue = input[0];
+  if (!boxedValue) return { value: [], context };
+  const value = unbox(boxedValue);
 
   // Handle different types
   if (typeof value === 'number') {
-    return { value: [Math.abs(value)], context };
+    const result = Math.abs(value);
+    const typeInfo = Number.isInteger(result) ? 
+      { type: 'Integer' as const, singleton: true } : 
+      { type: 'Decimal' as const, singleton: true };
+    return { value: [box(result, typeInfo)], context };
   }
 
   // Handle Quantity type
   if (value && typeof value === 'object' && 'value' in value && 'unit' in value) {
+    const result = {
+      value: Math.abs(value.value),
+      unit: value.unit,
+      ...(value._ucumQuantity && { _ucumQuantity: { ...value._ucumQuantity, value: Math.abs(value._ucumQuantity.value) } })
+    };
     return { 
-      value: [{
-        value: Math.abs(value.value),
-        unit: value.unit,
-        ...(value._ucumQuantity && { _ucumQuantity: { ...value._ucumQuantity, value: Math.abs(value._ucumQuantity.value) } })
-      }], 
+      value: [box(result, { type: 'Quantity', singleton: true })], 
       context 
     };
   }
 
-  throw new Error(`Cannot apply abs() to ${typeof value}`);
+  throw Errors.invalidOperandType('abs', `${typeof value}`);
 };
 
 export const absFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/aggregate-function.ts

@@ -1,10 +1,12 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
 import { RuntimeContextManager } from '../interpreter';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // aggregator expression is required
   if (args.length < 1) {
-    throw new Error('aggregate() requires at least one argument (aggregator expression)');
+    throw Errors.invalidOperation('aggregate requires at least one argument (aggregator expression)');
   }
 
   const aggregatorExpr = args[0]!;
@@ -22,8 +24,14 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
   // For each item in the input collection, evaluate the aggregator expression
   input.forEach((item, index) => {
     // Create a new context with $this, $index, and $total
-    let aggregatorContext = RuntimeContextManager.withIterator(context, item, index);
-    aggregatorContext = RuntimeContextManager.setVariable(aggregatorContext, '$total', total);
+    // Note: $this needs unboxed value, but we pass boxed item to evaluator
+    const unboxedItem = unbox(item);
+    let aggregatorContext = RuntimeContextManager.withIterator(context, unboxedItem, index);
+    
+    // For the first iteration without init, $total should be empty (not undefined)
+    // $total needs to be unboxed values for variable access
+    const unboxedTotal = total.map(v => unbox(v));
+    aggregatorContext = RuntimeContextManager.setVariable(aggregatorContext, '$total', unboxedTotal);
 
     // Evaluate the aggregator expression
     const result = evaluator(aggregatorExpr, [item], aggregatorContext);

package/src/operations/all-function.ts

@@ -1,42 +1,52 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
 import { RuntimeContextManager } from '../interpreter';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // all() requires exactly one argument (the criteria expression)
   if (!args || args.length !== 1) {
-    throw new Error('all() requires exactly one argument');
+    throw Errors.invalidOperation('all requires exactly one argument');
   }
 
   // If the input collection is empty, the result is true per spec
   if (input.length === 0) {
-    return { value: [true], context };
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
 
   const criteriaExpression = args[0];
   if (!criteriaExpression) {
-    throw new Error('all() requires a criteria expression');
+    throw Errors.invalidOperation('all requires a criteria expression');
   }
 
   // Evaluate the criteria for each element in the input collection
   for (let i = 0; i < input.length; i++) {
-    const item = input[i];
+    const boxedItem = input[i];
+    if (!boxedItem) continue;
+    
+    const item = unbox(boxedItem);
     
     // Create iterator context with $this and $index
     let tempContext = RuntimeContextManager.withIterator(context, item, i);
     tempContext = RuntimeContextManager.setVariable(tempContext, '$total', input.length);
     
     // Evaluate the criteria expression with the current item as context
-    const result = evaluator(criteriaExpression, [item], tempContext);
+    const result = evaluator(criteriaExpression, [boxedItem], tempContext);
     
     // Check if the result is truthy
     // If the result is empty or contains a falsy value, return false
-    if (result.value.length === 0 || result.value[0] !== true) {
-      return { value: [false], context };
+    if (result.value.length === 0) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    const resultValue = unbox(result.value[0]!);
+    if (resultValue !== true) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
     }
   }
 
   // All criteria evaluations were true
-  return { value: [true], context };
+  return { value: [box(true, { type: 'Boolean', singleton: true })], context };
 };
 
 export const allFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/allFalse-function.ts

@@ -1,22 +1,25 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // If the input is empty, the result is true
   if (input.length === 0) {
-    return { value: [true], context };
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
   
-  // Verify all inputs are booleans
+  // Verify all inputs are booleans (unbox first)
   for (let i = 0; i < input.length; i++) {
-    if (typeof input[i] !== 'boolean') {
-      throw new Error(`allFalse() expects all items to be Boolean values, but item at index ${i} is ${typeof input[i]}`);
+    const unboxedValue = unbox(input[i]!);
+    if (typeof unboxedValue !== 'boolean') {
+      throw Errors.booleanOperationOnNonBoolean('allFalse', i, `${typeof unboxedValue}`);
     }
   }
   
   // Return true if all items are false, false if any item is true
-  const result = input.every(item => item === false);
+  const result = input.every(item => unbox(item) === false);
   
-  return { value: [result], context };
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const allFalseFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/allTrue-function.ts

@@ -1,22 +1,25 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // If the input is empty, the result is true
   if (input.length === 0) {
-    return { value: [true], context };
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
   
-  // Verify all inputs are booleans
+  // Verify all inputs are booleans (unbox first)
   for (let i = 0; i < input.length; i++) {
-    if (typeof input[i] !== 'boolean') {
-      throw new Error(`allTrue() expects all items to be Boolean values, but item at index ${i} is ${typeof input[i]}`);
+    const unboxedValue = unbox(input[i]!);
+    if (typeof unboxedValue !== 'boolean') {
+      throw Errors.booleanOperationOnNonBoolean('allTrue', i, `${typeof unboxedValue}`);
     }
   }
   
   // Return true if all items are true, false if any item is false
-  const result = input.every(item => item === true);
+  const result = input.every(item => unbox(item) === true);
   
-  return { value: [result], context };
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const allTrueFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/and-operator.ts

@@ -1,21 +1,30 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: OperationEvaluator = (input, context, left, right) => {
   // Three-valued logic implementation
-  if (left.length === 0 || right.length === 0) {
-    // If either operand is false, result is false
-    if (left.length > 0 && left[0] === false) {
-      return { value: [false], context };
-    }
-    if (right.length > 0 && right[0] === false) {
-      return { value: [false], context };
-    }
-    // Otherwise unknown
-    return { value: [], context };
+  
+  // Get values safely
+  const leftBoxed = left.length > 0 ? left[0] : null;
+  const rightBoxed = right.length > 0 ? right[0] : null;
+  
+  const leftValue = leftBoxed ? unbox(leftBoxed) : null;
+  const rightValue = rightBoxed ? unbox(rightBoxed) : null;
+  
+  // If either operand is false, result is false
+  if (leftValue === false || rightValue === false) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // If both operands are true, result is true
+  if (leftValue === true && rightValue === true) {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
-  return { value: [left[0] && right[0]], context };
+  
+  // Otherwise (empty or non-boolean), result is empty
+  return { value: [], context };
 };
 
 export const andOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/anyFalse-function.ts

@@ -1,23 +1,25 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // Empty input returns false per spec
   if (input.length === 0) {
-    return { value: [false], context };
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
   }
   
   // Check if any item in the collection is false
-  for (const item of input) {
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
     if (typeof item !== 'boolean') {
       continue; // Skip non-boolean values
     }
     if (item === false) {
-      return { value: [true], context };
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
     }
   }
   
   // All items are true or non-boolean
-  return { value: [false], context };
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
 };
 
 export const anyFalseFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/anyTrue-function.ts

@@ -1,23 +1,25 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // Empty input returns false per spec
   if (input.length === 0) {
-    return { value: [false], context };
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
   }
   
   // Check if any item in the collection is true
-  for (const item of input) {
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
     if (typeof item !== 'boolean') {
       continue; // Skip non-boolean values
     }
     if (item === true) {
-      return { value: [true], context };
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
     }
   }
   
   // All items are false or non-boolean
-  return { value: [false], context };
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
 };
 
 export const anyTrueFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/as-operator.ts

@@ -1,6 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: OperationEvaluator = (input, context, left, right) => {
   // 'as' operator performs type casting/filtering

package/src/operations/ceiling-function.ts

@@ -1,9 +1,11 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // ceiling() takes no arguments
   if (args.length !== 0) {
-    throw new Error('ceiling() takes no arguments');
+    throw Errors.wrongArgumentCount('ceiling', 0, args.length);
   }
 
   // If input is empty, return empty
@@ -13,19 +15,21 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
 
   // If input has multiple items, error
   if (input.length > 1) {
-    throw new Error('ceiling() can only be applied to a single item');
+    throw Errors.singletonRequired('ceiling', input.length);
   }
 
-  const value = input[0];
+  const boxedValue = input[0];
+  if (!boxedValue) return { value: [], context };
+  const value = unbox(boxedValue);
 
   // Must be a number
   if (typeof value !== 'number') {
-    throw new Error(`Cannot apply ceiling() to ${typeof value}`);
+    throw Errors.invalidOperandType('ceiling', `${typeof value}`);
   }
 
   // Math.ceil can return -0, normalize it to 0
   const result = Math.ceil(value);
-  return { value: [Object.is(result, -0) ? 0 : result], context };
+  return { value: [box(Object.is(result, -0) ? 0 : result, { type: 'Integer', singleton: true })], context };
 };
 
 export const ceilingFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/children-function.ts

@@ -0,0 +1,94 @@
+import type { FunctionDefinition, FunctionEvaluator, TypeInfo } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
+
+export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('children', 0, args.length);
+  }
+  
+  const results: any[] = [];
+  const modelProvider = context.modelProvider;
+  
+  // Process each item in the input collection
+  // input is already an array, not an object with value property
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
+    
+    if (item && typeof item === 'object') {
+      // Get the parent type info if available
+      let parentTypeInfo: TypeInfo | undefined;
+      if (modelProvider && boxedItem.typeInfo) {
+        parentTypeInfo = boxedItem.typeInfo;
+      } else if (modelProvider && 'resourceType' in item && typeof item.resourceType === 'string') {
+        // Try to get type info from resourceType
+        parentTypeInfo = modelProvider.getType(item.resourceType);
+      }
+      
+      // Collect all child properties
+      for (const propertyName in item) {
+        // Skip resourceType as it's not a child element in FHIRPath
+        if (propertyName === 'resourceType') {
+          continue;
+        }
+        
+        // Skip primitive element properties (those starting with _)
+        if (propertyName.startsWith('_')) {
+          continue;
+        }
+        
+        const value = item[propertyName];
+        
+        // Skip null/undefined values
+        if (value === null || value === undefined) {
+          continue;
+        }
+        
+        // Get type info for this element from model provider
+        let elementTypeInfo: TypeInfo | undefined;
+        if (modelProvider && parentTypeInfo) {
+          elementTypeInfo = modelProvider.getElementType(parentTypeInfo, propertyName);
+        }
+        
+        // Get primitive element if it exists
+        const primitiveElementName = `_${propertyName}`;
+        const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
+        
+        if (Array.isArray(value)) {
+          // Add each array element
+          for (let i = 0; i < value.length; i++) {
+            const elementValue = value[i];
+            if (elementValue !== null && elementValue !== undefined) {
+              const elementPrimitive = primitiveElement?.[i];
+              // Make the type info singleton since it's a single element
+              const singletonTypeInfo = elementTypeInfo ? { ...elementTypeInfo, singleton: true } : undefined;
+              results.push(box(elementValue, singletonTypeInfo, elementPrimitive));
+            }
+          }
+        } else {
+          // Add single value - ensure it's marked as singleton
+          const singletonTypeInfo = elementTypeInfo ? { ...elementTypeInfo, singleton: true } : undefined;
+          results.push(box(value, singletonTypeInfo, primitiveElement));
+        }
+      }
+    }
+  }
+  
+  return { value: results, context };
+};
+
+export const childrenFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'children',
+  category: ['navigation'],
+  description: 'Returns all immediate child nodes of all items in the input collection',
+  examples: [
+    'Patient.children()',
+    'Observation.children().ofType(CodeableConcept)'
+  ],
+  signature: {
+    input: { type: 'Any', singleton: false },
+    parameters: [],
+    result: { type: 'Any', singleton: false }
+  },
+  evaluate
+};

package/src/operations/combine-function.ts

@@ -1,15 +1,17 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // combine() requires exactly one argument (the other collection)
   if (!args || args.length !== 1) {
-    throw new Error('combine() requires exactly one argument');
+    throw Errors.invalidOperation('combine requires exactly one argument');
   }
 
   // Evaluate the argument to get the other collection
   const otherArg = args[0];
   if (!otherArg) {
-    throw new Error('combine() requires a collection argument');
+    throw Errors.argumentRequired('combine', 'collection argument');
   }
   
   // Evaluate the argument expression

package/src/operations/combine-operator.ts

@@ -1,17 +1,18 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: OperationEvaluator = (input, context, left, right) => {
   // Combine operator concatenates all values as strings
-  const leftStr = left.map(v => String(v)).join('');
-  const rightStr = right.map(v => String(v)).join('');
+  const leftStr = left.map(v => String(unbox(v))).join('');
+  const rightStr = right.map(v => String(unbox(v))).join('');
   
   if (leftStr === '' && rightStr === '') {
     return { value: [], context };
   }
   
-  return { value: [leftStr + rightStr], context };
+  return { value: [box(leftStr + rightStr, { type: 'String', singleton: true })], context };
 };
 
 export const combineOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -22,6 +23,19 @@ export const combineOperator: OperatorDefinition & { evaluate: OperationEvaluato
   associativity: 'left',
   description: 'String concatenation operator',
   examples: ['first & " " & last'],
-  signatures: [],
+  signatures: [
+    {
+      name: 'string-combine',
+      left: { type: 'String', singleton: true },
+      right: { type: 'String', singleton: true },
+      result: { type: 'String', singleton: true },
+    },
+    {
+      name: 'any-combine',
+      left: { type: 'Any' },
+      right: { type: 'Any' },
+      result: { type: 'String', singleton: true },
+    }
+  ],
   evaluate
 };

package/src/operations/contains-function.ts

@@ -1,15 +1,17 @@
 import type { FunctionDefinition } from '../types';
+import { Errors } from '../errors';
 import type { FunctionEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   // contains() requires exactly 1 argument
   if (args.length !== 1) {
-    throw new Error('contains() requires exactly 1 argument');
+    throw Errors.wrongArgumentCount('contains', 1, args.length);
   }
 
   const substringExpr = args[0];
   if (!substringExpr) {
-    throw new Error('contains() requires a substring argument');
+    throw Errors.argumentRequired('contains', 'substring argument');
   }
 
   // If input collection is empty, result is empty
@@ -19,11 +21,16 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
 
   // If input collection contains multiple items, signal an error
   if (input.length > 1) {
-    throw new Error('contains() can only be applied to a single string');
+    throw Errors.invalidOperation('contains can only be applied to a single string');
   }
 
   // Input must be a string
-  const inputValue = input[0];
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
   if (typeof inputValue !== 'string') {
     // Non-string input returns empty
     return { value: [], context };
@@ -39,10 +46,15 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
   
   // Substring must be a single string
   if (substringResult.value.length > 1) {
-    throw new Error('contains() substring argument must evaluate to a single value');
+    throw Errors.invalidOperation('contains substring argument must evaluate to a single value');
+  }
+  
+  const boxedSubstring = substringResult.value[0];
+  if (!boxedSubstring) {
+    return { value: [], context };
   }
   
-  const substring = substringResult.value[0];
+  const substring = unbox(boxedSubstring);
   if (typeof substring !== 'string') {
     // Non-string substring returns empty
     return { value: [], context };
@@ -50,12 +62,12 @@ export const evaluate: FunctionEvaluator = (input, context, args, evaluator) =>
 
   // If substring is empty string, result is true
   if (substring === '') {
-    return { value: [true], context };
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
 
   // Check if input string contains the substring
   const result = inputValue.includes(substring);
-  return { value: [result], context };
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const containsFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/contains-operator.ts

@@ -1,6 +1,8 @@
 import type { OperatorDefinition } from '../types';
+import { Errors } from '../errors';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: OperationEvaluator = (input, context, left, right) => {
   // If right is empty, result is empty
@@ -10,23 +12,29 @@ export const evaluate: OperationEvaluator = (input, context, left, right) => {
   
   // Right must have single item
   if (right.length > 1) {
-    throw new Error('contains operator: right operand must be a single item');
+    throw Errors.invalidOperation('contains operator: right operand must be a single item');
   }
   
   // If left is empty, result is false
   if (left.length === 0) {
-    return { value: [false], context };
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
   }
   
   // Check if the single right item is in left using equality
-  const rightItem = right[0];
-  for (const leftItem of left) {
+  const boxedRightItem = right[0];
+  if (!boxedRightItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  const rightItem = unbox(boxedRightItem);
+  
+  for (const boxedLeftItem of left) {
+    const leftItem = unbox(boxedLeftItem);
     if (leftItem === rightItem) {
-      return { value: [true], context };
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
     }
   }
   
-  return { value: [false], context };
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
 };
 
 export const containsOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/count-function.ts

@@ -1,9 +1,10 @@
 import type { FunctionDefinition } from '../types';
 import type { FunctionEvaluator } from '../types';
+import { box, unbox } from '../boxing';
 
 export const evaluate: FunctionEvaluator = (input, context, args, evaluator) => {
   return { 
-    value: [input.length], 
+    value: [box(input.length, { type: 'Integer', singleton: true })], 
     context 
   };
 };