@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/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 { collectionsEquivalent } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  // Empty collections are equivalent
-  if (left.length === 0 && right.length === 0) {
-    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // Different sizes are not equivalent
-  if (left.length !== right.length) {
-    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // For single items, check type-specific 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 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 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 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 equality for now
-    // TODO: Implement full equivalence logic for Date/DateTime/Time and complex types
-    return { value: [box(l === r, { type: 'Boolean', singleton: true })], context };
-  }
+  // Use the new collectionsEquivalent function from comparison.ts
+  const result = collectionsEquivalent(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(false, { type: 'Boolean', singleton: true })], context };
-    }
+  // null result means incomparable - return empty collection
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  // Return boolean result
+  return {
+    value: [box(result, { type: 'Boolean', singleton: true })],
+    context
+  };
 };
 
 export const equivalentOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -67,6 +26,7 @@ export const equivalentOperator: OperatorDefinition & { evaluate: OperationEvalu
   category: ['equality'],
   precedence: PRECEDENCE.EQUALITY,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Empty collections are valid operands for equivalence
   description: 'Returns true if the collections are the same. For single items: strings are compared case-insensitive with normalized whitespace, decimals are rounded to least precision, dates with different precision return false. For collections: order-independent comparison. Empty ~ empty returns true (unlike =)',
   examples: [
     "'abc' ~ 'ABC'",

package/src/operations/exclude-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length !== 1) {
@@ -44,6 +44,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const excludeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'exclude',
+  doesNotPropagateEmpty: true,  // exclude with empty argument returns the original collection
   category: ['collection'],
   description: 'Returns the set of elements that are not in the other collection. Duplicate items will not be eliminated by this function, and order will be preserved.',
   examples: [

package/src/operations/exists-function.ts

@@ -1,8 +1,8 @@
 import type { FunctionDefinition } from '../types';
 import { Errors } from '../errors';
-import { RuntimeContextManager } from '../interpreter';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
 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) => {
   // No arguments - just check if input is not empty
@@ -42,6 +42,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const existsFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'exists',
+  doesNotPropagateEmpty: true,
   category: ['collection', 'logical'],
   description: 'Returns true if the collection has any items, or if any item satisfies the condition',
   examples: ['Patient.name.exists()', 'Patient.name.exists(use = "official")'],
@@ -55,4 +56,4 @@ export const existsFunction: FunctionDefinition & { evaluate: FunctionEvaluator
     result: { type: 'Boolean', singleton: true },
   }],
   evaluate
-};
+};

package/src/operations/first-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) => {
   if (input.length > 0) {

package/src/operations/floor-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // floor() takes no arguments

package/src/operations/greater-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { compareQuantities } 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) {
@@ -24,6 +24,23 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: result !== null ? [box(result > 0, { type: 'Boolean', singleton: true })] : [], context };
   }
   
