@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/model-provider.ts

@@ -172,7 +172,8 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
       
       return schema;
     } catch (error) {
-      console.warn(`Failed to load schema for ${typeName}:`, error);
+      // Silently fail for unknown types - this is expected for non-FHIR types
+      // like function names or property names that get speculatively checked
       return undefined;
     }
   }
@@ -189,7 +190,8 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
     let current = schema;
     
     // Walk up the inheritance chain
-    while (current.base && current.base !== 'Resource' && current.base !== 'Element') {
+    // Include all base types including DomainResource, Resource, and Element
+    while (current.base) {
       // Extract just the type name from the base URL if it's a full URL
       let baseTypeName = current.base;
       if (baseTypeName && baseTypeName.startsWith('http://')) {
@@ -277,10 +279,54 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
   
   // Async implementation with lazy loading
   async getType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined> {
-    // Check if it's a primitive type - these don't require initialization
-    if (this.typeMapping[typeName]) {
+    // First check if this is a FHIRPath primitive type name
+    const fhirpathPrimitives = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Any'];
+    if (fhirpathPrimitives.includes(typeName)) {
+      // Return the FHIRPath primitive type directly without trying to load a schema
       return {
-        type: this.typeMapping[typeName],
+        type: typeName as TypeName,
+        namespace: 'FHIR',
+        name: typeName,
+        singleton: true,
+        modelContext: {
+          path: typeName,
+          schemaHierarchy: []
+        }
+      };
+    }
+    
+    // Check if it's a FHIR primitive type that maps to a FHIRPath type
+    const mappedType = this.typeMapping[typeName];
+    if (mappedType) {
+      // For types that are both FHIRPath types and complex FHIR types (like Quantity),
+      // we need to check if they have a schema
+      // But skip primitive FHIRPath types that definitely don't have schemas
+      const primitiveTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time'];
+      const isPrimitive = primitiveTypes.includes(mappedType);
+      
+      if (this.initialized && !isPrimitive) {
+        const schema = await this.getSchema(typeName);
+        if (schema) {
+          // It's a complex type with properties
+          const schemaHierarchy = await this.getSchemaHierarchyAsync(schema);
+          return {
+            type: mappedType,
+            namespace: 'FHIR',
+            name: typeName,
+            singleton: true,
+            modelContext: {
+              path: typeName,
+              schemaHierarchy,
+              canonicalUrl: schema.url,
+              version: schema.version
+            }
+          };
+        }
+      }
+      
+      // It's a pure primitive type without properties
+      return {
+        type: mappedType,
         namespace: 'FHIR',
         name: typeName,
         singleton: true,
@@ -324,6 +370,26 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
     const context = parentType.modelContext;
     if (!context) return undefined;
     
+    // Handle union types (polymorphic fields like value[x])
+    if (context.isUnion && context.choices) {
+      // For union types, check if the property exists on any of the choice types
+      for (const choice of context.choices) {
+        // Get the type for this choice - use type field which has the proper case
+        const choiceTypeName = choice.type;
+        const choiceType = await this.getType(choiceTypeName);
+        if (choiceType) {
+          // Try to get the property from this choice type
+          const elementType = await this.getElementType(choiceType, propertyName);
+          if (elementType) {
+            // Found the property on this choice type
+            return elementType;
+          }
+        }
+      }
+      // Property not found on any choice type
+      return undefined;
+    }
+    
     // Search through schema hierarchy for the property
     for (const schema of context.schemaHierarchy) {
       const element = schema.elements?.[propertyName];
@@ -609,42 +675,4 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
     return this.primitiveTypesCache || [];
   }
 
-  // Synchronous method to get type from cache (for analyzer)
-  getTypeFromCache(typeName: string): TypeInfo<FHIRModelContext> | undefined {
-    // Check if it's a primitive type - these don't require initialization
-    if (this.typeMapping[typeName]) {
-      return {
-        type: this.typeMapping[typeName],
-        namespace: 'FHIR',
-        name: typeName,
-        singleton: true,
-        modelContext: {
-          path: typeName,
-          schemaHierarchy: []
-        }
-      };
-    }
-    
-    // For complex types, check if schema is in cache
-    const schema = this.schemaCache.get(typeName);
-    if (!schema) {
-      return undefined;
-    }
-    
-    // Get cached hierarchy or at least the current schema
-    const schemaHierarchy = this.hierarchyCache.get(schema.name || schema.url) || [schema];
-    
-    return {
-      type: 'Any',  // Complex types are 'Any' in FHIRPath
-      namespace: 'FHIR',
-      name: typeName,
-      singleton: true,
-      modelContext: {
-        path: typeName,
-        schemaHierarchy,
-        canonicalUrl: schema.url,
-        version: schema.version
-      }
-    };
-  }
 }

package/src/operations/abs-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) => {
   // abs() takes no arguments

package/src/operations/aggregate-function.ts

@@ -1,7 +1,7 @@
-import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import type { FunctionDefinition, FunctionEvaluator, TypeInfo } from '../types';
 import { Errors } from '../errors';
-import { RuntimeContextManager } from '../interpreter';
-import { box, unbox } from '../boxing';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // aggregator expression is required
@@ -21,6 +21,11 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     total = [];
   }
 
+  // If input is empty and init is provided, return the init value
+  if (input.length === 0 && initExpr) {
+    return { value: total, context };
+  }
+
   // For each item in the input collection, evaluate the aggregator expression
   for (let index = 0; index < input.length; index++) {
     const item = input[index]!;
@@ -46,6 +51,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const aggregateFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'aggregate',
+  doesNotPropagateEmpty: true,  // aggregate with init should return init value for empty input
   category: ['aggregates'],
   description: 'Performs general-purpose aggregation by evaluating the aggregator expression for each element of the input collection',
   examples: [
@@ -63,5 +69,78 @@ export const aggregateFunction: FunctionDefinition & { evaluate: FunctionEvaluat
     ],
     result: { type: 'Any', singleton: false }
   }],
-  evaluate
-};
+  evaluate,
+  async inferResultType(analyzer, node, inputType) {
+    // If init parameter is provided, use its type to infer result type
+    if (node.arguments.length >= 2) {
+      const initType = await (analyzer as any).inferType(node.arguments[1]!, inputType);
+      // The result type is the same as init type
+      return initType;
+    }
+    // Without init, we can't fully infer the type without running annotation
+    // This is a limitation - the actual type will be set during annotateAST
+    if (node.arguments.length >= 1) {
+      // We could try to infer, but it would require setting up system variables
+      // For now, return Any and let annotateAST handle proper typing
+      return { type: 'Any', singleton: false };
+    }
+    // No arguments at all
+    return { type: 'Any', singleton: false };
+  },
+  async analyze(context, args) {
+    const diagnostics: any[] = [];
+    const itemType = { ...context.inputType, singleton: true };
+
+    // Determine $total type: from init (arg[1]) if provided; otherwise from aggregator result after first iteration (approximate with Any)
+    let totalType = { type: 'Any', singleton: false } as TypeInfo;
+
+    if (args.length >= 2 && args[1]) {
+      const initResult = await context
+        .withSystemVariable('$this', itemType)
+        .withSystemVariable('$index', { type: 'Integer', singleton: true })
+        .analyzeNode(args[1]!);
+      diagnostics.push(...initResult.diagnostics);
+      totalType = initResult.type;
+    }
+
+    // Analyze aggregator with $this (item) and $total (init or inferred seed)
+    if (args.length >= 1 && args[0]) {
+      // If we don't have init, seed $total with a heuristic:
+      // - If aggregator contains string operations, seed as String
+      // - Else seed as item type
+      const containsStringHints = (function hasStringHints(node: any): boolean {
+        if (!node) return false;
+        if (node.type === 'Literal' && typeof node.value === 'string') return true;
+        if (node.type === 'Function' && node.name?.type === 'Identifier' && node.name.name === 'toString') return true;
+        if (node.children) return node.children.some((c: any) => hasStringHints(c));
+        if (node.arguments) return (node.arguments as any[]).some(a => hasStringHints(a));
+        if (node.left && node.right) return hasStringHints(node.left) || hasStringHints(node.right);
+        if (node.expression) return hasStringHints(node.expression);
+        return false;
+      })(args[0]);
+
+      const seededTotal = (args.length < 2)
+        ? (containsStringHints ? { type: 'String', singleton: true } as TypeInfo : itemType)
+        : totalType;
+      let aggregatorCtx = context
+        .withSystemVariable('$this', itemType)
+        .withSystemVariable('$index', { type: 'Integer', singleton: true })
+        .withSystemVariable('$total', seededTotal);
+
+      const firstPass = await aggregatorCtx.analyzeNode(args[0]!);
+      diagnostics.push(...firstPass.diagnostics);
+
+      // If no init provided, refine $total type to aggregator result and re-analyze aggregator
+      if (args.length < 2) {
+        aggregatorCtx = aggregatorCtx.withSystemVariable('$total', firstPass.type);
+        const secondPass = await aggregatorCtx.analyzeNode(args[0]!);
+        diagnostics.push(...secondPass.diagnostics);
+        return { type: secondPass.type, diagnostics, context };
+      }
+
+      return { type: firstPass.type, diagnostics, context };
+    }
+
+    return { type: context.inputType, diagnostics, context };
+  }
+};

package/src/operations/all-function.ts

@@ -1,7 +1,7 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { RuntimeContextManager } from '../interpreter';
-import { box, unbox } from '../boxing';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // all() requires exactly one argument (the criteria expression)
@@ -51,6 +51,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const allFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'all',
+  doesNotPropagateEmpty: true,  // Returns true for empty collections
   category: ['existence'],
   description: 'Returns true if for every element in the input collection, criteria evaluates to true. Otherwise, the result is false. If the input collection is empty, the result is true.',
   examples: [
@@ -66,4 +67,4 @@ export const allFunction: FunctionDefinition & { evaluate: FunctionEvaluator } =
     result: { type: 'Boolean', singleton: true }
   }],
   evaluate
-};
+};

