@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/matchesFull-function.ts

@@ -0,0 +1,96 @@
+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) => {
+  // Check single item in input
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (input.length > 1) {
+    throw Errors.stringSingletonRequired('matchesFull', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('matchesFull');
+  }
+
+  // Check arguments
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('matchesFull', 1, args.length);
+  }
+
+  // Evaluate regex argument
+  const regexArg = args[0];
+  if (!regexArg) {
+    throw Errors.argumentRequired('matchesFull', 'regex argument');
+  }
+  
+  const regexResult = await evaluator(regexArg, input, context);
+  
+  if (regexResult.value.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (regexResult.value.length > 1) {
+    throw Errors.singletonRequired('matchesFull regex', regexResult.value.length);
+  }
+  
+  const boxedRegex = regexResult.value[0];
+  if (!boxedRegex) {
+    return { value: [], context };
+  }
+  
+  const regexPattern = unbox(boxedRegex);
+  if (typeof regexPattern !== 'string') {
+    throw Errors.invalidStringOperation('matchesFull', 'regex argument');
+  }
+
+  try {
+    // matchesFull implicitly adds ^ and $ anchors to match the entire string
+    // Only add anchors if they're not already present
+    let fullPattern = regexPattern;
+    if (!regexPattern.startsWith('^')) {
+      fullPattern = '^' + fullPattern;
+    }
+    if (!regexPattern.endsWith('$')) {
+      fullPattern = fullPattern + '$';
+    }
+    
+    // Create regex with unicode support and single line mode (dotAll)
+    // Per spec: case-sensitive, single line mode, allow Unicode
+    const regex = new RegExp(fullPattern, 'us');
+    const result = regex.test(inputValue);
+    
+    return { value: [box(result, { type: 'Boolean', singleton: true })], context };
+  } catch (error) {
+    throw new Error(`Invalid regular expression in matchesFull(): ${(error as Error).message}`);
+  }
+};
+
+export const matchesFullFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'matchesFull',
+  category: ['string'],
+  description: 'Returns true when the input string completely matches the given regular expression',
+  examples: [
+    "'Library'.matchesFull('Library')",
+    "'http://example.org/Library'.matchesFull('Library')",
+    "'N8000123'.matchesFull('N[0-9]{7}')"
+  ],
+  signatures: [{
+    name: 'matchesFull',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'regex', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'Boolean', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/millisecondOf-function.ts

@@ -0,0 +1,66 @@
+// millisecondOf() function - Extracts millisecond component from Time or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const millisecondOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // millisecondOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('millisecondOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('millisecondOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Time or DateTime
+  if (isFHIRTime(value) || isFHIRDateTime(value)) {
+    // Check if millisecond component is present
+    if (value.millisecond === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the millisecond as an Integer (0-999)
+    return {
+      value: [box(value.millisecond, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const millisecondOfFunction: FunctionDefinition & { evaluate: typeof millisecondOfEvaluator } = {
+  name: 'millisecondOf',
+  category: ['temporal'],
+  description: 'Returns the millisecond component of a Time or DateTime value (0-999)',
+  examples: [
+    '@T10:30:45.123.millisecondOf()',
+    '@2014-01-05T10:30:45.500.millisecondOf()',
+    'Observation.effectiveDateTime.millisecondOf()'
+  ],
+  signatures: [
+    {
+      name: 'millisecondOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: millisecondOfEvaluator
+};

package/src/operations/minus-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { subtractQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { subtractQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,6 +17,67 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
+  // Check for temporal arithmetic using boxed type information
+  const leftType = boxedl?.typeInfo?.type;
+  const rightType = boxedr?.typeInfo?.type;
+  
+  if ((leftType === 'Date' || leftType === 'DateTime' || leftType === 'Time') && rightType === 'Quantity') {
+    // Left is temporal, right is quantity
+    const temporalType = leftType;
+    const quantity = r as QuantityValue;
+    
+    // Import temporal utilities and create TimeQuantity
+    const { createTimeQuantity, subtract } = await import('../complex-types/temporal');
+    
+    // Calendar duration units (allowed for temporal arithmetic)
+    const calendarUnits = ['year', 'years', 'month', 'months', 'week', 'weeks', 
+                          'day', 'days', 'hour', 'hours', 'minute', 'minutes', 
+                          'second', 'seconds', 'millisecond', 'milliseconds'];
+    
+    // Variable duration UCUM units (not allowed for temporal arithmetic - they have calendar-dependent durations)
+    const variableDurationUnits = ['a', 'mo'];
+    
+    // Fixed duration UCUM units (allowed - they map directly to calendar units)
+    const fixedDurationUnitMap: Record<string, string> = {
+      'd': 'day',
+      'wk': 'week', 
+      'h': 'hour',
+      'min': 'minute',
+      's': 'second',
+      'ms': 'millisecond'
+    };
+    
+    // Check if this is a variable duration unit (not allowed)
+    if (variableDurationUnits.includes(quantity.unit)) {
+      // Variable duration units like 'a' and 'mo' cannot be subtracted from temporal values
+      // because they don't have fixed durations
+      const { Errors } = await import('../errors');
+      throw Errors.invalidTemporalUnit(temporalType, quantity.unit);
+    }
+    
+    // Map fixed duration UCUM units to calendar units
+    let mappedUnit = fixedDurationUnitMap[quantity.unit] || quantity.unit;
+    
+    // Check if this is a valid calendar duration unit (after mapping)
+    if (!calendarUnits.includes(mappedUnit)) {
+      // Non-time units with temporal values return empty per FHIRPath spec
+      return { value: [], context };
+    }
+    
+    const timeQuantity = createTimeQuantity(quantity.value, mappedUnit as any);
+    
+    // Use the functional subtract operation
+    const result = subtract(l as any, timeQuantity);
+    
+    if (temporalType === 'Date') {
+      return { value: [box(result, { type: 'Date', singleton: true })], context };
+    } else if (temporalType === 'DateTime') {
+      return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+    } else if (temporalType === 'Time') {
+      return { value: [box(result, { type: 'Time', singleton: true })], context };
+    }
+  }
+  
   // Check if both are quantities
   if (l && typeof l === 'object' && 'unit' in l && 
       r && typeof r === 'object' && 'unit' in r) {
@@ -26,7 +87,11 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   
   // Handle numeric subtraction
   if (typeof l === 'number' && typeof r === 'number') {
-    return { value: [box(l - r, { type: 'Any', singleton: true })], context };
+    const result = l - r;
+    const typeInfo = Number.isInteger(result) ? 
+      { type: 'Integer' as const, singleton: true } : 
+      { type: 'Decimal' as const, singleton: true };
+    return { value: [box(result, typeInfo)], context };
   }
   
   // For other types, return empty

package/src/operations/minuteOf-function.ts

@@ -0,0 +1,66 @@
+// minuteOf() function - Extracts minute component from Time or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const minuteOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // minuteOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('minuteOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('minuteOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Time or DateTime
+  if (isFHIRTime(value) || isFHIRDateTime(value)) {
+    // Check if minute component is present
+    if (value.minute === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the minute as an Integer (0-59)
+    return {
+      value: [box(value.minute, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const minuteOfFunction: FunctionDefinition & { evaluate: typeof minuteOfEvaluator } = {
+  name: 'minuteOf',
+  category: ['temporal'],
+  description: 'Returns the minute component of a Time or DateTime value (0-59)',
+  examples: [
+    '@T10:30:00.minuteOf()',
+    '@2014-01-05T10:30:00.minuteOf()',
+    'Observation.effectiveDateTime.minuteOf()'
+  ],
+  signatures: [
+    {
+      name: 'minuteOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: minuteOfEvaluator
+};

package/src/operations/mod-operator.ts

@@ -1,7 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {

package/src/operations/monthOf-function.ts

@@ -0,0 +1,66 @@
+// monthOf() function - Extracts month component from Date or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDate, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const monthOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // monthOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('monthOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('monthOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Date or DateTime
+  if (isFHIRDate(value) || isFHIRDateTime(value)) {
+    // Check if month component is present
+    if (value.month === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the month as an Integer (1-12)
+    return {
+      value: [box(value.month, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Date or DateTime, return empty
+  return { value: [], context };
+};
+
+export const monthOfFunction: FunctionDefinition & { evaluate: typeof monthOfEvaluator } = {
+  name: 'monthOf',
+  category: ['temporal'],
+  description: 'Returns the month component of a Date or DateTime value (1-12)',
+  examples: [
+    '@2014-01-05.monthOf()',
+    '@2014-01-05T10:30:00.monthOf()',
+    'Patient.birthDate.monthOf()'
+  ],
+  signatures: [
+    {
+      name: 'monthOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: monthOfEvaluator
+};

package/src/operations/multiply-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { multiplyQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { multiplyQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -71,6 +71,30 @@ export const multiplyOperator: OperatorDefinition & { evaluate: OperationEvaluat
       left: { type: 'Quantity', singleton: true },
       right: { type: 'Quantity', singleton: true },
       result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'quantity-integer-multiply',
+      left: { type: 'Quantity', singleton: true },
+      right: { type: 'Integer', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'integer-quantity-multiply',
+      left: { type: 'Integer', singleton: true },
+      right: { type: 'Quantity', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'quantity-decimal-multiply',
+      left: { type: 'Quantity', singleton: true },
+      right: { type: 'Decimal', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'decimal-quantity-multiply',
+      left: { type: 'Decimal', singleton: true },
+      right: { type: 'Quantity', singleton: true },
+      result: { type: 'Quantity', singleton: true },
     }
   ],
   evaluate

package/src/operations/not-equal-operator.ts

@@ -1,33 +1,19 @@
-import type { OperatorDefinition } from '../types';
+import type { OperatorDefinition, OperationEvaluator } from '../types';
 import { PRECEDENCE } from '../types';
-import type { OperationEvaluator } from '../types';
-import { equalQuantities, compareQuantities, type QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { box } from '../interpreter/boxing';
+import { collectionsNotEqual } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  if (left.length === 0 || right.length === 0) {
-    return { value: [], context };
-  }
-  
-  const boxedl = left[0];
-  if (!boxedl) return { value: [], context };
-  const l = unbox(boxedl);
-  const boxedr = right[0];
-  if (!boxedr) return { value: [], context };
-  const r = unbox(boxedr);
+  // Use the unified comparison system
+  const result = collectionsNotEqual(left, right);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const comparison = compareQuantities(l as QuantityValue, r as QuantityValue);
-    // If quantities are incomparable (different dimensions), return empty
-    if (comparison === null) {
-      return { value: [], context };
-    }
-    return { value: [box(comparison !== 0, { type: 'Boolean', singleton: true })], context };
+  // null means incomparable (returns empty)
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(l !== r, { type: 'Boolean', singleton: true })], context };
+  // Return the boolean result
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const notEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -38,11 +24,19 @@ export const notEqualOperator: OperatorDefinition & { evaluate: OperationEvaluat
   associativity: 'left',
   description: 'The converse of the equals operator, returning true if equal returns false; false if equal returns true; and empty ({ }) if equal returns empty',
   examples: ['name != "John"', 'Patient.gender != "male"', '5 != 3'],
-  signatures: [{
-    name: 'not-equal',
-    left: { type: 'Any', singleton: true },
-    right: { type: 'Any', singleton: true },
-    result: { type: 'Boolean', singleton: true },
-  }],
+  signatures: [
+    {
+      name: 'not-equal',
+      left: { type: 'Any', singleton: true },
+      right: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true },
+    },
+    {
+      name: 'not-equal',
+      left: { type: 'Any', singleton: false },
+      right: { type: 'Any', singleton: false },
+      result: { type: 'Boolean', singleton: true },
+    }
+  ],
   evaluate
 };

package/src/operations/not-equivalent-operator.ts

@@ -1,64 +1,23 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box } from '../interpreter/boxing';
+import { collectionsNotEquivalent } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  // Empty collections are equivalent, so not-equivalent returns false
-  if (left.length === 0 && right.length === 0) {
-    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // Different sizes are not equivalent, so not-equivalent returns true
-  if (left.length !== right.length) {
-    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // For single items, check type-specific non-equivalence
-  if (left.length === 1 && right.length === 1) {
-    const boxedl = left[0];
-  if (!boxedl) return { value: [], context };
-  const l = unbox(boxedl);
-    const boxedr = right[0];
-  if (!boxedr) return { value: [], context };
-  const r = unbox(boxedr);
-    
-    // String non-equivalence: case-insensitive with normalized whitespace
-    if (typeof l === 'string' && typeof r === 'string') {
-      const normalizeString = (s: string) => s.trim().toLowerCase().replace(/\s+/g, ' ');
-      return { value: [box(normalizeString(l) !== normalizeString(r), { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // Number non-equivalence (for Integer and Decimal)
-    if (typeof l === 'number' && typeof r === 'number') {
-      // For decimals with different precision, round to least precise
-      // This is a simplified implementation
-      return { value: [box(Math.abs(l - r) >= Number.EPSILON, { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // Boolean non-equivalence
-    if (typeof l === 'boolean' && typeof r === 'boolean') {
-      return { value: [box(l !== r, { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // For complex types and other cases, use inequality for now
-    // TODO: Implement full non-equivalence logic for Date/DateTime/Time and complex types
-    return { value: [box(l !== r, { type: 'Boolean', singleton: true })], context };
-  }
+  // Use the new collectionsNotEquivalent function from comparison.ts
+  const result = collectionsNotEquivalent(left, right);
   
-  // For multiple items, comparison is order-independent
-  // Create sorted copies for comparison
-  // TODO: Implement proper order-independent comparison with recursive equivalence
-  const leftSorted = [...left].sort();
-  const rightSorted = [...right].sort();
-  
-  for (let i = 0; i < leftSorted.length; i++) {
-    if (leftSorted[i] !== rightSorted[i]) {
-      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
-    }
+  // null result means incomparable - return empty collection
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  // Return boolean result
+  return {
+    value: [box(result, { type: 'Boolean', singleton: true })],
+    context
+  };
 };
 
 export const notEquivalentOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -67,6 +26,7 @@ export const notEquivalentOperator: OperatorDefinition & { evaluate: OperationEv
   category: ['equality'],
   precedence: PRECEDENCE.EQUALITY,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Empty collections are valid operands for not-equivalence
   description: 'The converse of the equivalent operator, returning true if equivalent returns false and false if equivalent returns true. In other words, A !~ B is short-hand for (A ~ B).not()',
   examples: [
     "'abc' !~ 'ABC'",

package/src/operations/not-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition } from '../types';
 import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Three-valued logic implementation

package/src/operations/ofType-function.ts

@@ -1,9 +1,8 @@
 import type { FunctionDefinition, RuntimeContext, ASTNode, TypeInfo, NodeEvaluator, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import type { FHIRPathValue } from '../boxing';
-import { unbox } from '../boxing';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { unbox } from '../interpreter/boxing';
 import { isIdentifierNode, isFunctionNode } from '../types';
-import { NodeType } from '../types';
 
 export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'ofType',
@@ -21,7 +20,8 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
       { 
         name: 'type', 
         type: { type: 'Any', singleton: true },
-        expression: true
+        expression: true,
+        typeReference: true // This parameter expects a type name
       }
     ],
     result: 'inputType'
@@ -37,10 +37,6 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
     let targetTypeName: string;
     if (isIdentifierNode(typeArg)) {
       targetTypeName = typeArg.name;
-    } else if (typeArg.type === NodeType.TypeOrIdentifier) {
-      targetTypeName = (typeArg as any).name;
-    } else if (typeArg.type === NodeType.TypeReference) {
-      targetTypeName = (typeArg as any).name;
     } else if (isFunctionNode(typeArg) && isIdentifierNode(typeArg.name)) {
       // Handle cases like ofType(Patient())
       targetTypeName = typeArg.name.name;
@@ -91,9 +87,9 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
         return matchingType !== undefined;
       }
       
-      // Check if the box has type information
-      if (boxedItem.typeInfo) {
-        // If we have type info, use it for accurate filtering
+      // Check if the box has specific type information (not just "Any")
+      if (boxedItem.typeInfo && boxedItem.typeInfo.type !== 'Any') {
+        // If we have specific type info, use it for accurate filtering
         return boxedItem.typeInfo.type === targetTypeName;
       }
       
@@ -136,4 +132,4 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
 
     return { value: actualFiltered, context };
   }
-};
+};