+  // Check if both are temporal values (Date, DateTime, Time)
+  if (l && typeof l === 'object' && 'kind' in l &&
+      r && typeof r === 'object' && 'kind' in r) {
+    const temporalL = l as any;
+    const temporalR = r as any;
+    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
+    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
+      const { compare } = await import('../complex-types/temporal');
+      const result = compare(temporalL, temporalR);
+      // null means incomparable (different precisions), returns empty
+      if (result === null) {
+        return { value: [], context };
+      }
+      return { value: [box(result > 0, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
   return { value: [box((l as any) > (r as any), { type: 'Boolean', singleton: true })], context };
 };
 

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

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { compareQuantities } 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) {
@@ -24,6 +24,23 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: result !== null ? [box(result >= 0, { type: 'Boolean', singleton: true })] : [], context };
   }
   
+  // Check if both are temporal values (Date, DateTime, Time)
+  if (l && typeof l === 'object' && 'kind' in l &&
+      r && typeof r === 'object' && 'kind' in r) {
+    const temporalL = l as any;
+    const temporalR = r as any;
+    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
+    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
+      const { compare } = await import('../complex-types/temporal');
+      const result = compare(temporalL, temporalR);
+      // null means incomparable (different precisions), returns empty
+      if (result === null) {
+        return { value: [], context };
+      }
+      return { value: [box(result >= 0, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
   return { value: [box((l as any) >= (r as any), { type: 'Boolean', singleton: true })], context };
 };
 

package/src/operations/highBoundary-function.ts

@@ -0,0 +1,120 @@
+// highBoundary() function - Returns the greatest possible value to the specified precision
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { 
+  isFHIRDate, isFHIRDateTime, isFHIRTime,
+  getDateHighBoundary, getDateTimeHighBoundary, getTimeHighBoundary 
+} from '../complex-types/temporal';
+import { getDecimalHighBoundary } from './decimal-boundaries';
+import { Errors } from '../errors';
+
+export const highBoundaryEvaluator: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // highBoundary() takes optional precision parameter
+  if (args.length > 1) {
+    throw Errors.wrongArgumentCountRange('highBoundary', 0, 1, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('highBoundary', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Get precision if provided
+  let precision: number | undefined;
+  if (args.length === 1) {
+    const precisionResult = await evaluator(args[0]!, input, context);
+    const precisionArg = precisionResult.value;
+    if (precisionArg.length === 0) {
+      return { value: [], context };
+    }
+    if (precisionArg.length > 1) {
+      throw Errors.singletonRequired('highBoundary precision', precisionArg.length);
+    }
+    const precisionValue = unbox(precisionArg[0]!);
+    if (typeof precisionValue !== 'number' || !Number.isInteger(precisionValue)) {
+      throw Errors.invalidOperandType('highBoundary precision', typeof precisionValue);
+    }
+    precision = precisionValue;
+  }
+  
+  // Handle Date
+  if (isFHIRDate(value)) {
+    const result = getDateHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'Date', singleton: true })], context };
+  }
+  
+  // Handle DateTime
+  if (isFHIRDateTime(value)) {
+    const result = getDateTimeHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+  }
+  
+  // Handle Time
+  if (isFHIRTime(value)) {
+    const result = getTimeHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'Time', singleton: true })], context };
+  }
+  
+  // For Decimal/Integer types
+  if (typeof value === 'number') {
+    const result = getDecimalHighBoundary(value, precision);
+    if (result === null) {
+      return { value: [], context };
+    }
+    // Determine the result type based on whether it's an integer or decimal
+    const isInteger = Number.isInteger(result);
+    return { 
+      value: [box(result, { type: isInteger ? 'Integer' : 'Decimal', singleton: true })], 
+      context 
+    };
+  }
+  
+  // Invalid type returns empty
+  return { value: [], context };
+};
+
+export const highBoundaryFunction: FunctionDefinition & { evaluate: typeof highBoundaryEvaluator } = {
+  name: 'highBoundary',
+  category: ['utility'],
+  description: 'Returns the greatest possible value of the input to the specified precision',
+  examples: [
+    '@2014.highBoundary(6)',
+    '@2014-01-01T08.highBoundary(17)',
+    '@T10:30.highBoundary(9)',
+    '1.587.highBoundary()',
+    '1.587.highBoundary(2)',
+    '1.highBoundary(0)'
+  ],
+  signatures: [
+    {
+      name: 'highBoundary',
+      input: { type: 'Any' as const, singleton: true },
+      parameters: [
+        { name: 'precision', type: { type: 'Integer' as const, singleton: true }, optional: true }
+      ],
+      result: { type: 'Any' as const, singleton: true }
+    }
+  ],
+  evaluate: highBoundaryEvaluator
+};

package/src/operations/hourOf-function.ts