package/src/operations/allFalse-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 the input is empty, the result is true
@@ -24,6 +24,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const allFalseFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'allFalse',
+  doesNotPropagateEmpty: true,
   category: ['existence'],
   description: 'Takes a collection of Boolean values and returns true if all the items are false. If any items are true, the result is false. If the input is empty, the result is true.',
   examples: [

package/src/operations/allTrue-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 the input is empty, the result is true
@@ -24,6 +24,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const allTrueFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'allTrue',
+  doesNotPropagateEmpty: true,
   category: ['existence'],
   description: 'Takes a collection of Boolean values and returns true if all the items are true. If any items are false, the result is false. If the input is empty, the result is true.',
   examples: [

package/src/operations/and-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 implementation
@@ -30,6 +30,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
 export const andOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
   symbol: 'and',
   name: 'and',
+  doesNotPropagateEmpty: true,  // Three-valued logic: false and empty = false
   category: ['logical'],
   precedence: PRECEDENCE.AND,
   associativity: 'left',

package/src/operations/anyFalse-function.ts

@@ -1,5 +1,5 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Empty input returns false per spec
@@ -24,6 +24,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const anyFalseFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'anyFalse',
+  doesNotPropagateEmpty: true,
   category: ['existence'],
   description: 'Takes a collection of Boolean values and returns true if any of the items are false. If all the items are true, or if the input is empty, the result is false.',
   examples: [

package/src/operations/anyTrue-function.ts

@@ -1,5 +1,5 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Empty input returns false per spec
@@ -24,6 +24,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const anyTrueFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'anyTrue',
+  doesNotPropagateEmpty: true,
   category: ['existence'],
   description: 'Takes a collection of Boolean values and returns true if any of the items are true. If all the items are false, or if the input is empty, the result is false.',
   examples: [

package/src/operations/as-function.ts

@@ -0,0 +1,58 @@
+import type { FunctionDefinition, FunctionEvaluator, ASTNode, RuntimeContext, NodeEvaluator } from '../types';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { NodeType, isIdentifierNode } from '../types';
+import { evaluate as asOperatorEvaluate } from './as-operator';
+
+const asEvaluator: FunctionEvaluator = async (
+  input: FHIRPathValue[], 
+  context: RuntimeContext, 
+  args: ASTNode[],
+  evaluator: NodeEvaluator
+) => {
+  // as() function takes one argument - the type name
+  if (args.length !== 1) {
+    return { value: [], context };
+  }
+  
+  const typeArg = args[0];
+  if (!typeArg) {
+    return { value: [], context };
+  }
+  
+  // Extract type name from the argument AST node
+  let typeName: string;
+  
+  if (isIdentifierNode(typeArg)) {
+    typeName = typeArg.name;
+  } else {
+    // For other node types, try to get the name
+    throw new Error(`as() requires a type name as argument, got ${typeArg.type}`);
+  }
+  
+  // Use the as operator implementation with the type name
+  return asOperatorEvaluate(input, context, input, [typeName]);
+};
+
+export { asEvaluator };
+
+export const asFunction: FunctionDefinition & { evaluate: typeof asEvaluator } = {
+  name: 'as',
+  category: ['type'],
+  description: 'Casts the input to the specified type, returning empty if the cast fails',
+  examples: ['Patient.name.as(HumanName)', '"hello".as(String)', '5.as(Integer)'],
+  signatures: [
+    {
+      name: 'as-type-cast',
+      parameters: [{ 
+        name: 'type', 
+        type: { type: 'Any', singleton: true },
+        expression: true,
+        typeReference: true
+      }],
+      input: { type: 'Any', singleton: false },
+      result: { type: 'Any', singleton: false }
+    }
+  ],
+  doesNotPropagateEmpty: false,
+  evaluate: asEvaluator
+};

package/src/operations/as-operator.ts

@@ -1,7 +1,8 @@
 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';
+import { isFHIRDate, isFHIRDateTime, isFHIRTime } from '../complex-types/temporal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // 'as' operator performs type casting/filtering
@@ -10,29 +11,66 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: [], context };
   }
   
-  // TODO: Implement proper FHIRPath type casting
-  // For now, just return the value as-is if it matches the type
   const results: any[] = [];
-  const typeName = right[0]; // Should be a type name
+  const typeName = right[0] as string; // Should be a type name
   
-  for (const item of left) {
+  for (const boxedItem of left) {
+    const item = unbox(boxedItem);
     let matches = false;
-    switch (typeName) {
-      case 'String':
-        matches = typeof item === 'string';
-        break;
-      case 'Boolean':
-        matches = typeof item === 'boolean';
-        break;
-      case 'Integer':
-        matches = Number.isInteger(item);
-        break;
-      case 'Decimal':
-        matches = typeof item === 'number';
-        break;
+    
+    // Check typeInfo first if available
+    if (boxedItem?.typeInfo) {
+      // If we have a ModelProvider, use it for accurate type checking (handles subtypes)
+      if (context.modelProvider) {
+        const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, typeName as any);
+        matches = matchingType !== undefined;
+      } else {
+        // Without ModelProvider, just check exact match
+        matches = boxedItem.typeInfo.type === typeName;
+      }
+    } else {
+      // Fallback to primitive type checking
+      switch (typeName) {
+        case 'String':
+          matches = typeof item === 'string';
+          break;
+        case 'Boolean':
+          matches = typeof item === 'boolean';
+          break;
+        case 'Integer':
+          matches = typeof item === 'number' && Number.isInteger(item);
+          break;
+        case 'Decimal':
+          matches = typeof item === 'number';
+          break;
+        case 'Date':
+          // Check if it's a FHIRDate instance or has Date typeInfo
+          if (item && typeof item === 'object') {
+            matches = isFHIRDate(item) || (item as any).kind === 'FHIRDate';
+          }
+          break;
+        case 'DateTime':
+          // Check if it's a FHIRDateTime instance or has DateTime typeInfo
+          if (item && typeof item === 'object') {
+            matches = isFHIRDateTime(item) || (item as any).kind === 'FHIRDateTime';
+          }
+          break;
+        case 'Time':
+          // Check if it's a FHIRTime instance or has Time typeInfo
+          if (item && typeof item === 'object') {
+            matches = isFHIRTime(item) || (item as any).kind === 'FHIRTime';
+          }
+          break;
+        default:
+          // For complex types, check resourceType
+          if (item && typeof item === 'object' && 'resourceType' in item) {
+            matches = item.resourceType === typeName;
+          }
+      }
     }
+    
     if (matches) {
-      results.push(item);
+      results.push(boxedItem);
     }
   }
   

package/src/operations/ceiling-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) => {
   // ceiling() takes no arguments

package/src/operations/children-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator, TypeInfo } 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 !== 0) {
@@ -22,9 +22,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
         parentTypeInfo = boxedItem.typeInfo;
       } else if (modelProvider && 'resourceType' in item && typeof item.resourceType === 'string') {
         // Try to get type info from resourceType (use cached version)
-        parentTypeInfo = 'getTypeFromCache' in modelProvider 
-          ? (modelProvider as any).getTypeFromCache(item.resourceType)
-          : undefined;
+        parentTypeInfo = await modelProvider.getType(item.resourceType);
       }
       
       // Collect all child properties
@@ -94,5 +92,16 @@ export const childrenFunction: FunctionDefinition & { evaluate: FunctionEvaluato
     parameters: [],
     result: { type: 'Any', singleton: false }
   }],
