@atomic-ehr/fhirpath 0.0.3 → 0.0.4

package/dist/{index.d.ts → model-provider.common-oir-zg7r.d.ts}

@@ -190,13 +190,13 @@ declare enum PRECEDENCE {
     XOR = 30,
     AND = 40,
     IN_CONTAINS = 50,
+    AS_IS = 55,// as, is (moved to lower precedence)
     EQUALITY = 60,// =, !=, ~, !~
+    PIPE = 65,// | (moved to lower precedence) 
     COMPARISON = 70,// <, >, <=, >=
-    PIPE = 80,// |
     ADDITIVE = 90,// +, -
     MULTIPLICATIVE = 100,// *, /, div, mod
     UNARY = 110,// unary +, -, not
-    AS_IS = 120,// as, is
     POSTFIX = 130,// []
     DOT = 140
 }
@@ -253,6 +253,7 @@ interface FunctionSignature {
         typeReference?: boolean;
     }>;
     result: TypeInfo | 'inputType' | 'inputTypeSingleton' | 'parameterType';
+    variadic?: boolean;
 }
 interface FunctionDefinition {
     name: string;
@@ -330,7 +331,7 @@ interface IdentifierNode extends BaseASTNode {
 interface LiteralNode extends BaseASTNode {
     type: NodeType.Literal;
     value: any;
-    valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+    valueType: 'string' | 'number' | 'decimal' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
 }
 interface TemporalLiteralNode extends BaseASTNode {
     type: NodeType.TemporalLiteral;
@@ -396,8 +397,8 @@ interface RuntimeContext {
     currentNode?: ASTNode;
     modelProvider?: ModelProvider;
 }
-interface EvaluationResult {
-    value: FHIRPathValue[];
+interface EvaluationResult<T = any> {
+    value: T[];
     context: RuntimeContext;
 }
 declare enum DiagnosticSeverity {
@@ -613,7 +614,8 @@ declare class Interpreter {
         inputType?: TypeInfo;
         modelProvider?: ModelProvider;
         now?: Date;
-    }): Promise<any[]>;
+        includeMetadata?: boolean;
+    }): Promise<EvaluationResult['value']>;
     private getBooleanKind;
     private boxBoolean;
     private evaluateTemporalLiteral;
@@ -743,72 +745,6 @@ declare class Analyzer {
     analyze(ast: ASTNode, userVariables?: Record<string, any>, inputType?: TypeInfo, options?: AnalyzerOptions): Promise<AnalysisResultWithCursor>;
 }
 
-interface FHIRModelContext {
-    path: string;
-    schemaHierarchy: FHIRSchema[];
-    isUnion?: boolean;
-    choices?: Array<{
-        type: TypeName;
-        code: string;
-        choiceName?: string;
-        schema?: FHIRSchema;
-    }>;
-    canonicalUrl?: string;
-    version?: string;
-}
-interface FHIRModelProviderConfig {
-    packages: Array<{
-        name: string;
-        version: string;
-    }>;
-    cacheDir?: string;
-    registryUrl?: string;
-}
-/**
- * FHIR ModelProvider implementation
- *
- * Note: This provider requires async initialization before use.
- * Call initialize() before using the synchronous methods.
- *
- * For best performance, pre-load common types during initialization.
- */
-declare class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
-    private config;
-    private canonicalManager;
-    private schemaCache;
-    private hierarchyCache;
-    private initialized;
-    private complexTypesCache?;
-    private primitiveTypesCache?;
-    private resourceTypesCache?;
-    private readonly typeMapping;
-    private readonly primitiveTypeMapping;
-    constructor(config?: FHIRModelProviderConfig);
-    initialize(): Promise<void>;
-    private buildCanonicalUrl;
-    getSchema(typeName: string): Promise<FHIRSchema | undefined>;
-    private getSchemaHierarchyAsync;
-    private extractTypeName;
-    private getSchemaHierarchyCached;
-    private mapToFHIRPathType;
-    private isChoiceType;
-    private createUnionContext;
-    getType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
-    getElementType(parentType: TypeInfo<FHIRModelContext>, propertyName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
-    ofType(type: TypeInfo<FHIRModelContext>, typeName: TypeName): TypeInfo<FHIRModelContext> | undefined;
-    getElementNames(parentType: TypeInfo<FHIRModelContext>): string[];
-    getChildrenType(parentType: TypeInfo<FHIRModelContext>): Promise<TypeInfo<FHIRModelContext> | undefined>;
-    loadType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
-    getElements(typeName: string): Promise<Array<{
-        name: string;
-        type: string;
-        documentation?: string;
-    }>>;
-    getResourceTypes(): Promise<string[]>;
-    getComplexTypes(): Promise<string[]>;
-    getPrimitiveTypes(): Promise<string[]>;
-}
-
 interface ASTMetadata {
     complexity: number;
     depth: number;
@@ -895,6 +831,7 @@ declare const Errors: {
     incompatibleUnits(unit1: string, unit2: string, location?: Range): FHIRPathError;
     indexOutOfBounds(index: number, size: number, location?: Range): FHIRPathError;
     invalidOperation(details: string, location?: Range): FHIRPathError;
+    systemVariableOverride(name: string, location?: Range): FHIRPathError;
     invalidPrecision(operation: string, location?: Range): FHIRPathError;
     invalidStringOperation(operation: string, paramName: string, location?: Range): FHIRPathError;
     invalidNumericOperation(operation: string, paramName: string, expectedType: string, location?: Range): FHIRPathError;
@@ -995,13 +932,83 @@ interface EvaluateOptions {
     variables?: Record<string, unknown>;
     modelProvider?: ModelProvider;
     inputType?: TypeInfo;
+    includeMetadata?: boolean;
 }
-declare function evaluate(expression: string, options?: EvaluateOptions): Promise<any[]>;
+declare function evaluate<T = any>(expression: string, options?: EvaluateOptions): Promise<EvaluationResult<T>['value']>;
 declare function analyze(expression: string, options?: {
     variables?: Record<string, unknown>;
     modelProvider?: ModelProvider;
     inputType?: TypeInfo;
     errorRecovery?: boolean;
 }): Promise<AnalysisResult>;
+declare function getVersion(): string;
+
+type Resource = {
+    url?: string;
+    version?: string;
+    id: string;
+    resourceType: string;
+    [key: string]: any;
+};
+interface FHIRModelContext {
+    path: string;
+    schemaHierarchy: FHIRSchema[];
+    isUnion?: boolean;
+    choices?: Array<{
+        type: TypeName;
+        code: string;
+        choiceName?: string;
+        schema?: FHIRSchema;
+    }>;
+    canonicalUrl?: string;
+    version?: string;
+}
+/**
+ * FHIR ModelProvider implementation
+ *
+ * Note: This provider requires async initialization before use.
+ * Call initialize() before using the synchronous methods.
+ *
+ * For best performance, pre-load common types during initialization.
+ */
+declare class FHIRModelProviderBase implements ModelProvider<FHIRModelContext> {
+    private schemaCache;
+    private hierarchyCache;
+    private initialized;
+    private complexTypesCache?;
+    private primitiveTypesCache?;
+    private resourceTypesCache?;
+    private readonly typeMapping;
+    private readonly primitiveTypeMapping;
+    constructor();
+    prepare(): Promise<void>;
+    initialize(): Promise<void>;
+    resolve(_canonicalUrl: string): Promise<Resource | null>;
+    search(_params: {
+        kind: "primitive-type" | "complex-type" | "resource";
+    }): Promise<Resource[]>;
+    private buildCanonicalUrl;
+    getSchema(typeName: string): Promise<FHIRSchema | undefined>;
+    private getSchemaHierarchyAsync;
+    private extractTypeName;
+    private getSchemaHierarchyCached;
+    private mapToFHIRPathType;
+    private isChoiceType;
+    private createUnionContext;
+    getType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
+    getElementType(parentType: TypeInfo<FHIRModelContext>, propertyName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
+    ofType(type: TypeInfo<FHIRModelContext>, typeName: TypeName): TypeInfo<FHIRModelContext> | undefined;
+    getElementNames(parentType: TypeInfo<FHIRModelContext>): string[];
+    getChildrenType(parentType: TypeInfo<FHIRModelContext>): Promise<TypeInfo<FHIRModelContext> | undefined>;
+    loadType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined>;
+    getElements(typeName: string): Promise<Array<{
+        name: string;
+        type: string;
+        documentation?: string;
+    }>>;
+    getResourceTypes(): Promise<string[]>;
+    getComplexTypes(): Promise<string[]>;
+    getPrimitiveTypes(): Promise<string[]>;
+}
 
-export { type ASTMetadata, type ASTNode, type AnalysisResult, Analyzer, type AnyCursorNode, type CompletionItem, CompletionKind, type CompletionOptions, type CursorArgumentNode, CursorContext, type CursorIdentifierNode, type CursorIndexNode, type CursorNode, type CursorOperatorNode, type CursorTypeNode, type Diagnostic, DiagnosticSeverity, ErrorCodes, Errors, type EvaluateOptions, type FHIRModelContext, FHIRModelProvider, type FHIRModelProviderConfig, FHIRPathError, type FunctionDefinition, type InspectOptions, type InspectResult, Interpreter, type ModelProvider as ModelTypeProvider, type OperatorDefinition, type ParseResult, Parser, Registry, type TypeInfo, type TypeName, analyze, evaluate, inspect, isCursorNode, parse, provideCompletions, registry };
+export { Analyzer as A, type CursorNode as B, CompletionKind as C, DiagnosticSeverity as D, type EvaluateOptions as E, FHIRModelProviderBase as F, type CursorOperatorNode as G, type CursorIdentifierNode as H, Interpreter as I, type CursorArgumentNode as J, type CursorIndexNode as K, type CursorTypeNode as L, type ModelProvider as M, type AnyCursorNode as N, type OperatorDefinition as O, Parser as P, type Resource as R, type TypeInfo as T, type FHIRModelContext as a, analyze as b, Registry as c, type ParseResult as d, evaluate as e, type Diagnostic as f, getVersion as g, type AnalysisResult as h, type ASTNode as i, type TypeName as j, type FunctionDefinition as k, type EvaluationResult as l, inspect as m, type InspectOptions as n, type InspectResult as o, parse as p, type ASTMetadata as q, registry as r, FHIRPathError as s, Errors as t, ErrorCodes as u, provideCompletions as v, type CompletionItem as w, type CompletionOptions as x, CursorContext as y, isCursorNode as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/fhirpath",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "A TypeScript implementation of FHIRPath",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,7 +9,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "node": "./dist/index.node.js",
+      "default": "./dist/index.browser.js"
     }
   },
   "files": [
@@ -48,6 +49,8 @@
     "@types/lodash": "^4.17.20",
     "@types/node": "22.13.14",
     "@types/turndown": "^5.0.5",
+    "@types/xml2js": "^0.4.14",
+    "@xmldom/xmldom": "^0.8.11",
     "antlr4ts": "^0.5.0-alpha.4",
     "antlr4ts-cli": "^0.5.0-alpha.4",
     "js-yaml": "^4.1.0",
@@ -56,7 +59,8 @@
     "tsup": "8.5.0",
     "turndown": "^7.2.0",
     "typescript": "^5.8.3",
-    "typescript-mcp": "^0.0.14"
+    "typescript-mcp": "^0.0.14",
+    "xml2js": "^0.6.2"
   },
   "peerDependencies": {
     "typescript": "^5"
@@ -64,6 +68,7 @@
   "dependencies": {
     "@atomic-ehr/fhir-canonical-manager": "^0.0.11",
     "@atomic-ehr/fhirschema": "^0.0.2",
-    "@atomic-ehr/ucum": "^0.2.5"
+    "@atomic-ehr/ucum": "^0.2.5",
+    "fast-xml-parser": "^5.2.5"
   }
-}
+}

package/src/analyzer.ts

@@ -198,6 +198,19 @@ export class Analyzer {
 
     // Special handling for dot operator - flow context through
     if (node.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 (node.left.type === NodeType.MembershipTest && node.right.type === NodeType.Identifier) {
+        const membershipTest = node.left as MembershipTestNode;
+        const rightIdent = node.right as IdentifierNode;
+        // Reconstruct the correct MembershipTest with full type name
+        const correctedNode: MembershipTestNode = {
+          ...membershipTest,
+          targetType: `${membershipTest.targetType}.${rightIdent.name}`
+        };
+        return await this.analyzeMembershipTest(correctedNode, context);
+      }
+      
       const leftResult = await this.analyzeNode(node.left, context);
       if (this.stoppedAtCursor) {
         return { type: { type: 'Any', singleton: false }, diagnostics: leftResult.diagnostics };
@@ -391,7 +404,7 @@ export class Analyzer {
       if (signature) {
         const params = signature.parameters || [];
         const requiredCount = params.filter(p => !p.optional).length;
-        const maxCount = params.length;
+        const maxCount = signature.variadic ? Infinity : params.length;
         const actualCount = node.arguments.length;
 
         if (actualCount < requiredCount) {
@@ -468,6 +481,7 @@ export class Analyzer {
       if (param?.expression) {
         const itemType = { ...context.inputType, singleton: true };
         const exprContext = context
+          .withInputType(itemType)  // Set input type to singleton for expression parameters
           .withSystemVariable('$this', itemType)
           .withSystemVariable('$index', { type: 'Integer', singleton: true });
         const argResult = await this.analyzeNode(arg, exprContext);
@@ -637,15 +651,29 @@ export class Analyzer {
 
     // Check if it's a user variable (starts with %)
     if (varName.startsWith('%')) {
-      // Special handling for %context - it's a built-in environment variable
-      // that always returns the original input to the evaluation engine
+      // Special handling for built-in environment variables
       if (varName === '%context') {
         // %context returns the root input type (the original input to evaluate())
         // In the analyzer, we track this as the initial input type
         return { type: context.inputType, diagnostics, context };
       }
       
-      const name = varName.substring(1); // Remove % prefix
+      // Special handling for FHIR system variables (code system URLs)
+      if (varName === '%sct' || varName === '%loinc' || varName === '%ucum' || 
+          varName === '%vs-administrative-gender' || varName === '%`vs-administrative-gender`') {
+        // These are string constants
+        return { type: { type: 'String', singleton: true }, diagnostics, context };
+      }
+      
+      // Handle environment variable syntax with backticks %`variable`
+      let name: string;
+      if (varName.startsWith('%`') && varName.endsWith('`')) {
+        // Remove %` from start and ` from end
+        name = varName.slice(2, -1);
+      } else {
+        // Remove % prefix
+        name = varName.substring(1);
+      }
       const varType = context.userVariables.get(name);
       
       if (!varType) {
@@ -745,10 +773,12 @@ export class Analyzer {
         type = { type: 'String', singleton: true };
         break;
       case 'number':
-        // Check if integer or decimal
-        type = Number.isInteger(node.value) 
-          ? { type: 'Integer', singleton: true }
-          : { type: 'Decimal', singleton: true };
+        // Number without decimal point is integer
+        type = { type: 'Integer', singleton: true };
+        break;
+      case 'decimal':
+        // Number with decimal point is decimal (even if value is whole)
+        type = { type: 'Decimal', singleton: true };
         break;
       case 'boolean':
         type = { type: 'Boolean', singleton: true };
@@ -890,7 +920,14 @@ export class Analyzer {
 
     // ModelProvider requirement for non-primitive target types
     const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
-    if (!context.modelProvider && !primitiveTypes.includes(node.targetType)) {
+    
+    // Normalize System.X types to check if they're primitive
+    let targetType = node.targetType;
+    if (targetType.startsWith('System.')) {
+      targetType = targetType.substring(7); // Remove "System." prefix
+    }
+    
+    if (!context.modelProvider && !primitiveTypes.includes(targetType)) {
       diagnostics.push(toDiagnostic(Errors.modelProviderRequired('is', node.range)));
     }
     

package/src/complex-types/quantity-value.ts

@@ -25,6 +25,29 @@ export const CALENDAR_DURATION_UNITS = new Set([
   'millisecond', 'milliseconds'
 ]);
 
+/**
+ * Calendar to UCUM duration mappings
+ * Maps FHIRPath calendar duration units to their UCUM equivalents
+ */
+export const CALENDAR_TO_UCUM: Record<string, string> = {
+  'year': 'a',
+  'years': 'a',
+  'month': 'mo',
+  'months': 'mo',
+  'week': 'wk',
+  'weeks': 'wk',
+  'day': 'd',
+  'days': 'd',
+  'hour': 'h',
+  'hours': 'h',
+  'minute': 'min',
+  'minutes': 'min',
+  'second': 's',
+  'seconds': 's',
+  'millisecond': 'ms',
+  'milliseconds': 'ms'
+};
+
 /**
  * Create a quantity value
  */
@@ -234,19 +257,118 @@ export function divideQuantities(left: QuantityValue, right: QuantityValue): Qua
  * Returns -1 if left < right, 0 if equal, 1 if left > right, null if incomparable
  */
 export function compareQuantities(left: QuantityValue, right: QuantityValue): number | null {
-  // Special case: comparing calendar durations with the same unit
-  if (CALENDAR_DURATION_UNITS.has(left.unit) && left.unit === right.unit) {
-    if (left.value < right.value) {
-      return -1;
-    } else if (left.value > right.value) {
-      return 1;
-    } else {
+  // Handle calendar to UCUM comparisons
+  const leftIsCalendar = CALENDAR_DURATION_UNITS.has(left.unit);
+  const rightIsCalendar = CALENDAR_DURATION_UNITS.has(right.unit);
+  
+  // Both calendar units - only compare if they're compatible units
+  if (leftIsCalendar && rightIsCalendar) {
+    // Only allow conversion between specific compatible units
+    const areCompatible = (unit1: string, unit2: string): boolean => {
+      // Normalize to singular form
+      const normalize = (u: string) => u.endsWith('s') ? u.slice(0, -1) : u;
+      const n1 = normalize(unit1);
+      const n2 = normalize(unit2);
+      
+      // Same unit (singular/plural)
+      if (n1 === n2) return true;
+      
+      // Week <-> days conversion
+      if ((n1 === 'week' && n2 === 'day') || (n1 === 'day' && n2 === 'week')) return true;
+      
+      // No other conversions between calendar units
+      return false;
+    };
+    
+    if (!areCompatible(left.unit, right.unit)) {
+      // Different calendar units that aren't compatible
+      return null;
+    }
+    
+    // Handle week/day conversion
+    const normalizeToSingular = (u: string) => u.endsWith('s') ? u.slice(0, -1) : u;
+    const leftNorm = normalizeToSingular(left.unit);
+    const rightNorm = normalizeToSingular(right.unit);
+    
+    if (leftNorm === rightNorm) {
+      // Same unit, just compare values
+      if (left.value < right.value) return -1;
+      if (left.value > right.value) return 1;
       return 0;
     }
+    
+    // Week <-> day conversion
+    if ((leftNorm === 'week' && rightNorm === 'day') || 
+        (leftNorm === 'day' && rightNorm === 'week')) {
+      const leftInDays = leftNorm === 'week' ? left.value * 7 : left.value;
+      const rightInDays = rightNorm === 'week' ? right.value * 7 : right.value;
+      
+      if (leftInDays < rightInDays) return -1;
+      if (leftInDays > rightInDays) return 1;
+      return 0;
+    }
+    
+    // Shouldn't reach here
+    return null;
   }
   
-  // Different calendar units cannot be compared
-  if (CALENDAR_DURATION_UNITS.has(left.unit) || CALENDAR_DURATION_UNITS.has(right.unit)) {
+  // Calendar to UCUM comparison
+  if (leftIsCalendar && !rightIsCalendar) {
+    // Check for week/day special case
+    if ((left.unit === 'days' || left.unit === 'day') && right.unit === 'wk') {
+      // Convert days to weeks
+      const leftInWeeks = left.value / 7;
+      if (leftInWeeks < right.value) return -1;
+      if (leftInWeeks > right.value) return 1;
+      return 0;
+    }
+    if ((left.unit === 'weeks' || left.unit === 'week') && right.unit === 'd') {
+      // Convert weeks to days
+      const leftInDays = left.value * 7;
+      if (leftInDays < right.value) return -1;
+      if (leftInDays > right.value) return 1;
+      return 0;
+    }
+    
+    // Direct mapping check
+    const leftUcumUnit = CALENDAR_TO_UCUM[left.unit];
+    if (leftUcumUnit === right.unit) {
+      // Direct mapping, compare values
+      if (left.value < right.value) return -1;
+      if (left.value > right.value) return 1;
+      return 0;
+    }
+    // No mapping, incomparable
+    return null;
+  }
+  
+  // UCUM to calendar comparison
+  if (!leftIsCalendar && rightIsCalendar) {
+    // Check for week/day special case
+    if (left.unit === 'wk' && (right.unit === 'days' || right.unit === 'day')) {
+      // Convert weeks to days
+      const leftInDays = left.value * 7;
+      if (leftInDays < right.value) return -1;
+      if (leftInDays > right.value) return 1;
+      return 0;
+    }
+    if (left.unit === 'd' && (right.unit === 'weeks' || right.unit === 'week')) {
+      // Convert days to weeks
+      const leftInWeeks = left.value / 7;
+      if (leftInWeeks < right.value) return -1;
+      if (leftInWeeks > right.value) return 1;
+      return 0;
+    }
+    
+    // Direct mapping check
+    const rightUcumUnit = CALENDAR_TO_UCUM[right.unit];
+    if (left.unit === rightUcumUnit) {
+      // Direct mapping, compare values
+      if (left.value < right.value) return -1;
+      if (left.value > right.value) return 1;
+      return 0;
+    }
+    // No mapping, incomparable
     return null;
   }
   

package/src/complex-types/temporal.ts

@@ -461,7 +461,33 @@ export function equivalent(a: TemporalValue, b: TemporalValue): boolean {
 }
 
 export function compare(a: TemporalValue, b: TemporalValue): -1 | 0 | 1 | null {
-  // Different types can't be compared
+  // Special case: DateTime and Date can be compared when date portions differ
+  if (isFHIRDateTime(a) && isFHIRDate(b)) {
+    // Compare the date portion of DateTime with Date
+    if (a.year !== b.year) return a.year < b.year ? -1 : 1;
+    if (b.month !== undefined && a.month !== undefined) {
+      if (a.month !== b.month) return a.month < b.month ? -1 : 1;
+    }
+    if (b.day !== undefined && a.day !== undefined) {
+      if (a.day !== b.day) return a.day < b.day ? -1 : 1;
+    }
+    // When date portions are equal, Date and DateTime are incomparable
+    return null;
+  }
+  if (isFHIRDate(a) && isFHIRDateTime(b)) {
+    // Compare Date with the date portion of DateTime
+    if (a.year !== b.year) return a.year < b.year ? -1 : 1;
+    if (a.month !== undefined && b.month !== undefined) {
+      if (a.month !== b.month) return a.month < b.month ? -1 : 1;
+    }
+    if (a.day !== undefined && b.day !== undefined) {
+      if (a.day !== b.day) return a.day < b.day ? -1 : 1;
+    }
+    // When date portions are equal, Date and DateTime are incomparable
+    return null;
+  }
+  
+  // Different types (except DateTime/Date) can't be compared
   if (a.kind !== b.kind) {
     return null;
   }
@@ -765,7 +791,7 @@ function parseDateLiteral(value: string): FHIRDate {
 }
 
 function parseTimeLiteral(value: string): FHIRTime {
-  const match = value.match(/^(\d{2})(?::(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?)?$/);
+  const match = value.match(/^(\d{2})(?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/);
   if (!match) {
     throw new Error(`Invalid time literal: @T${value}`);
   }
@@ -773,7 +799,14 @@ function parseTimeLiteral(value: string): FHIRTime {
   const hour = parseInt(match[1]!, 10);
   const minute = match[2] ? parseInt(match[2]!, 10) : undefined;
   const second = match[3] ? parseInt(match[3]!, 10) : undefined;
-  const millisecond = match[4] ? parseInt(match[4]!, 10) : undefined;
+  // Handle variable-length fractional seconds (pad or truncate to 3 digits)
+  let millisecond: number | undefined;
+  if (match[4]) {
+    const fraction = match[4];
+    // Pad to 3 digits if needed, truncate if longer
+    const padded = (fraction + '000').substring(0, 3);
+    millisecond = parseInt(padded, 10);
+  }
   
   return createTime(hour, minute, second, millisecond);
 }
@@ -826,13 +859,19 @@ function parseDateTimeLiteral(value: string): FHIRDateTime {
       }
     }
     
-    // Parse time components
-    const timeMatch = timeWithoutTz.match(/^(\d{2})(?::(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?)?$/);
+    // Parse time components - handle variable-length milliseconds
+    const timeMatch = timeWithoutTz.match(/^(\d{2})(?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/);
     if (timeMatch) {
       hour = parseInt(timeMatch[1]!, 10);
       minute = timeMatch[2] ? parseInt(timeMatch[2]!, 10) : undefined;
       second = timeMatch[3] ? parseInt(timeMatch[3]!, 10) : undefined;
-      millisecond = timeMatch[4] ? parseInt(timeMatch[4]!, 10) : undefined;
+      // Handle variable-length fractional seconds (pad or truncate to 3 digits)
+      if (timeMatch[4]) {
+        const fraction = timeMatch[4];
+        // Pad to 3 digits if needed, truncate if longer
+        const padded = (fraction + '000').substring(0, 3);
+        millisecond = parseInt(padded, 10);
+      }
     }
   }
   

package/src/errors.ts

@@ -185,6 +185,10 @@ export const Errors = {
   invalidOperation(details: string, location?: Range): FHIRPathError {
     return new FHIRPathError(ErrorCodes.INVALID_OPERATION, `Invalid operation: ${details}`, location);
   },
+
+  systemVariableOverride(name: string, location?: Range): FHIRPathError {
+    return new FHIRPathError(ErrorCodes.INVALID_OPERATION, `Cannot override system variable '${name}'`, location);
+  },
   
   invalidPrecision(operation: string, location?: Range): FHIRPathError {
     return new FHIRPathError(ErrorCodes.INVALID_PRECISION, `${operation} precision must be a non-negative integer`, location);

package/src/index.browser.ts

@@ -0,0 +1,4 @@
+export * from './index.common'
+
+export { FHIRModelProvider } from './model-provider.browser';
+export type { FHIRModelContext, Options, Resolver, Searcher } from './model-provider.browser';