@@ -0,0 +1,66 @@
+// hourOf() function - Extracts hour 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 hourOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // hourOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('hourOf', 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('hourOf', 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 hour component is present
+    if (value.hour === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the hour as an Integer (0-23)
+    return {
+      value: [box(value.hour, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const hourOfFunction: FunctionDefinition & { evaluate: typeof hourOfEvaluator } = {
+  name: 'hourOf',
+  category: ['temporal'],
+  description: 'Returns the hour component of a Time or DateTime value (0-23)',
+  examples: [
+    '@T10:30:00.hourOf()',
+    '@2014-01-05T10:30:00.hourOf()',
+    'Patient.birthDate.hourOf()'
+  ],
+  signatures: [
+    {
+      name: 'hourOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: hourOfEvaluator
+};

package/src/operations/iif-function.ts

@@ -1,8 +1,10 @@
-import type { FunctionDefinition } from '../types';
-import { Errors } from '../errors';
+import type { FunctionDefinition, AnalysisContext, InternalAnalysisResult } from '../types';
+import { Errors, ErrorCodes } from '../errors';
 import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
-import { RuntimeContextManager } from '../interpreter';
+import { box, unbox } from '../interpreter/boxing';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
+import { NodeType } from '../parser';
+import { DiagnosticSeverity } from '../types';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length < 2) {
@@ -15,7 +17,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
   // Check for multiple items in input collection
   if (input.length > 1) {
-    throw Errors.invalidOperation('iif can only be used on single item or empty collections');
+    throw Errors.emptyNotAllowed('iif');
   }
 
   // Always evaluate condition
@@ -72,6 +74,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const iifFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'iif',
+  doesNotPropagateEmpty: true,  // iif evaluates even with empty input
   category: ['control'],
   description: 'If-then-else expression (immediate if)',
   examples: ['iif(gender = "male", "Mr.", "Ms.")'],
@@ -86,5 +89,181 @@ export const iifFunction: FunctionDefinition & { evaluate: FunctionEvaluator } =
     ],
     result: { type: 'Any', singleton: false },
   }],
-  evaluate
-};
+  evaluate,
+  
+  /**
+   * Analysis-time behavior for iif with lazy evaluation.
+   * Only analyzes reachable branches when condition is a literal.
+   */
+  async analyze(context: AnalysisContext, args): Promise<InternalAnalysisResult> {
+    const diagnostics: any[] = [];
+    
+    // Validate argument count
+    if (args.length < 2) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif requires at least 2 arguments',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    if (args.length > 3) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif takes at most 3 arguments',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    // Analyze condition
+    const conditionArg = args[0];
+    if (!conditionArg) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif requires a condition argument',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    const condResult = await context.analyzeNode(conditionArg);
+    diagnostics.push(...condResult.diagnostics);
+    
+    // Check if condition is a literal boolean
+    let isLiteralTrue = false;
+    let isLiteralFalse = false;
+    
+    if (conditionArg.type === NodeType.Literal) {
+      const literalValue = (conditionArg as any).value;
+      if (literalValue === true) {
+        isLiteralTrue = true;
+      } else if (literalValue === false) {
+        isLiteralFalse = true;
+      }
+    }
+    
+    let trueBranchType = { type: 'Any', singleton: false } as any;
+    let falseBranchType = { type: 'Any', singleton: false } as any;
+    
+    // Lazy evaluation: only analyze reachable branches
+    if (isLiteralTrue) {
+      // Only true branch is reachable
+      const trueBranch = args[1];
+      if (!trueBranch) {
+        return {
+          type: { type: 'Any', singleton: false },
+          diagnostics
+        };
+      }
+      const trueBranchResult = await context.analyzeNode(trueBranch);
+      diagnostics.push(...trueBranchResult.diagnostics);
+      trueBranchType = trueBranchResult.type;
+      
+      // Warn about unreachable false branch
+      if (args.length === 3 && args[2]) {
+        diagnostics.push({
+          message: 'Unreachable code: false branch will never execute',
+          severity: DiagnosticSeverity.Warning,
+          code: ErrorCodes.UNREACHABLE_CODE,
+          source: 'fhirpath',
+          range: args[2].range || { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        });
+      }
+      
+      return { type: trueBranchType, diagnostics };
+    } else if (isLiteralFalse) {
+      // Only false branch is reachable (if it exists)
+      // Warn about unreachable true branch
+      const trueBranch = args[1];
+      if (trueBranch) {
+        diagnostics.push({
+          message: 'Unreachable code: true branch will never execute',
+          severity: DiagnosticSeverity.Warning,
+          code: ErrorCodes.UNREACHABLE_CODE,
+          source: 'fhirpath',
+          range: trueBranch.range || { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        });
+      }
+      
+      if (args.length === 3 && args[2]) {
+        const falseBranchResult = await context.analyzeNode(args[2]);
+        diagnostics.push(...falseBranchResult.diagnostics);
+        falseBranchType = falseBranchResult.type;
+        return { type: falseBranchType, diagnostics };
+      } else {
+        // No else branch, return empty
+        return { type: { type: 'Any', singleton: false }, diagnostics };
+      }
+    } else {
+      // Dynamic condition: analyze both branches
+      const trueBranch = args[1];
+      if (trueBranch) {
+        const trueBranchResult = await context.analyzeNode(trueBranch);
+        diagnostics.push(...trueBranchResult.diagnostics);
+        trueBranchType = trueBranchResult.type;
+      }
+      
+      if (args.length === 3 && args[2]) {
+        const falseBranchResult = await context.analyzeNode(args[2]);
+        diagnostics.push(...falseBranchResult.diagnostics);
+        falseBranchType = falseBranchResult.type;
+        
+        // Result type is the union of both branches
+        // For now, if they differ, return Any
+        if (trueBranchType.type === falseBranchType.type && 
+            trueBranchType.singleton === falseBranchType.singleton) {
+          return { type: trueBranchType, diagnostics };
+        } else if (trueBranchType.type === falseBranchType.type) {
+          // Same type but different singleton - result is collection
+          return { type: { type: trueBranchType.type, singleton: false }, diagnostics };
+        }
+      }
+      
+      return { type: { type: 'Any', singleton: false }, diagnostics };
+    }
+  },
+  
+  async inferResultType(analyzer, node, inputType) {
+    // iif returns the common type of the true and false branches
+    if (node.arguments.length >= 2) {
+      const trueBranchType = await (analyzer as any).inferType(node.arguments[1]!, inputType);
+      if (node.arguments.length >= 3) {
+        const falseBranchType = await (analyzer as any).inferType(node.arguments[2]!, inputType);
+        // If both branches have the same type, use that
+        if (trueBranchType.type === falseBranchType.type && 
+            trueBranchType.singleton === falseBranchType.singleton) {
+          return trueBranchType;
+        }
+        // If types are the same but singleton differs, return as collection
+        if (trueBranchType.type === falseBranchType.type) {
+          // One is singleton, one is collection - result must be collection
+          return { type: trueBranchType.type, singleton: false };
+        }
+        // Otherwise, check if one is a subtype of the other
+        if ((analyzer as any).isTypeCompatible(trueBranchType, falseBranchType)) {
+          return falseBranchType;
+        }
+        if ((analyzer as any).isTypeCompatible(falseBranchType, trueBranchType)) {
+          return trueBranchType;
+        }
+      } else {
+        // Only true branch, result can be that type or empty
+        return { ...trueBranchType, singleton: false };
+      }
+    }
+    return { type: 'Any', singleton: false };
+  }
+};

package/src/operations/implies-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) => {
   // Three-valued logic for implies per spec truth table

package/src/operations/in-operator.ts

@@ -2,7 +2,7 @@ import type { OperatorDefinition } from '../types';
 import { Errors } from '../errors';
 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 is empty, result is empty
@@ -45,6 +45,7 @@ export const inOperator: OperatorDefinition & { evaluate: OperationEvaluator } =
   category: ['membership'],
   precedence: PRECEDENCE.IN_CONTAINS,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Has custom empty handling per spec
   description: 'If the left operand is a collection with a single item, returns true if the item is in the right operand using equality semantics. If the left is empty, the result is empty. If the right is empty, the result is false.',
   examples: ['\'Joe\' in Patient.name.given', '5 in (1 | 2 | 3 | 4 | 5)', 'code in terminologyServer.valueset(\'my-valueset\').code'],
   signatures: [