-  evaluate
+  evaluate,
+  async inferResultType(analyzer, node, inputType) {
+    const modelProvider = (analyzer as any).modelProvider;
+    if (inputType && modelProvider && 'getChildrenType' in modelProvider) {
+      const childrenType = await modelProvider.getChildrenType(inputType);
+      if (childrenType) {
+        return childrenType;
+      }
+    }
+    // Fallback to Any collection
+    return { type: 'Any', singleton: false };
+  }
 };

package/src/operations/combine-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) => {
   // combine() requires exactly one argument (the other collection)
@@ -16,8 +16,10 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   
   // Evaluate the argument expression
   // The argument should be evaluated in the root context, not the current input
-  // Use context.input which contains the root data
-  const otherResult = await evaluator(otherArg, context.input || [], context);
+  // Use the original context data
+  const rootInput = context.variables?.['%context'] || context.input || [];
+  const rootInputArray = Array.isArray(rootInput) ? rootInput : [rootInput];
+  const otherResult = await evaluator(otherArg, rootInputArray, context);
   const otherCollection = otherResult.value;
 
   // Merge the input and other collections into a single collection
@@ -29,6 +31,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const combineFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'combine',
+  doesNotPropagateEmpty: true,  // Combine accepts empty collections as valid input
   category: ['collection'],
   description: 'Merge the input and other collections into a single collection without eliminating duplicate values. Combining an empty collection with a non-empty collection will return the non-empty collection. There is no expectation of order in the resulting collection.',
   examples: [

package/src/operations/combine-operator.ts

@@ -1,23 +1,22 @@
 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) => {
   // Combine operator concatenates all values as strings
-  const leftStr = left.map(v => String(unbox(v))).join('');
-  const rightStr = right.map(v => String(unbox(v))).join('');
-  
-  if (leftStr === '' && rightStr === '') {
-    return { value: [], context };
-  }
+  // Empty collections are treated as empty string
+  const leftStr = left.length === 0 ? '' : left.map(v => String(unbox(v))).join('');
+  const rightStr = right.length === 0 ? '' : right.map(v => String(unbox(v))).join('');
   
+  // Always return a string, even if both are empty
   return { value: [box(leftStr + rightStr, { type: 'String', singleton: true })], context };
 };
 
 export const combineOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
   symbol: '&',
   name: 'combine',
+  doesNotPropagateEmpty: true,  // Treats empty as empty string, always returns a string
   category: ['string'],
   precedence: PRECEDENCE.ADDITIVE,
   associativity: 'left',