fhirpath-ts 0.2.1 → 0.2.2

package/src/analyzer/expression-policy.ts

@@ -9,6 +9,9 @@ import {
   type ColumnTypeClaim,
   criteriaSignature,
 } from '../api/column-signature.ts'
+import { bareEnvironmentName } from '../engine/context.ts'
+import { type AnalyzerVariable, PROJECT_ROW_VARIABLES } from './declarations.ts'
+import type { SourceVariablePlan } from './source-options.ts'
 
 /** The supported expression argument shapes: one string, columns, constraints, or DTO variables. */
 export type CallSiteShape = 'expression' | 'columns' | 'constraints' | 'dto-vars'
@@ -38,6 +41,12 @@ export interface CallSitePolicy {
    * the expression is analyzed without an input type.
    */
   rootFromClass?: true
+  /** The EvaluateOptions argument whose inline env/vars declarations are visible to the expression. */
+  optionsArg?: number
+  /** Additional expressions held by the options argument. */
+  optionsExpressions?: 'vars'
+  /** The call supplies projection-only `%rowIndex` and `%rowTotal`. */
+  rowVariables?: true
   /**
    * A DTO member site. Its `%variables` are never judged — they come from the
    * DTO's own `vars`/`env`, from a base class, or from the projecting call, none
@@ -58,15 +67,28 @@ export const CALL_SITES: ReadonlyMap<string, CallSitePolicy> = new Map([
   // evaluated somewhere else entirely — checkable.
   ['fhirpath', { argIndex: 0, shape: 'expression', receiver: 'any', rootArg: 1 }],
   ['compile', { argIndex: 0, shape: 'expression', receiver: 'any', rootArg: 1 }],
-  ['evaluate', { argIndex: 0, shape: 'expression', receiver: 'any' }],
-  ['evaluateTyped', { argIndex: 0, shape: 'expression', receiver: 'any' }],
-  ['first', { argIndex: 0, shape: 'expression', receiver: 'engine' }],
+  ['evaluate', { argIndex: 0, shape: 'expression', receiver: 'any', optionsArg: 2, optionsExpressions: 'vars' }],
+  ['evaluateTyped', { argIndex: 0, shape: 'expression', receiver: 'any', optionsArg: 2, optionsExpressions: 'vars' }],
+  ['first', { argIndex: 0, shape: 'expression', receiver: 'engine', optionsArg: 2, optionsExpressions: 'vars' }],
   ['analyzeExpression', { argIndex: 0, shape: 'expression', receiver: 'any' }],
   // Subject-first FhirPathEngine helpers: the expression(s) come second.
-  ['test', { argIndex: 1, shape: 'expression', receiver: 'engine' }],
-  ['filter', { argIndex: 1, shape: 'expression', receiver: 'engine' }],
-  ['project', { argIndex: 1, shape: 'columns', receiver: 'engine' }],
-  ['checkConstraints', { argIndex: 1, shape: 'constraints', receiver: 'any' }],
+  ['test', { argIndex: 1, shape: 'expression', receiver: 'engine', optionsArg: 2, optionsExpressions: 'vars' }],
+  ['filter', { argIndex: 1, shape: 'expression', receiver: 'engine', optionsArg: 2, optionsExpressions: 'vars' }],
+  [
+    'project',
+    {
+      argIndex: 1,
+      shape: 'columns',
+      receiver: 'engine',
+      optionsArg: 2,
+      optionsExpressions: 'vars',
+      rowVariables: true,
+    },
+  ],
+  [
+    'checkConstraints',
+    { argIndex: 1, shape: 'constraints', receiver: 'any', optionsArg: 2, optionsExpressions: 'vars' },
+  ],
   // DTO declarations: the column/criteria expressions of a `@column` field, and
   // the `vars` a DTO binds per row.
   [
@@ -113,6 +135,12 @@ export interface SourceBindings {
   rebound: ReadonlySet<string>
 }
 
+/** Semantic receiver facts a compiler-backed walker can prove. */
+export interface ReceiverEvidence {
+  /** The receiver resolves to this package's FhirPathEngine declaration. */
+  engine?: true
+}
+
 /**
  * Whether a call site should be checked, given its policy and the file's
  * bindings. `receiverRoot` is the leftmost identifier of a member-expression
@@ -124,14 +152,18 @@ export function isCheckedCall(
   policy: CallSitePolicy,
   calleeName: string,
   receiverRoot: string | undefined,
-  bindings: SourceBindings
+  bindings: SourceBindings,
+  evidence: ReceiverEvidence = {}
 ): boolean {
-  if (policy.receiver === 'engine') {
-    return receiverRoot !== undefined && bindings.trusted.has(receiverRoot) && !bindings.rebound.has(receiverRoot)
-  }
   if (policy.receiver === 'import') {
     return receiverRoot === undefined && bindings.trusted.has(calleeName) && !bindings.rebound.has(calleeName)
   }
+  if (evidence.engine === true) {
+    return true
+  }
+  if (policy.receiver === 'engine') {
+    return receiverRoot !== undefined && bindings.trusted.has(receiverRoot) && !bindings.rebound.has(receiverRoot)
+  }
   return !bindings.foreign.has(receiverRoot ?? calleeName)
 }
 
@@ -193,8 +225,25 @@ export interface SiteContext {
   inputType?: string
   /** A DTO member site, whose findings are weighed differently (see `CallSitePolicy.dto`). */
   dto?: true
+  /** Inline per-call environment and row-variable declarations visible to this site. */
+  variables?: Readonly<Record<string, SiteVariable>>
+  /** Ordered per-call vars, kept separate so loaded engine defaults can be merged without losing runtime order. */
+  variablePlan?: SiteVariablePlan
+  /**
+   * The call binds variables the source cannot name: a computed key, a spread,
+   * or a non-literal env/vars object. An unresolved `%variable` at such a site
+   * may exist at runtime, so it is a coverage gap rather than an error — see
+   * `analyzeSite`.
+   */
+  openVariables?: true
 }
 
