@atomic-ehr/fhirpath 0.0.2 → 0.0.3-canary.2be66fb.20250905161900

package/src/interpreter.ts

@@ -8,7 +8,6 @@ import type {
   VariableNode,
   CollectionNode,
   IndexNode,
-  TypeOrIdentifierNode,
   MembershipTestNode,
   TypeCastNode,
   QuantityNode
@@ -16,152 +15,22 @@ import type {
 import { NodeType } from './types';
 import { Registry } from './registry';
 import * as operations from './operations';
-import type { EvaluationResult, FunctionEvaluator, NodeEvaluator, OperationEvaluator, RuntimeContext } from './types';
-import { createQuantity } from './quantity-value';
-import { box, unbox, ensureBoxed, type FHIRPathValue } from './boxing';
+import type { EvaluationResult, FunctionEvaluator, NodeEvaluator, OperationEvaluator, RuntimeContext, TypeInfo } from './types';
+import { createQuantity } from './complex-types/quantity-value';
+import { box, unbox, ensureBoxed, type FHIRPathValue } from './interpreter/boxing';
 import { Errors } from './errors';
+import { detectChoiceValues, getPrimitiveElement, maybeParseTemporal, reboxResource } from './interpreter/navigator';
+import { RuntimeContextManager } from './interpreter/runtime-context';
+import { Analyzer } from './analyzer';
+import { DiagnosticSeverity } from './types';
+import { FHIRPathError, ErrorCodes } from './errors';
+import { toTemporalString } from './complex-types/temporal';
 
 /**
  * Runtime context manager that provides efficient prototype-based context operations
  * for both interpreter and compiler.
  */
-export class RuntimeContextManager {
-  /**
-   * Create a new runtime context
-   */
-  static create(input: any[], initialVariables?: Record<string, any>): RuntimeContext {
-    const context = Object.create(null) as RuntimeContext;
-    
-    context.input = input;
-    context.focus = input;
-    
-    // Create variables object with null prototype to avoid pollution
-    context.variables = Object.create(null);
-    
-    // Set root context variables with % prefix
-    context.variables['%context'] = input;
-    context.variables['%resource'] = input;
-    context.variables['%rootResource'] = input;
-    
-    // Add any initial variables (with % prefix for user-defined)
-    if (initialVariables) {
-      for (const [key, value] of Object.entries(initialVariables)) {
-        // Add % prefix if not already present and not a special variable
-        const varKey = key.startsWith('$') || key.startsWith('%') ? key : `%${key}`;
-        context.variables[varKey] = value;
-      }
-    }
-    
-    return context;
-  }
-
-  /**
-   * Create a child context using prototype inheritance
-   * O(1) operation - no copying needed
-   */
-  static copy(context: RuntimeContext): RuntimeContext {
-    // Create child context with parent as prototype
-    const newContext = Object.create(context) as RuntimeContext;
-    
-    // Create child variables that inherit from parent's variables
-    newContext.variables = Object.create(context.variables);
-    
-    // input and focus are inherited through prototype chain
-    // Only set them if they need to change
-    
-    return newContext;
-  }
-
-  /**
-   * Create a new context with updated input/focus
-   */
-  static withInput(context: RuntimeContext, input: any[], focus?: any[]): RuntimeContext {
-    const newContext = this.copy(context);
-    newContext.input = input;
-    newContext.focus = focus ?? input;
-    return newContext;
-  }
-
-  /**
-   * Set iterator context ($this, $index)
-   */
-  static withIterator(
-    context: RuntimeContext, 
-    item: any, 
-    index: number
-  ): RuntimeContext {
-    let newContext = this.setVariable(context, '$this', [item], true);
-    newContext = this.setVariable(newContext, '$index', index, true);
-    return newContext;
-  }
-
-  /**
-   * Set a variable in the context (handles both special $ and user % variables)
-   */
-  static setVariable(context: RuntimeContext, name: string, value: any, allowRedefinition: boolean = false): RuntimeContext {
-    // Ensure value is array for consistency (except for special variables like $index)
-    const arrayValue = (name === '$index' || name === '$total') ? value : 
-                      Array.isArray(value) ? value : [value];
-    
-    // Determine variable key based on prefix
-    let varKey = name;
-    if (!name.startsWith('$') && !name.startsWith('%')) {
-      // No prefix - assume user-defined variable, add % prefix
-      varKey = `%${name}`;
-    }
-    
-    // Check for system variables (with or without % prefix)
-    const systemVariables = ['context', 'resource', 'rootResource', 'ucum', 'sct', 'loinc'];
-    const baseVarName = varKey.startsWith('%') ? varKey.substring(1) : varKey;
-    if (systemVariables.includes(baseVarName)) {
-      // Silently return original context for system variable redefinition
-      return context;
-    }
-    
-    // Check if variable already exists (unless redefinition is allowed)
-    if (!allowRedefinition && context.variables && Object.prototype.hasOwnProperty.call(context.variables, varKey)) {
-      // Silently return original context for variable redefinition
-      return context;
-    }
-    
-    // Create new context and set variable
-    const newContext = this.copy(context);
-    newContext.variables[varKey] = arrayValue;
-    
-    // Special handling for $this
-    if (varKey === '$this' && Array.isArray(arrayValue) && arrayValue.length === 1) {
-      newContext.input = arrayValue;
-      newContext.focus = arrayValue;
-    }
-    
-    return newContext;
-  }
-
-  /**
-   * Get a variable from context
-   */
-  static getVariable(context: RuntimeContext, name: string): any | undefined {
-    // Handle special cases
-    if (name === '$this' || name === '$index' || name === '$total') {
-      return context.variables[name];
-    }
-    
-    // Handle environment variables (with or without % prefix)
-    if (name === 'context' || name === '%context') {
-      return context.variables['%context'];
-    }
-    if (name === 'resource' || name === '%resource') {
-      return context.variables['%resource'];
-    }
-    if (name === 'rootResource' || name === '%rootResource') {
-      return context.variables['%rootResource'];
-    }
-    
-    // Handle user-defined variables (add % prefix if not present)
-    const varKey = name.startsWith('%') ? name : `%${name}`;
-    return context.variables[varKey];
-  }
-}
+// RuntimeContextManager moved to './runtime-context'
 
 export class Interpreter {
   private registry: Registry;
@@ -179,8 +48,8 @@ export class Interpreter {
     // Initialize node evaluators using object dispatch pattern
     this.nodeEvaluators = {
       [NodeType.Literal]: this.evaluateLiteral.bind(this),
+      [NodeType.TemporalLiteral]: this.evaluateTemporalLiteral.bind(this),
       [NodeType.Identifier]: this.evaluateIdentifier.bind(this),
-      [NodeType.TypeOrIdentifier]: this.evaluateTypeOrIdentifier.bind(this),
       [NodeType.Binary]: this.evaluateBinary.bind(this),
       [NodeType.Unary]: this.evaluateUnary.bind(this),
       [NodeType.Function]: this.evaluateFunction.bind(this),
@@ -256,226 +125,329 @@ export class Interpreter {
     return context;
   }
 
+  /**
+   * Parse, analyze and evaluate a FHIRPath expression with optional
+   * model provider, variables and input type. Returns unboxed values
+   * with temporal values formatted as FHIRPath literals.
+   */
+  async evaluateExpression(
+    expression: string,
+    options: {
+      input?: unknown;
+      variables?: Record<string, unknown>;
+      inputType?: TypeInfo;
+      modelProvider?: import('./types').ModelProvider;
+      now?: Date;
+    } = {}
+  ): Promise<any[]> {
+    // Analyze expression first (ensures type info and diagnostics)
+    const analysis = await Analyzer.analyzeExpression(expression, {
+      variables: options.variables,
+      modelProvider: options.modelProvider ?? this.modelProvider,
+      inputType: options.inputType,
+      errorRecovery: false,
+    });
+
+    const errors = analysis.diagnostics.filter(d => d.severity === DiagnosticSeverity.Error);
+    if (errors.length > 0) {
+      const first = errors[0]!;
+      const code = typeof first.code === 'string' && first.code.length > 0 ? first.code : ErrorCodes.INVALID_OPERATION;
+      throw new FHIRPathError(code, first.message, first.range);
+    }
+
+    // Bootstrap runtime context and boxed input
+    const { context, input } = await RuntimeContextManager.bootstrapContext(options.input, {
+      modelProvider: options.modelProvider ?? this.modelProvider,
+      variables: options.variables,
+      now: options.now,
+    });
+
+    // Evaluate using analyzed AST and BOXED input
+    const result = await this.evaluate(analysis.ast, input as any[], context);
+
+    // Unbox and format temporal outputs for API parity
+    return result.value.map((boxedValue) => {
+      const value = unbox(boxedValue);
+      if (value && typeof value === 'object' && 'kind' in value) {
+        if ((value as any).kind === 'FHIRDate' || (value as any).kind === 'FHIRDateTime') {
+          return '@' + toTemporalString(value as any);
+        } else if ((value as any).kind === 'FHIRTime') {
+          return '@T' + toTemporalString(value as any);
+        }
+      }
+      return value;
+    });
+  }
+
+  // Helper: classify a boolean operand for short-circuit decisions
+  private getBooleanKind(values: FHIRPathValue[]): 'empty' | 'true' | 'false' | 'other' {
+    if (values.length === 0) {
+      return 'empty';
+    }
+    const v = unbox(values[0]!);
+    if (v === true) {
+      return 'true';
+    }
+    if (v === false) {
+      return 'false';
+    }
+    return 'other';
+  }
+
+  private boxBoolean(b: boolean): FHIRPathValue {
+    return box(b, { type: 'Boolean', singleton: true });
+  }
+
+  // TemporalLiteral node evaluator
+  private async evaluateTemporalLiteral(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
+    const temporal = node as import('./types').TemporalLiteralNode;
+    
+    // The value is already parsed in the parser
+    let typeInfo: import('./types').TypeInfo;
+    
+    if (temporal.valueType === 'date') {
+      typeInfo = { type: 'Date', singleton: true };
+    } else if (temporal.valueType === 'datetime') {
+      typeInfo = { type: 'DateTime', singleton: true };
+    } else {
+      typeInfo = { type: 'Time', singleton: true };
+    }
+    
+    return {
+      value: [box(temporal.value, typeInfo)],
+      context
+    };
+  }
+
   // Literal node evaluator
   private async evaluateLiteral(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const literal = node as LiteralNode;
     
     // Box the literal value with appropriate type info
     let typeInfo: import('./types').TypeInfo | undefined;
-    const value = literal.value;
+    let value: any = literal.value;
     
-    if (typeof value === 'string') {
+    // Handle temporal literals (backwards compatibility - should not reach here with new parser)
+    if (literal.valueType === 'date' || literal.valueType === 'datetime' || literal.valueType === 'time') {
+      // Import temporal parsing function
+      const { parseTemporalLiteral } = await import('./complex-types/temporal');
+      // Parse the temporal literal (add @ back since it was stripped by parser)
+      const temporalValue = parseTemporalLiteral('@' + literal.value);
+      
+      // Set appropriate type info
+      if (literal.valueType === 'date') {
+        typeInfo = { type: 'Date', singleton: true };
+      } else if (literal.valueType === 'datetime') {
+        typeInfo = { type: 'DateTime', singleton: true };
+      } else if (literal.valueType === 'time') {
+        typeInfo = { type: 'Time', singleton: true };
+      }
+      
+      value = temporalValue;
+    } else if (typeof value === 'string') {
       typeInfo = { type: 'String', singleton: true };
     } else if (typeof value === 'number') {
-      typeInfo = Number.isInteger(value) ? 
-        { type: 'Integer', singleton: true } : 
-        { type: 'Decimal', singleton: true };
+      // Use the valueType from the literal node to determine if it's integer or decimal
+      // This preserves the distinction between 1.0 (decimal) and 1 (integer)
+      typeInfo = literal.valueType === 'decimal' ? 
+        { type: 'Decimal', singleton: true } : 
+        { type: 'Integer', singleton: true };
     } else if (typeof value === 'boolean') {
       typeInfo = { type: 'Boolean', singleton: true };
     }
     
     return {
-      value: [box(literal.value, typeInfo)],
+      value: [box(value, typeInfo)],
       context
     };
   }
 
-  // Identifier node evaluator
-  private async evaluateIdentifier(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
-    const identifier = node as IdentifierNode;
-    const name = identifier.name;
+  // Helper: Handle extension elements
+  private handleExtension(
+    boxedItem: FHIRPathValue, 
+    nodeTypeInfo?: TypeInfo
+  ): FHIRPathValue[] {
+    const results: FHIRPathValue[] = [];
+    if (boxedItem.primitiveElement?.extension) {
+      for (const ext of boxedItem.primitiveElement.extension) {
+        results.push(box(ext, nodeTypeInfo || { type: 'Any', singleton: false }));
+      }
+    }
+    return results;
+  }
 
-    // Navigate property on each boxed item in input
+  // Helper: Handle FHIR choice types (e.g., value[x])
+  private async handleChoiceTypes(
+    item: object,
+    name: string,
+    context: RuntimeContext
+  ): Promise<FHIRPathValue[]> {
     const results: FHIRPathValue[] = [];
-    
-    // Get the type info from the node (set by analyzer)
-    const nodeTypeInfo = node.typeInfo;
-    
-    for (const boxedItem of input) {
-      const item = unbox(boxedItem);
-      
-      // Special handling for primitive extension navigation
-      if (name === 'extension' && boxedItem.primitiveElement?.extension) {
-        // Navigation from a primitive value to its extensions
-        for (const ext of boxedItem.primitiveElement.extension) {
-          results.push(box(ext, nodeTypeInfo || { type: 'Any', singleton: false }));
+    const choiceHits = await detectChoiceValues(item as Record<string, unknown>, name, context.modelProvider);
+    for (const hit of choiceHits) {
+      results.push(box(hit.value, hit.typeInfo, hit.primitiveElement));
+    }
+    return results;
+  }
+
+  // Helper: Handle union type choices
+  private handleUnionChoices(
+    item: object,
+    nodeTypeInfo?: TypeInfo
+  ): FHIRPathValue[] {
+    const results: FHIRPathValue[] = [];
+    if (
+      nodeTypeInfo?.modelContext &&
+      typeof nodeTypeInfo.modelContext === 'object' &&
+      'isUnion' in nodeTypeInfo.modelContext &&
+      (nodeTypeInfo.modelContext as any).isUnion &&
+      'choices' in nodeTypeInfo.modelContext &&
+      Array.isArray((nodeTypeInfo.modelContext as any).choices)
+    ) {
+      for (const choice of (nodeTypeInfo.modelContext as any).choices) {
+        const choiceName = choice.choiceName;
+        if (choiceName && choiceName in (item as any)) {
+          const value = (item as any)[choiceName];
+          const primitiveElement = getPrimitiveElement(item as Record<string, unknown>, choiceName);
+          const choiceTypeInfo = { type: choice.type, singleton: !Array.isArray(value), modelContext: choice } as any;
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              results.push(box(v, { ...choiceTypeInfo, singleton: true }, primitiveElement));
+            }
+          } else if (value !== null && value !== undefined) {
+            results.push(box(value, choiceTypeInfo, primitiveElement));
+          }
         }
-        continue;
       }
-      
-      if (item && typeof item === 'object') {
-        // First, check if this might be a FHIR choice type by looking for choice properties
-        // FHIR choice types use the pattern: base name + Type suffix (e.g., valueQuantity, valueCodeableConcept)
-        let foundChoiceValue = false;
+    }
+    return results;
+  }
+
+  // Helper: Handle standard property access
+  private async handleStandardProperty(
+    item: object,
+    name: string,
+    nodeTypeInfo: TypeInfo | undefined,
+    context: RuntimeContext,
+    parentTypeInfo?: TypeInfo
+  ): Promise<FHIRPathValue[]> {
+    const results: FHIRPathValue[] = [];
+    if (name in (item as any)) {
+      const value = (item as any)[name];
+      const primitiveElement = getPrimitiveElement(item as Record<string, unknown>, name);
+
+      // Determine if this is a FHIR primitive - if parent is a FHIR resource and value is primitive
+      const isFHIRPrimitive = parentTypeInfo && 
+                              parentTypeInfo.type && 
+                              parentTypeInfo.type !== 'Any' && 
+                              !parentTypeInfo.type.startsWith('System.') &&
+                              (typeof value === 'boolean' || typeof value === 'string' || typeof value === 'number');
+
+      if (Array.isArray(value)) {
+        let elementTypeInfo = nodeTypeInfo ? { ...nodeTypeInfo, singleton: true } : undefined;
         
-        // Check for FHIR choice type pattern
-        if (context.modelProvider) {
-          // Try common FHIR choice patterns
-          const possibleChoiceProperties = Object.keys(item).filter(key => 
-            key.startsWith(name) && key !== name && key.length > name.length
-          );
-          
-          if (possibleChoiceProperties.length > 0) {
-            // This looks like a choice type - return all matching values
-            for (const choiceProp of possibleChoiceProperties) {
-              const value = item[choiceProp];
-              const primitiveElementName = `_${choiceProp}`;
-              const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
-              
-              // Try to determine the type from the property name suffix
-              let choiceType = 'Any';
-              const suffix = choiceProp.substring(name.length);
-              if (suffix) {
-                // Remove leading uppercase letter and make it the type
-                choiceType = suffix;
-              }
-              
-              if (Array.isArray(value)) {
-                for (const v of value) {
-                  // For FHIR resources, use their resourceType
-                  if (v && typeof v === 'object' && 'resourceType' in v) {
-                    const typeInfo = await context.modelProvider!.getType(v.resourceType);
-                    results.push(box(v, typeInfo || { type: v.resourceType as any, singleton: true }, primitiveElement));
-                  } else {
-                    results.push(box(v, { type: choiceType as any, singleton: true }, primitiveElement));
-                  }
-                }
-              } else if (value !== null && value !== undefined) {
-                // For FHIR resources, use their resourceType
-                if (value && typeof value === 'object' && 'resourceType' in value) {
-                  const typeInfo = await context.modelProvider!.getType(value.resourceType);
-                  results.push(box(value, typeInfo || { type: value.resourceType as any, singleton: true }, primitiveElement));
-                } else {
-                  results.push(box(value, { type: choiceType as any, singleton: !Array.isArray(value) }, primitiveElement));
-                }
-              }
-              foundChoiceValue = true;
-            }
+        // For FHIR primitives, use FHIR namespace
+        if (isFHIRPrimitive && elementTypeInfo) {
+          if (elementTypeInfo.type === 'Boolean') {
+            elementTypeInfo = { ...elementTypeInfo, type: 'boolean' as any };
           }
         }
         
-        // Check if this is a choice type navigation from analyzer
-        if (!foundChoiceValue && nodeTypeInfo?.modelContext && typeof nodeTypeInfo.modelContext === 'object' &&
-            'isUnion' in nodeTypeInfo.modelContext && 
-            nodeTypeInfo.modelContext.isUnion && 'choices' in nodeTypeInfo.modelContext &&
-            Array.isArray(nodeTypeInfo.modelContext.choices)) {
-          // For choice types, look for any of the choice properties
-          for (const choice of nodeTypeInfo.modelContext.choices) {
-            const choiceName = choice.choiceName;
-            if (choiceName && choiceName in item) {
-              const value = item[choiceName];
-              const primitiveElementName = `_${choiceName}`;
-              const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
-              
-              // Box with the specific choice type
-              const choiceTypeInfo = {
-                type: choice.type,
-                singleton: !Array.isArray(value),
-                modelContext: choice
-              };
-              
-              if (Array.isArray(value)) {
-                for (const v of value) {
-                  results.push(box(v, { ...choiceTypeInfo, singleton: true }, primitiveElement));
-                }
-              } else if (value !== null && value !== undefined) {
-                results.push(box(value, choiceTypeInfo, primitiveElement));
-              }
-              foundChoiceValue = true;
-            }
+        for (const v of value) {
+          if (
+            v && typeof v === 'object' && 'resourceType' in (v as any) && typeof (v as any).resourceType === 'string'
+          ) {
+            // Always re-box FHIR resources to get proper type information from ModelProvider
+            const boxed = await reboxResource(v, true, context.modelProvider);
+            results.push(boxed);
+          } else {
+            const val = await maybeParseTemporal(v, elementTypeInfo, context.modelProvider);
+            results.push(box(val, elementTypeInfo, primitiveElement));
           }
         }
-        
-        if (!foundChoiceValue && name in item) {
-          // Regular property navigation
-          const value = item[name];
-          const primitiveElementName = `_${name}`;
-          const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
-          
-          if (Array.isArray(value)) {
-            // Box each array element with type info
-            // For arrays, make the type singleton since each element is a single value
-            const elementTypeInfo = nodeTypeInfo ? { ...nodeTypeInfo, singleton: true } : undefined;
-            for (const v of value) {
-              // Special handling for FHIR resources - use their resourceType
-              // Do this when the property could be polymorphic (type is 'Any' or 'Resource')
-              if (v && typeof v === 'object' && 'resourceType' in v && typeof v.resourceType === 'string' &&
-                  (!elementTypeInfo || elementTypeInfo.type === 'Any' || (elementTypeInfo as any).type === 'Resource')) {
-                // Get full type info from model provider if available
-                let resourceTypeInfo;
-                if (context.modelProvider) {
-                  resourceTypeInfo = await context.modelProvider.getType(v.resourceType);
-                  if (resourceTypeInfo) {
-                    // Make it singleton since it's a single element in the array
-                    resourceTypeInfo = { ...resourceTypeInfo, singleton: true };
-                  }
-                }
-                if (!resourceTypeInfo) {
-                  // Fallback to basic type info
-                  resourceTypeInfo = {
-                    type: v.resourceType as import('./types').TypeName,
-                    singleton: true
-                  };
-                }
-                results.push(box(v, resourceTypeInfo, primitiveElement));
-              } else {
-                results.push(box(v, elementTypeInfo, primitiveElement));
-              }
-            }
-          } else if (value !== null && value !== undefined) {
-            // Special handling for FHIR resources - use their resourceType
-            // Do this when the property could be polymorphic (type is 'Any' or 'Resource')
-            if (value && typeof value === 'object' && 'resourceType' in value && typeof value.resourceType === 'string' &&
-                (!nodeTypeInfo || nodeTypeInfo.type === 'Any' || (nodeTypeInfo as any).type === 'Resource')) {
-              // Get full type info from model provider if available
-              let resourceTypeInfo;
-              if (context.modelProvider) {
-                resourceTypeInfo = await context.modelProvider.getType(value.resourceType);
-                if (resourceTypeInfo) {
-                  // Preserve singleton status
-                  resourceTypeInfo = { ...resourceTypeInfo, singleton: !Array.isArray(value) };
-                }
-              }
-              if (!resourceTypeInfo) {
-                // Fallback to basic type info
-                resourceTypeInfo = {
-                  type: value.resourceType as import('./types').TypeName,
-                  singleton: !Array.isArray(value)
-                };
-              }
-              results.push(box(value, resourceTypeInfo, primitiveElement));
-            } else {
-              // Box single value with primitive element if available
-              results.push(box(value, nodeTypeInfo, primitiveElement));
+      } else if (value !== null && value !== undefined) {
+        if (
+          value && typeof value === 'object' && 'resourceType' in (value as any) && typeof (value as any).resourceType === 'string'
+        ) {
+          // Always re-box FHIR resources to get proper type information from ModelProvider
+          const boxed = await reboxResource(value, true, context.modelProvider);
+          results.push(boxed);
+        } else {
+          // For FHIR primitives, use FHIR namespace
+          let typeInfo = nodeTypeInfo;
+          if (isFHIRPrimitive && typeInfo) {
+            if (typeInfo.type === 'Boolean') {
+              typeInfo = { ...typeInfo, type: 'boolean' as any };
             }
           }
+          
+          const val = await maybeParseTemporal(value, typeInfo, context.modelProvider);
+          results.push(box(val, typeInfo, primitiveElement));
         }
       }
     }
-
-    return {
-      value: results,
-      context
-    };
+    return results;
   }
 
-  // TypeOrIdentifier node evaluator (handles Patient, Observation, etc.)
-  private async evaluateTypeOrIdentifier(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
-    const typeOrId = node as TypeOrIdentifierNode;
-    const name = typeOrId.name;
+  // Identifier node evaluator
+  private async evaluateIdentifier(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
+    const identifier = node as IdentifierNode;
+    const name = identifier.name;
+    const nodeTypeInfo = node.typeInfo;
+    const results: FHIRPathValue[] = [];
 
-    // First try as type filter
-    const filtered = input.filter(boxedItem => {
+    for (const boxedItem of input) {
       const item = unbox(boxedItem);
-      return item && typeof item === 'object' && item.resourceType === name;
-    });
 
-    if (filtered.length > 0) {
-      return { value: filtered, context };
+      // 1. Handle extension special case
+      if (name === 'extension') {
+        results.push(...this.handleExtension(boxedItem, nodeTypeInfo));
+        continue;
+      }
+
+      // Process only objects
+      if (item && typeof item === 'object') {
+        // 2. Handle FHIR choice types (e.g., value[x])
+        const choiceResults = await this.handleChoiceTypes(item, name, context);
+        if (choiceResults.length > 0) {
+          results.push(...choiceResults);
+          continue;
+        }
+
+        // 3. Handle union type choices
+        const unionResults = this.handleUnionChoices(item, nodeTypeInfo);
+        results.push(...unionResults);
+
+        // 4. Handle standard property access
+        const propertyResults = await this.handleStandardProperty(item, name, nodeTypeInfo, context, boxedItem.typeInfo);
+        results.push(...propertyResults);
+      }
     }
 
-    // Otherwise treat as identifier
-    return await this.evaluateIdentifier(node, input, context);
+    // If no properties matched, try type-filter fallback on resources
+    if (results.length === 0) {
+      const filtered: FHIRPathValue[] = [];
+      for (const boxedItem of input) {
+        const item = unbox(boxedItem);
+        if (item && typeof item === 'object' && (item as any).resourceType === name) {
+          if (context.modelProvider) {
+            const typeInfo = await context.modelProvider.getType(name);
+            if (typeInfo) {
+              filtered.push(box(item, { ...typeInfo, singleton: true }));
+            } else {
+              filtered.push(boxedItem);
+            }
+          } else {
+            filtered.push(boxedItem);
+          }
+        }
+      }
+      if (filtered.length > 0) {
+        return { value: filtered, context };
+      }
+    }
+
+    return { value: results, context };
   }
 
   // Binary operator evaluator
@@ -485,8 +457,29 @@ export class Interpreter {
 
     // Special handling for dot operator (sequential pipeline)
     if (operator === '.') {
+      // Check if this is actually a namespaced type in an 'is' expression
+      // Parser incorrectly creates: (true is System).Boolean instead of: true is System.Boolean
+      if (binary.left.type === NodeType.MembershipTest && binary.right.type === NodeType.Identifier) {
+        const membershipTest = binary.left as MembershipTestNode;
+        const rightIdent = binary.right as IdentifierNode;
+        
+        // Extract the expression from the membership test
+        const expr = membershipTest.expression;
+        const typeName = `${membershipTest.targetType}.${rightIdent.name}`;
+        
+        // Evaluate the expression
+        const exprResult = await this.evaluate(expr, input, context);
+        
+        // Now apply the is operator with the full type name
+        const evaluator = this.operationEvaluators.get('is');
+        if (evaluator) {
+          return await evaluator(input, context, exprResult.value, [typeName]);
+        }
+      }
+      
       // Evaluate left with current input/context
       const leftResult = await this.evaluate(binary.left, input, context);
+      
       // Use left's output as right's input, and left's context flows to right
       return await this.evaluate(binary.right, leftResult.value, leftResult.context);
     }
@@ -495,28 +488,120 @@ export class Interpreter {
     if (operator === '|') {
       // Each side of union should have its own variable scope
       // Variables defined on left side should not be visible on right side
-      const leftResult = await this.evaluate(binary.left, input, context);
-      const rightResult = await this.evaluate(binary.right, input, context); // Use original context, not leftResult.context
+      // Evaluate both sides in parallel since both use the same input/context
+      const [leftResult, rightResult] = await Promise.all([
+        this.evaluate(binary.left, input, context),
+        this.evaluate(binary.right, input, context)
+      ]);
       
       // Merge the results
-      const unionEvaluator = this.operationEvaluators.get('union');
+      const unionEvaluator = this.operationEvaluators.get('|');
       if (unionEvaluator) {
         return await unionEvaluator(input, context, leftResult.value, rightResult.value);
       }
-      
-      // Fallback if union evaluator not found
-      return {
-        value: [...leftResult.value, ...rightResult.value],
-        context  // Original context preserved
-      };
+      // If union evaluator not found, surface a clear error
+      throw Errors.noEvaluatorFound('binary operator', '|');
     }
 
+    // Special handling for 'is' and 'as' operators - right side is a type identifier, not an expression
+    if (operator === 'is' || operator === 'as') {
+      const leftResult = await this.evaluate(binary.left, input, context);
+      
+      // Extract type name from right side WITHOUT evaluating it
+      let typeName: string;
+      if (binary.right.type === NodeType.Identifier) {
+        typeName = (binary.right as any).name;
+      } else if (binary.right.type === NodeType.Binary && (binary.right as any).operator === '.') {
+        // Handle namespaced types like System.Boolean or FHIR.Patient
+        const rightBinary = binary.right as any;
+        if (rightBinary.left.type === NodeType.Identifier && rightBinary.right.type === NodeType.Identifier) {
+          typeName = `${rightBinary.left.name}.${rightBinary.right.name}`;
+        } else {
+          throw new Error('is operator requires a type name as right operand');
+        }
+      } else {
+        throw new Error('is operator requires a type name as right operand');
+      }
+      
+      const evaluator = this.operationEvaluators.get('is');
+      if (evaluator) {
+        return await evaluator(input, context, leftResult.value, [typeName]);
+      }
+    }
+    
     // Get operation evaluator
     const evaluator = this.operationEvaluators.get(operator);
     if (evaluator) {
-      // Most operators evaluate arguments in parallel with same input/context
-      const leftResult = await this.evaluate(binary.left, input, context);
-      const rightResult = await this.evaluate(binary.right, input, context);
+      // Short-circuit for logical operators when possible
+      if (operator === 'and' || operator === 'or' || operator === 'implies') {
+        const leftResult = await this.evaluate(binary.left, input, context);
+        const kind = this.getBooleanKind(leftResult.value);
+
+        if (operator === 'and') {
+          // false and _ -> false (short-circuit)
+          if (kind === 'false') {
+            return { value: [this.boxBoolean(false)], context };
+          }
+          // true and y -> y; empty and false -> false handled by evaluator; need right
+          const rightResult = await this.evaluate(binary.right, input, context);
+          const operatorDef = this.registry.getOperatorDefinition(operator);
+          if (operatorDef && !operatorDef.doesNotPropagateEmpty) {
+            if (leftResult.value.length === 0 || rightResult.value.length === 0) {
+              return { value: [], context };
+            }
+          }
+          return await evaluator(input, context, leftResult.value, rightResult.value);
+        }
+
+        if (operator === 'or') {
+          // true or _ -> true (short-circuit)
+          if (kind === 'true') {
+            return { value: [this.boxBoolean(true)], context };
+          }
+          // false or y -> y; empty or true -> true handled by evaluator; need right
+          const rightResult = await this.evaluate(binary.right, input, context);
+          const operatorDef = this.registry.getOperatorDefinition(operator);
+          if (operatorDef && !operatorDef.doesNotPropagateEmpty) {
+            if (leftResult.value.length === 0 || rightResult.value.length === 0) {
+              return { value: [], context };
+            }
+          }
+          return await evaluator(input, context, leftResult.value, rightResult.value);
+        }
+
+        if (operator === 'implies') {
+          // false implies _ -> true (short-circuit)
+          if (kind === 'false') {
+            return { value: [this.boxBoolean(true)], context };
+          }
+          // true implies y -> y; empty implies y -> true if y true else empty; need right
+          const rightResult = await this.evaluate(binary.right, input, context);
+          const operatorDef = this.registry.getOperatorDefinition(operator);
+          if (operatorDef && !operatorDef.doesNotPropagateEmpty) {
+            if (leftResult.value.length === 0 || rightResult.value.length === 0) {
+              return { value: [], context };
+            }
+          }
+          return await evaluator(input, context, leftResult.value, rightResult.value);
+        }
+      }
+
+      // Default path: evaluate both operands in parallel
+      const [leftResult, rightResult] = await Promise.all([
+        this.evaluate(binary.left, input, context),
+        this.evaluate(binary.right, input, context)
+      ]);
+
+      // Handle empty propagation for operators
+      // Rely exclusively on registry metadata
+      const operatorDef = this.registry.getOperatorDefinition(operator);
+      if (operatorDef && !operatorDef.doesNotPropagateEmpty) {
+        // Check if either operand is empty
+        if (leftResult.value.length === 0 || rightResult.value.length === 0) {
+          return { value: [], context };
+        }
+      }
+
       return await evaluator(input, context, leftResult.value, rightResult.value);
     }
 
@@ -584,14 +669,83 @@ export class Interpreter {
     const func = node as FunctionNode;
     const funcName = (func.name as IdentifierNode).name;
 
+    // Get the function definition to check if it propagates empty
+    const functionDef = this.registry.getFunction(funcName);
+    
     // Check if function is registered with an evaluator
     const functionEvaluator = this.functionEvaluators.get(funcName);
-    if (functionEvaluator) {
-      return await functionEvaluator(input, context, func.arguments, this.evaluate.bind(this));
+    if (!functionEvaluator) {
+      // No function found in registry
+      throw Errors.unknownFunction(funcName);
     }
+    // Helper: pick a matching signature based on argument count
+    const pickSignature = () => {
+      if (!functionDef?.signatures || functionDef.signatures.length === 0) {
+        return undefined as import('./types').FunctionSignature | undefined;
+      }
+      const argsCount = func.arguments.length;
+      for (const sig of functionDef.signatures) {
+        const total = sig.parameters.length;
+        const required = sig.parameters.filter(p => !p.optional).length;
+        if (argsCount >= required && argsCount <= total) {
+          return sig;
+        }
+      }
+      // Fallback to first signature
+      return functionDef.signatures[0];
+    };
+
+    const signature = pickSignature();
+
+    // Memoized evaluator to avoid duplicate evaluation of arguments
+    // Only memoize when both input and context references are identical to this call's input/context.
+    const originalInputRef = input;
+    const originalContextRef = context;
+    const cache = new WeakMap<ASTNode, Promise<EvaluationResult>>();
+    const memoEval = async (n: ASTNode, inVals: any[], ctx: RuntimeContext) => {
+      if (inVals === originalInputRef && ctx === originalContextRef) {
+        const cached = cache.get(n);
+        if (cached) {
+          return cached;
+        }
+        const promise = this.evaluate(n, inVals, ctx);
+        cache.set(n, promise);
+        return promise;
+      }
+      // Different input or context – do not reuse cached result
+      return this.evaluate(n, inVals, ctx);
+    };
+
+    // Handle empty propagation centrally (default: propagate)
+    if (functionDef && !functionDef.doesNotPropagateEmpty) {
+      // If input is empty, propagate empty immediately
+      if (input.length === 0) {
+        return { value: [], context };
+      }
 
-    // No function found in registry
-    throw Errors.unknownFunction(funcName);
+      // Evaluate non-expression, non-typeReference arguments once for emptiness
+      for (let i = 0; i < func.arguments.length; i++) {
+        const arg = func.arguments[i];
+        const param = signature?.parameters[i];
+        if (!arg || !param) {
+          continue;
+        }
+        // Skip expression or typeReference params (not evaluated here)
+        if (param.expression || param.typeReference) {
+          continue;
+        }
+        // Evaluate with memoization
+        const argResult = await memoEval(arg, input, context);
+        // If argument is empty and it's a required parameter, propagate empty
+        const isRequired = !param.optional;
+        if (isRequired && argResult.value.length === 0) {
+          return { value: [], context };
+        }
+      }
+    }
+
+    // Call the function evaluator with memoized evaluator
+    return await functionEvaluator(input, context, func.arguments, memoEval);
   }
 
   // Index evaluator
@@ -621,76 +775,14 @@ export class Interpreter {
     const test = node as MembershipTestNode;
     const exprResult = await this.evaluate(test.expression, input, context);
     
-    // If expression evaluates to empty, return empty
-    if (exprResult.value.length === 0) {
-      return { value: [], context };
+    // Use the is-operator implementation for consistency
+    const isOperator = this.operationEvaluators.get('is');
+    if (isOperator) {
+      return isOperator(input, context, exprResult.value, [test.targetType]);
     }
     
-    // If we have type information from analyzer (with ModelProvider), use it
-    if (context.currentNode?.typeInfo?.modelContext) {
-      const modelContext = context.currentNode.typeInfo.modelContext as any;
-      
-      // For union types, check if the target type is valid
-      if (modelContext.isUnion && modelContext.choices) {
-        const hasValidChoice = modelContext.choices.some((c: any) => 
-          c.type === test.targetType || c.elementType === test.targetType
-        );
-        
-        if (!hasValidChoice) {
-          // Type system knows this will always be false
-          return { 
-            value: exprResult.value.map(() => box(false, { type: 'Boolean', singleton: true })), 
-            context 
-          };
-        }
-      }
-    }
-    
-    // Type checking with subtype support via ModelProvider
-    const results = await Promise.all(exprResult.value.map(async boxedItem => {
-      const item = unbox(boxedItem);
-      
-      // If we have a ModelProvider and typeInfo, use it for accurate subtype checking
-      if (context.modelProvider && boxedItem.typeInfo) {
-        const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, test.targetType as import('./types').TypeName);
-        return box(matchingType !== undefined, { type: 'Boolean', singleton: true });
-      }
-      
-      // For FHIR resources without typeInfo, try to get it from modelProvider
-      if (context.modelProvider && item && typeof item === 'object' && 'resourceType' in item && typeof item.resourceType === 'string') {
-        const typeInfo = await context.modelProvider.getType(item.resourceType);
-        if (typeInfo) {
-          const matchingType = context.modelProvider.ofType(typeInfo, test.targetType as import('./types').TypeName);
-          return box(matchingType !== undefined, { type: 'Boolean', singleton: true });
-        }
-        // Fall back to exact match
-        return box(item.resourceType === test.targetType, { type: 'Boolean', singleton: true });
-      }
-      
-      // Check for FHIR resource types (no ModelProvider available)
-      if (item && typeof item === 'object' && 'resourceType' in item) {
-        return box(item.resourceType === test.targetType, { type: 'Boolean', singleton: true });
-      }
-      
-      // Check primitive types
-      const isMatch = (() => {
-        switch (test.targetType) {
-          case 'String': return typeof item === 'string';
-          case 'Boolean': return typeof item === 'boolean';
-          case 'Integer': return Number.isInteger(item);
-          case 'Decimal': return typeof item === 'number';
-          case 'Date':
-          case 'DateTime':
-          case 'Time':
-            // Simple check for date-like strings
-            return typeof item === 'string' && !isNaN(Date.parse(item));
-          default: return false;
-        }
-      })();
-      return box(isMatch, { type: 'Boolean', singleton: true });
-    }));
-
-    return { value: results, context };
+    // Fallback - shouldn't reach here normally
+    return { value: [], context };
   }
 
   // Type cast (as operator)
@@ -698,76 +790,22 @@ export class Interpreter {
     const cast = node as TypeCastNode;
     const exprResult = await this.evaluate(cast.expression, input, context);
     
-    // If we have type information from analyzer (with ModelProvider), use it
-    if (context.currentNode?.typeInfo?.modelContext) {
-      const modelContext = context.currentNode.typeInfo.modelContext as any;
-      
-      // For union types, check if the cast is valid
-      if (modelContext.isUnion && modelContext.choices) {
-        const validChoice = modelContext.choices.find((c: any) => 
-          c.type === cast.targetType || c.elementType === cast.targetType
-        );
-        
-        if (!validChoice) {
-          // Invalid cast - return empty
-          return { value: [], context };
-        }
-      }
+    // Use the as-operator implementation for consistency
+    const asOperator = this.operationEvaluators.get('as');
+    if (asOperator) {
+      return asOperator(input, context, exprResult.value, [cast.targetType]);
     }
     
-    // Filter values that match the target type with subtype support
-    const filtered = await Promise.all(exprResult.value.map(async boxedItem => {
-      const item = unbox(boxedItem);
-      
-      // If we have a ModelProvider and typeInfo, use it for accurate subtype checking
-      if (context.modelProvider && boxedItem.typeInfo) {
-        const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, cast.targetType as import('./types').TypeName);
-        return matchingType !== undefined;
-      }
-      
-      // For FHIR resources without typeInfo, try to get it from modelProvider
-      if (context.modelProvider && item && typeof item === 'object' && 'resourceType' in item && typeof item.resourceType === 'string') {
-        const typeInfo = await context.modelProvider.getType(item.resourceType);
-        if (typeInfo) {
-          const matchingType = context.modelProvider.ofType(typeInfo, cast.targetType as import('./types').TypeName);
-          return matchingType !== undefined;
-        }
-        // Fall back to exact match
-        return item.resourceType === cast.targetType;
-      }
-      
-      // Check for FHIR resource types (no ModelProvider available)
-      if (item && typeof item === 'object' && 'resourceType' in item) {
-        return item.resourceType === cast.targetType;
-      }
-      
-      // Check primitive types
-      switch (cast.targetType) {
-        case 'String': return typeof item === 'string';
-        case 'Boolean': return typeof item === 'boolean';
-        case 'Integer': return Number.isInteger(item);
-        case 'Decimal': return typeof item === 'number';
-        case 'Date':
-        case 'DateTime':
-        case 'Time':
-          // Simple check for date-like strings
-          return typeof item === 'string' && !isNaN(Date.parse(item));
-        default: return false;
-      }
-    }));
-    
-    // Filter out the false results (filter returns boolean for each item)
-    const actualFiltered = exprResult.value.filter((_, index) => filtered[index]);
-    
-    return { value: actualFiltered, context };
+    // Fallback implementation (shouldn't normally reach here)
+    return { value: [], context };
   }
   
   private async evaluateQuantity(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const quantity = node as QuantityNode;
-    const quantityValue = createQuantity(quantity.value, quantity.unit, quantity.isCalendarUnit);
+    const quantityValue = createQuantity(quantity.value, quantity.unit);
     return {
       value: [box(quantityValue, { type: 'Quantity', singleton: true })],
       context
     };
   }
-}
+}