+/** Analyzer facts a source literal can declare; ordering requires runtime knowledge. */
+export type SiteVariable = Pick<AnalyzerVariable, 'types' | 'single' | 'targets'>
+
+/** The vars state at one expression: declarations apply as each value runs, then to the completed scope. */
+export type SiteVariablePlan = SourceVariablePlan
+
 /** One class of a file, as a walker reads its heritage clause. */
 export interface ClassHeritage {
   /** The class's own name, when it has one. */
@@ -276,7 +325,8 @@ export function siteContext<N>(
   policy: CallSitePolicy,
   argumentAt: (index: number) => N | undefined,
   classRoot: string | undefined,
-  ast: ExpressionAst<N>
+  ast: ExpressionAst<N>,
+  variables: Readonly<Record<string, SiteVariable>> | undefined
 ): SiteContext {
   const rootArgument = policy.rootArg === undefined ? undefined : argumentAt(policy.rootArg)
   const inputType =
@@ -288,9 +338,205 @@ export function siteContext<N>(
   return {
     ...(policy.dto === true && { dto: true as const }),
     ...(inputType !== undefined && { inputType }),
+    ...(variables !== undefined && Object.keys(variables).length > 0 && { variables }),
+  }
+}
+
+export interface OptionScopes<N> {
+  env: Record<string, SiteVariable>
+  vars: Record<string, SiteVariable>
+  /** Final declarations only, without value-only names. */
+  varDeclarations: Record<string, SiteVariable>
+  /** Whether this closed options object definitely omits varTypes. */
+  inheritsVarDeclarations: boolean
+  /**
+   * The options bind variables whose names the source cannot enumerate before
+   * any var expression runs: an open `env`/`envTypes` object, or an unresolved
+   * options write that may supply either one.
+   */
+  openBeforeVars: boolean
+  /** Whether the completed env/vars/type declarations may bind additional names. */
+  openAfterVars: boolean
+  /** Final ordered `vars` entries, or one coverage gap when their order is dynamic. */
+  expressions: (ExpressionCandidate<N> & { name?: string })[]
+}
+
+/** Parse one literal EvaluateOptions object into environment and ordered var scopes. */
+export function optionScopes<N>(options: N, ast: ExpressionAst<N>): OptionScopes<N> | undefined {
+  const properties = ast.properties(options)
+  if (properties === undefined) {
+    return undefined
+  }
+  const lastUnknown = properties.findLastIndex(property => property.name === undefined)
+  const envValues = finalKnownProperty(properties, 'env', lastUnknown)
+  const envDeclarations = finalKnownProperty(properties, 'envTypes', lastUnknown)
+  const varValues = finalKnownProperty(properties, 'vars', lastUnknown)
+  const varDeclarations = finalKnownProperty(properties, 'varTypes', lastUnknown)
+  const varsProperties = varValues === undefined ? [] : ast.properties(varValues)
+  const envScope = variablesFromPair(envValues, envDeclarations, ast)
+  const varScope = variablesFromPair(varValues, varDeclarations, ast)
+  const unknownOptions = lastUnknown >= 0
+  // env/envTypes exist while var bodies run. vars/varTypes only finish binding
+  // after those bodies have run, so an unknown varTypes name must not hide a
+  // real error inside a var expression.
+  const openBeforeVars =
+    envScope.valuesOpen ||
+    envScope.declarationsOpen ||
+    (unknownOptions && (envValues === undefined || envDeclarations === undefined))
+  const dynamicVars = varsProperties === undefined || varsProperties.some(property => property.name === undefined)
+  return {
+    env: envScope.variables,
+    vars: varScope.variables,
+    varDeclarations: varScope.declarations,
+    inheritsVarDeclarations: !unknownOptions && varDeclarations === undefined,
+    openBeforeVars,
+    openAfterVars:
+      openBeforeVars ||
+      dynamicVars ||
+      varScope.declarationsOpen ||
+      (unknownOptions && (varValues === undefined || varDeclarations === undefined)),
+    expressions:
+      varValues === undefined
+        ? []
+        : dynamicVars
+          ? [{ node: varValues, uncheckable: 'dynamic-vars' as const }]
+          : finalVarExpressions(varsProperties, ast),
+  }
+}
+
+/** Final values in Object.entries order when every vars key is statically known. */
+function finalVarExpressions<N>(
+  properties: readonly ExpressionProperty<N>[],
+  ast: ExpressionAst<N>
+): (ExpressionCandidate<N> & { name: string })[] {
+  return finalNormalizedEntries(properties).flatMap(({ name, value: node }) => {
+    const entry = ast.string(node)
+    return [{ node, name, ...(entry !== undefined && { expression: entry.expression }) }]
+  })
+}
+
+/** Runtime entries after Object.entries(), bare-name normalization, and Object.entries() again. */
+function finalNormalizedEntries<N>(properties: readonly ExpressionProperty<N>[]): { name: string; value: N }[] {
+  const raw: Record<string, N> = Object.create(null)
+  for (const property of properties) {
+    if (property.name !== undefined) {
+      raw[property.name] = property.value
+    }
+  }
+  const normalized: Record<string, N> = Object.create(null)
+  for (const [rawName, value] of Object.entries(raw)) {
+    normalized[bareEnvironmentName(rawName)] = value
+  }
+  return Object.entries(normalized).map(([name, value]) => ({ name, value }))
+}
+
+/** Known names and provably final values of one normalized host map. */
+function normalizedObjectWrites<N>(
+  node: N | undefined,
+  ast: ExpressionAst<N>
+): {
+  names: string[]
+  final: { name: string; value: N }[]
+  open: boolean
+} {
+  if (node === undefined) {
+    return { names: [], final: [], open: false }
+  }
+  const properties = ast.properties(node)
+  if (properties === undefined) {
+    return { names: [], final: [], open: true }
+  }
+  const names = [
+    ...new Set(
+      properties.flatMap(property => (property.name === undefined ? [] : [bareEnvironmentName(property.name)]))
+    ),
+  ]
+  const open = properties.some(property => property.name === undefined)
+  // An unknown raw key can establish either `%x` or `x` first. Overwriting a
+  // property does not move that insertion position, so no normalized value is
+  // provably final once the map is open.
+  const final = open ? [] : finalNormalizedEntries(properties)
+  return { names, final, open }
+}
+
+function variablesFromPair<N>(
+  values: N | undefined,
+  declared: N | undefined,
+  ast: ExpressionAst<N>
+): {
+  variables: Record<string, SiteVariable>
+  declarations: Record<string, SiteVariable>
+  valuesOpen: boolean
+  declarationsOpen: boolean
+} {
+  const valueWrites = normalizedObjectWrites(values, ast)
+  const declarationWrites = normalizedObjectWrites(declared, ast)
+  const variables = Object.fromEntries(valueWrites.names.map(name => [name, {}]))
+  const declarations: Record<string, SiteVariable> = {}
+  for (const { name, value } of declarationWrites.final) {
+    const declaration = typeDeclaration(value, ast)
+    if (declaration !== undefined) {
+      declarations[name] = declaration
+    }
+  }
+  return {
+    variables: { ...variables, ...declarations },
+    declarations,
+    valuesOpen: valueWrites.open,
+    declarationsOpen: declarationWrites.open,
+  }
+}
+
+/** Last named property after an unknown write that could replace its value. */
+function finalKnownProperty<N>(
+  properties: readonly ExpressionProperty<N>[] | undefined,
+  name: string,
+  after: number
+): N | undefined {
+  let value: N | undefined
+  for (const property of properties?.slice(after + 1) ?? []) {
+    if (property.name === name) {
+      value = property.value
+    }
+  }
+  return value
+}
+
+function typeDeclaration<N>(node: N, ast: ExpressionAst<N>): SiteVariable | undefined {
+  const properties = ast.properties(node)
+  if (properties === undefined) {
+    return undefined
+  }
+  const lastUnknown = properties.findLastIndex(property => property.name === undefined)
+  const typeNode = finalKnownProperty(properties, 'type', lastUnknown)
+  const types = typeNode === undefined ? undefined : literalStrings(typeNode, ast)
+  if (types === undefined || types.length === 0) {
+    return undefined
+  }
+  const collectionNode = finalKnownProperty(properties, 'collection', lastUnknown)
+  const collection = collectionNode === undefined ? (lastUnknown < 0 ? false : undefined) : ast.boolean(collectionNode)
+  const targetsNode = finalKnownProperty(properties, 'targets', lastUnknown)
+  const targets = targetsNode === undefined ? undefined : literalStrings(targetsNode, ast)
+  return {
+    types,
+    ...(collection !== undefined && { single: !collection }),
+    ...(targets !== undefined && targets.length > 0 && { targets }),
   }
 }
 
+function literalStrings<N>(node: N, ast: ExpressionAst<N>): string[] | undefined {
+  const one = ast.string(node)?.expression
+  if (one !== undefined) {
+    return [one]
+  }
+  const elements = ast.elements(node)
+  if (elements === undefined) {
+    return undefined
+  }
+  const strings = elements.map(element => ast.string(element)?.expression)
+  return strings.every(value => value !== undefined) ? strings : undefined
+}
+
 /**
  * The AST accessors a walker provides so shape extraction can be written once.
  * Each returns undefined when the node is not of the asked-for kind, which the
@@ -303,57 +549,180 @@ export interface ExpressionAst<N> {
   /** The node's value as a `true`/`false` literal, or undefined when it is not one. */
   boolean(node: N): boolean | undefined
   /**
-   * The plain (non-spread, non-shorthand) properties of an object literal, or
-   * undefined when the node is not an object literal. `name` is the property's
-   * statically-known key — undefined for computed keys.
+   * The properties of an object literal in source order, including shorthand
+   * properties whose value is the identifier itself, or undefined when the node
+   * is not an object literal. `name` is the property's statically-known key —
+   * a plain or computed string literal, or an identifier — and undefined for
+   * other computed keys. A spread carries `spread: true`, no name, and the
+   * spread expression as its value.
    */
-  properties(node: N): { name: string | undefined; value: N }[] | undefined
+  properties(node: N): ExpressionProperty<N>[] | undefined
   /** The elements of an array literal, or undefined when the node is not one. */
   elements(node: N): N[] | undefined
 }
 
+/** One object-literal write as exposed by either source walker. */
+export interface ExpressionProperty<N> {
+  name: string | undefined
+  value: N
+  spread?: true
+}
+
+/** One expression-shaped node, whether or not its value is a static string. */
+export interface ExpressionCandidate<N> {
+  node: N
+  expression?: string
+  /** The node contains expressions, but their final names/order cannot be proven. */
+  uncheckable?: 'dynamic-vars'
+}
+
+/** One call expression paired with the source facts visible at that exact point. */
+export interface ContextualExpressionCandidate<N> extends ExpressionCandidate<N> {
+  context: SiteContext
+  source: 'argument' | 'option-var'
+}
+
 /**
- * Extract the expression literal(s) an argument holds, per the call site's shape.
- * Column keys are output names, not expressions, so a computed key does not stop
- * its value from being checked; `{ path }` / `{ expression }` lookups match
- * identifier and string-literal keys only.
+ * Expand one supported call into every expression-shaped node and its context.
+ * EvaluateOptions vars bind in declaration order after env. Project vars also
+ * see the row variables, and project columns see the completed var scope.
+ * A construct that binds names the source cannot list marks the relevant scope
+ * open. Dynamic `vars` keys also make the final expression values and
+ * Object.entries order unknowable: a later spread can overwrite an earlier
+ * value while retaining its original key position. Such var bodies become one
+ * explicit coverage gap instead of producing false diagnostics.
  */
-export function expressionEntries<N>(argument: N, shape: CallSiteShape, ast: ExpressionAst<N>): ExpressionEntry<N>[] {
+export function callExpressionCandidates<N>(
+  policy: CallSitePolicy,
+  argumentAt: (index: number) => N | undefined,
+  classRoot: string | undefined,
+  ast: ExpressionAst<N>
+): ContextualExpressionCandidate<N>[] {
+  const argument = argumentAt(policy.argIndex)
+  if (argument === undefined) {
+    return []
+  }
+  const options = policy.optionsArg === undefined ? undefined : argumentAt(policy.optionsArg)
+  const scopes = options === undefined ? undefined : optionScopes(options, ast)
+  const openBeforeVars = options !== undefined && (scopes === undefined || scopes.openBeforeVars)
+  const openAfterVars = options !== undefined && (scopes === undefined || scopes.openAfterVars)
+  const base = siteContext(policy, argumentAt, classRoot, ast, {
+    ...scopes?.env,
+    ...(policy.rowVariables === true && PROJECT_ROW_VARIABLES),
+  })
+  const values = scopes?.expressions.flatMap(entry => (entry.name === undefined ? [] : [entry.name])) ?? []
+  const plan =
+    options === undefined
+      ? undefined
+      : {
+          values,
+          declarations: scopes?.varDeclarations ?? {},
+          inheritsDeclarations: scopes?.inheritsVarDeclarations ?? false,
+        }
+  const context: SiteContext = {
+    ...base,
+    ...(plan !== undefined && { variablePlan: plan }),
+    ...(openAfterVars && { openVariables: true }),
+  }
+  const candidates: ContextualExpressionCandidate<N>[] = expressionCandidates(argument, policy.shape, ast).map(
+    candidate => ({
+      ...candidate,
+      context,
+      source: 'argument' as const,
+    })
+  )
+  if (policy.optionsExpressions !== 'vars' || policy.optionsArg === undefined) {
+    return candidates
+  }
+  if (scopes === undefined) {
+    return candidates
+  }
+  for (const entry of scopes.expressions) {
+    candidates.push({
+      node: entry.node,
+      ...(entry.expression !== undefined && { expression: entry.expression }),
+      ...(entry.uncheckable !== undefined && { uncheckable: entry.uncheckable }),
+      context: {
+        ...base,
+        variablePlan: {
+          values,
+          declarations: scopes.varDeclarations,
+          inheritsDeclarations: scopes.inheritsVarDeclarations,
+          ...(entry.name !== undefined && { before: entry.name }),
+        },
+        ...(openBeforeVars && { openVariables: true as const }),
+      },
+      source: 'option-var',
+    })
+  }
+  return candidates
+}
+
+/** Canonical traversal of every supported expression container. */
+export function expressionCandidates<N>(
+  argument: N,
+  shape: CallSiteShape,
+  ast: ExpressionAst<N>
+): ExpressionCandidate<N>[] {
   if (shape === 'expression') {
     const entry = ast.string(argument)
-    return entry ? [entry] : []
+    return [{ node: argument, ...(entry !== undefined && { expression: entry.expression }) }]
   }
   if (shape === 'columns') {
-    // project() columns: { name: 'expr' }, { name: { path: 'expr', ... } }, or
-    // the boolean-criteria form { name: { test: 'expr' } }.
-    return (ast.properties(argument) ?? []).flatMap(({ value }) => {
+    // A non-object may be a DTO class, which holds no source expressions. A
+    // spread holds no column literal of its own.
+    return (ast.properties(argument) ?? []).flatMap(({ value, spread }) => {
+      if (spread === true) {
+        return []
+      }
       const entry = ast.string(value)
-      return entry ? [entry] : [...namedStringEntries(value, 'path', ast), ...namedStringEntries(value, 'test', ast)]
+      if (entry !== undefined) {
+        return [{ node: value, expression: entry.expression }]
+      }
+      const nested = ast.properties(value)
+      if (nested === undefined) {
+        return [{ node: value }]
+      }
+      return nested.flatMap(property => {
+        if (property.name !== 'path' && property.name !== 'test') {
+          return []
+        }
+        const nestedEntry = ast.string(property.value)
+        return [{ node: property.value, ...(nestedEntry !== undefined && { expression: nestedEntry.expression }) }]
+      })
     })
   }
   if (shape === 'dto-vars') {
-    // defineDto() options: { vars: { name: 'expr' }, callerEnv: [...] }. Only
-    // vars hold expressions.
     const vars = (ast.properties(argument) ?? []).filter(({ name }) => name === 'vars')
-    return vars.flatMap(({ value }) =>
-      (ast.properties(value) ?? []).flatMap(({ value: expression }) => {
-        const entry = ast.string(expression)
-        return entry ? [entry] : []
-      })
-    )
+    return vars.flatMap(({ value }) => {
+      const properties = ast.properties(value)
+      return properties === undefined
+        ? [{ node: value }]
+        : properties.flatMap(property => {
+            if (property.spread === true) {
+              return []
+            }
+            const entry = ast.string(property.value)
+            return [{ node: property.value, ...(entry !== undefined && { expression: entry.expression }) }]
+          })
+    })
   }
-  // checkConstraints() constraints: [{ key, expression: 'expr', ... }].
-  return (ast.elements(argument) ?? []).flatMap(element => namedStringEntries(element, 'expression', ast))
-}
-
-/** The string-literal values of an object literal's `name` properties. */
-function namedStringEntries<N>(object: N, name: string, ast: ExpressionAst<N>): ExpressionEntry<N>[] {
-  return (ast.properties(object) ?? []).flatMap(({ name: key, value }) => {
-    if (key !== name) {
-      return []
+  const elements = ast.elements(argument)
+  if (elements === undefined) {
+    return [{ node: argument }]
+  }
+  return elements.flatMap(element => {
+    const properties = ast.properties(element)
+    if (properties === undefined) {
+      return [{ node: element }]
     }
-    const entry = ast.string(value)
-    return entry ? [entry] : []
+    return properties.flatMap(property => {
+      if (property.name !== 'expression') {
+        return []
+      }
+      const entry = ast.string(property.value)
+      return [{ node: property.value, ...(entry !== undefined && { expression: entry.expression }) }]
+    })
   })
 }
 
@@ -417,9 +786,16 @@ function columnClaim<N>(options: N | undefined, ast: ExpressionAst<N>): ColumnTy
   if (properties === undefined) {
     return {}
   }
-  const named = (name: string): N | undefined => properties.find(property => property.name === name)?.value
+  const lastUnknown = properties.findLastIndex(property => property.name === undefined)
+  if (lastUnknown >= 0) {
+    // A spread/computed key can introduce `as` or `choices`; later type and
+    // collection writes do not remove those conversion modes. Keep only the
+    // independently known input signature.
+    return {}
+  }
+  const named = (name: string): N | undefined => finalKnownProperty(properties, name, lastUnknown)
   const collection = named('collection')
-  const isCollection = collection === undefined ? false : ast.boolean(collection)
+  const isCollection = collection === undefined ? (lastUnknown < 0 ? false : undefined) : ast.boolean(collection)
   if (isCollection === undefined) {
     return {}
   }

package/src/analyzer/operator-rules.ts

@@ -1,6 +1,6 @@
 import type { BinaryOperator } from '../parser/ast.ts'
 import { commonValueKind } from '../values/type-compat.ts'
-import { type StaticStateLike, unionStates, withSingle } from './signatures.ts'
+import { sequentialOrder, type StaticStateLike, unionStates, withOrder, withSingle } from './signatures.ts'
 
 export type OperatorResultRule =
   | { kind: 'fixed'; types: readonly string[]; single: boolean }
@@ -50,7 +50,7 @@ export function applyOperatorResultRule(
   const rule = OPERATOR_RESULT_RULES[operator]
   switch (rule.kind) {
     case 'fixed':
-      return { types: [...rule.types], single: rule.single }
+      return { types: [...rule.types], single: rule.single, ordered: true }
     case 'arithmetic': {
       const leftKind = commonValueKind(left.types)
       const rightKind = commonValueKind(right.types)
@@ -58,6 +58,7 @@ export function applyOperatorResultRule(
       return {
         types: quantity ? ['System.Quantity'] : operator === '/' ? ['System.Decimal'] : (left.types ?? right.types),
         single: true,
+        ordered: true,
       }
     }
     case 'union':
@@ -67,7 +68,7 @@ export function applyOperatorResultRule(
       if (right.types?.length === 0) {
         return left
       }
-      return withSingle(unionStates([left, right]), false)
+      return withOrder(withSingle(unionStates([left, right]), false), sequentialOrder(left.ordered, right.ordered))
   }
 }
 
@@ -79,10 +80,10 @@ export function applyTypeOperatorResultRule(
   const rule = TYPE_OPERATOR_RESULT_RULES[operator]
   switch (rule.kind) {
     case 'fixed':
-      return { types: [...rule.types], single: rule.single }
+      return { types: [...rule.types], single: rule.single, ordered: true }
     case 'narrow':
       return narrowedTypes === undefined
-        ? { types: undefined, single: undefined }
-        : { types: [...narrowedTypes], single: true }
+        ? { types: undefined, single: undefined, ordered: undefined }
+        : { types: [...narrowedTypes], single: true, ordered: true }
   }
 }