fhirpath-ts 0.0.0-bootstrap.0 → 0.2.0

package/src/typed/context-maps.ts

@@ -0,0 +1,41 @@
+/** An empty host context that contributes no known keys. */
+export type EmptyContextMap = Record<never, never>
+
+/** Preserve host values for best-effort type inference without exposing them as declarations. */
+export type HostValueDeclarations<Values> =
+  Values extends Readonly<Record<PropertyKey, unknown>>
+    ? { readonly [Name in keyof Values]: { readonly __value: Values[Name] } }
+    : EmptyContextMap
+
+/** Environment names are stored without the optional leading `%`. */
+export type BareContextName<Name extends PropertyKey> = Name extends string
+  ? Name extends `%${infer Bare}`
+    ? Bare
+    : Name
+  : Name
+
+/** Normalize both accepted environment-key spellings into one type-level map. */
+export type NormalizeContextMap<Map> =
+  Map extends Readonly<Record<PropertyKey, unknown>>
+    ? { readonly [Name in keyof Map as BareContextName<Name>]: Map[Name] }
+    : EmptyContextMap
+
+/** Merge normalized maps by name, with the overlay taking precedence. */
+export type MergeContextMaps<Base, Overlay> = Omit<NormalizeContextMap<Base>, keyof NormalizeContextMap<Overlay>> &
+  NormalizeContextMap<Overlay>
+
+/** Infer undeclared host values while letting explicit declarations replace them. */
+export type InferredHostValueDeclarations<Values, Declarations> =
+  keyof NormalizeContextMap<Values> extends keyof NormalizeContextMap<Declarations>
+    ? NormalizeContextMap<Declarations>
+    : MergeContextMaps<HostValueDeclarations<Values>, Declarations>
+
+/** Read an optional context field without distributing undefined into its map. */
+export type ContextProperty<Context, Name extends PropertyKey> = Name extends keyof Context
+  ? Exclude<Context[Name], undefined>
+  : EmptyContextMap
+
+/** Look up one normalized name, returning never when it is undeclared. */
+export type LookupContextMap<Map, Name extends string> = Name extends keyof NormalizeContextMap<Map>
+  ? NormalizeContextMap<Map>[Name]
+  : never

package/src/typed/infer.ts

@@ -1,433 +1,165 @@
-import type { R4Bases, R4Elements, R4Resources, R4TypeOf } from '../r4/generated/type-maps.ts'
-
-/**
- * Type-level inference for common literal expressions: paths, indexes, choice
- * stems, selected collection functions, `select`, `ofType`, `as`, fixed-result
- * functions, unions, groups, and variable roots. Other expressions return
- * `unknown[]`. The runtime and analyzer support the full language.
- */
-
-/**
- * A type name the bound model knows — a resource or a datatype. What a DTO's
- * `fhirType` must be, and what `fhirpath`/`compile` accept as the type an
- * expression runs against. Lives here, with the rest of the inference vocabulary,
- * so every layer above spells it one way.
- */
+import type { R4Resources, R4TypeOf } from '../r4/generated/type-maps.ts'
+import type {
+  BareContextName,
+  ContextProperty,
+  EmptyContextMap,
+  InferredHostValueDeclarations,
+  MergeContextMaps,
+  NormalizeContextMap,
+} from './context-maps.ts'
+import type { InferTypeExpression } from './parser.ts'
+
+/** A type name known by the generated R4 model. */
 export type FhirTypeName = keyof R4TypeOf & string
-
-/** Element lookup by name, walking base types. */
-type ElementInfo<T extends string, E extends string> = T extends keyof R4Elements
-  ? E extends keyof R4Elements[T]
-    ? R4Elements[T][E]
-    : T extends keyof R4Bases
-      ? R4Bases[T] extends string
-        ? ElementInfo<R4Bases[T], E>
-        : never
-      : never
-  : never
-
-/**
- * Characters that never appear in an element or variable name: their presence
- * in a segment means an operator or literal got glued on (`name and x`,
- * `gender=gender`), and the runtime evaluates something entirely different
- * from a navigation. Such segments must degrade to 'opaque' — the broad state
- * would let a later fixed-return call claim a concrete type for what is
- * really a comparison.
- */
-type GluedName<E extends string> = E extends
-  | `${string} ${string}`
-  | `${string}'${string}`
-  | `${string}"${string}`
-  | `${string}=${string}`
-  | `${string}!${string}`
-  | `${string}<${string}`
-  | `${string}>${string}`
-  | `${string}+${string}`
-  | `${string}-${string}`
-  | `${string}*${string}`
-  | `${string}/${string}`
-  | `${string}&${string}`
-  | `${string}~${string}`
-  | `${string},${string}`
-  | `${string}|${string}`
-  | `${string}%${string}`
-  | `${string}$${string}`
-  | `${string}@${string}`
-  | `${string}(${string}`
-  | `${string})${string}`
-  | `${string}[${string}`
-  | `${string}]${string}`
-  | `${string}{${string}`
-  | `${string}}${string}`
-  | `${string}\\${string}`
-  | `${string}\`${string}`
-  ? true
-  : false
-
-/**
- * Navigates one element. A missing normal name widens the state because the
- * runtime returns empty and a later fixed-result function still has a known
- * type. A segment containing expression syntax becomes `opaque` instead.
- */
-type Navigate<S extends string, E extends string> = string extends S
-  ? MissedElement<E, S>
-  : ElementInfo<S, E> extends { t: infer N extends string }
-    ? string extends N
-      ? // No element matched: `infer N` fell back to its `string` constraint
-        // (a real element is always a literal name).
-        MissedElement<E, string>
-      : N
-    : 'opaque'
-
-/**
- * An element lookup that found nothing: glued segments are misparses and go
- * 'opaque'; a sane-looking name widens to (or stays) the broad state. Only
- * misses pay the GluedName scan — real elements are never glued.
- */
-type MissedElement<E extends string, Broad extends string> = GluedName<E> extends true ? 'opaque' : Broad
-
-/**
- * Checks that a matched call ends at its final `)`. Quotes are removed before
- * balancing parentheses. Backslashes and backticks fall outside this subset.
- */
-type CleanArg<A extends string> = A extends `${string}\\${string}` | `${string}\`${string}`
-  ? false
-  : Balanced<StripQuoted<A>>
-
-/** Removes `'…'` spans so parens inside string literals don't disturb Balanced. */
-type StripQuoted<A extends string> = A extends `${infer L}'${string}'${infer R}` ? `${L}${StripQuoted<R>}` : A
-
-/** Every `(` opens before its `)` closes; one nesting level per pair. */
-type Balanced<A extends string> = A extends `${infer L}(${infer M})${infer R}`
-  ? L extends `${string})${string}`
-    ? false
-    : M extends `${string}(${string}`
-      ? false
-      : Balanced<R>
-  : A extends `${string})${string}`
-    ? false
-    : true
-
-/** Push one stack entry per `(` of A (quoted spans already stripped). */
-type PushOpens<A extends string, Acc extends unknown[]> = A extends `${string}(${infer R}`
-  ? PushOpens<R, [...Acc, 0]>
-  : Acc
-
-/** Checks full parenthesis balance after quoted spans have been removed. */
-type BalancedDeep<A extends string, Open extends unknown[] = []> = A extends `${infer Head})${infer Rest}`
-  ? PushOpens<Head, Open> extends [unknown, ...infer Remaining]
-    ? BalancedDeep<Rest, Remaining>
-    : false
-  : PushOpens<A, Open> extends []
-    ? true
-    : false
-
-/**
- * Whether a fragment is a complete sub-expression, so a `|` (or a group's `)`)
- * right after it is really at the top level: quotes pair up, and what remains
- * after stripping them balances with nothing left open. Backslashes and
- * backticks are declined outright, like CleanArg.
- */
-type CompleteFragment<A extends string> = A extends `${string}\\${string}` | `${string}\`${string}`
-  ? false
-  : StripQuoted<A> extends infer Q extends string
-    ? Q extends `${string}'${string}`
-      ? false
-      : BalancedDeep<Q>
-    : false
-
-/** Strip the leading/trailing spaces a union split leaves around its terms. */
-type Trim<S extends string> = S extends ` ${infer R}` ? Trim<R> : S extends `${infer L} ` ? Trim<L> : S
-
-/**
- * Functions with input-independent result types. A test compares this table
- * with analyzer signatures. Functions whose result depends on input stay out.
- */
-export const FIXED_RETURNS = {
-  exists: 'boolean',
-  empty: 'boolean',
-  not: 'boolean',
-  hasValue: 'boolean',
-  count: 'integer',
-  length: 'integer',
-  toBoolean: 'boolean',
-  convertsToBoolean: 'boolean',
-  convertsToInteger: 'boolean',
-  convertsToDecimal: 'boolean',
-  convertsToString: 'boolean',
-  convertsToDate: 'boolean',
-  convertsToDateTime: 'boolean',
-  convertsToTime: 'boolean',
-  convertsToQuantity: 'boolean',
-  toInteger: 'integer',
-  toDecimal: 'decimal',
-  toString: 'string',
-  toDate: 'date',
-  toDateTime: 'dateTime',
-  toTime: 'time',
-  toQuantity: 'Quantity',
-  toChars: 'string',
-  join: 'string',
-  trim: 'string',
-  upper: 'string',
-  lower: 'string',
-  replace: 'string',
-  replaceMatches: 'string',
-  substring: 'string',
-  encode: 'string',
-  decode: 'string',
-  escape: 'string',
-  unescape: 'string',
-  split: 'string',
-  matches: 'boolean',
-  matchesFull: 'boolean',
-  startsWith: 'boolean',
-  endsWith: 'boolean',
-  contains: 'boolean',
-  subsetOf: 'boolean',
-  supersetOf: 'boolean',
-  isDistinct: 'boolean',
-  allTrue: 'boolean',
-  anyTrue: 'boolean',
-  allFalse: 'boolean',
-  anyFalse: 'boolean',
-  all: 'boolean',
-  indexOf: 'integer',
-  lastIndexOf: 'integer',
-  ceiling: 'integer',
-  floor: 'integer',
-  truncate: 'integer',
-  round: 'decimal',
-  sqrt: 'decimal',
-  exp: 'decimal',
-  ln: 'decimal',
-  log: 'decimal',
-} as const satisfies Record<string, FhirTypeName>
-
-type FixedReturns = typeof FIXED_RETURNS
-
-/**
- * Functions that yield a subset or reordering of their input, so the input's
- * type carries through. Cross-checked against the analyzer the same way as
- * FIXED_RETURNS (their signatures preserve the input's types). `abs` is
- * excluded deliberately: it preserves the numeric kind at runtime, but the
- * analyzer declares its result unknown, and the table must not outrun it.
- */
-export const IDENTITY_RETURNS = [
-  'where',
-  'first',
-  'last',
-  'single',
-  'distinct',
-  'tail',
-  'skip',
-  'take',
-  'exclude',
-  'intersect',
-  'trace',
-] as const
-
-type IdentityFn = (typeof IDENTITY_RETURNS)[number]
-
-/** One call segment, dispatched on the function name. */
-type Call<S extends string, Fn extends string, Arg extends string> = Fn extends IdentityFn
-  ? S
-  : Fn extends 'ofType' | 'as'
-    ? Arg extends FhirTypeName
-      ? Arg
-      : 'opaque'
-    : Fn extends keyof FixedReturns
-      ? FixedReturns[Fn]
-      : 'opaque'
-
-/** One `.`-separated segment: a call the subset knows, an indexer, or an element. */
-type Step<S extends string, Seg extends string> = [S] extends ['opaque']
-  ? 'opaque'
-  : Seg extends `${infer Fn}(${infer Arg})`
-    ? Fn extends 'select'
-      ? // A select argument is a sub-expression, so parse it before inference.
-        ParseExpr<Arg, S>
-      : CleanArg<Arg> extends true
-        ? Call<S, Fn, Arg>
-        : 'opaque'
-    : Seg extends `${infer N}[${infer I}]`
-      ? I extends `${string}]${string}` | `${string}[${string}`
-        ? // A ']' or '[' inside the index means this "one indexer" spans an
-          // operator (`family[0] | active[0]`): outside the subset.
-          'opaque'
-        : Navigate<S, N>
-      : Navigate<S, Seg>
-
-/** Walk the remaining `.`-separated segments. */
-type ParseSegments<Expr extends string, S extends string> = Expr extends ''
-  ? S
-  : Expr extends `${infer Head}.${infer Rest}`
-    ? Head extends `${string}(` | `${string}(${string}`
-      ? // A '.' inside parentheses split the segment: rejoin before stepping.
-        StepAcrossParen<Expr, S>
-      : ParseSegments<Rest, Step<S, Head>>
-    : Step<S, Expr>
-
-/**
- * A segment whose parentheses contain dots (e.g. `select(name.given)`) runs
- * to the `)` that completes its argument; the `.` after that starts the next
- * segment. Scanned `).` by `).`: a candidate close inside a string literal,
- * or with parens still open, is not the close — CompleteFragment decides.
- * With no valid `).` split, the whole rest is one segment ending at its
- * final `)`.
- */
-type StepAcrossParen<Expr extends string, S extends string> = ScanSegmentEnd<Expr, '', S>
-
-type ScanSegmentEnd<
-  Expr extends string,
-  Acc extends string,
-  S extends string,
-> = Expr extends `${infer Head}).${infer Rest}`
-  ? SegmentComplete<`${Acc}${Head}`> extends true
-    ? ParseSegments<Rest, Step<S, `${Acc}${Head})`>>
-    : ScanSegmentEnd<Rest, `${Acc}${Head}).`, S>
-  : WholeParenSegment<`${Acc}${Expr}`, S>
-
-/** Whether `Body)` is one complete call segment: its argument closes exactly there. */
-type SegmentComplete<Body extends string> = `${Body})` extends `${infer _Fn}(${infer Arg})`
-  ? CompleteFragment<Arg>
-  : false
-
-/** The rest of the expression is a single paren segment ending at its final `)`. */
-type WholeParenSegment<Expr extends string, S extends string> = Expr extends `${infer Head})${''}`
-  ? Step<S, `${Head})`>
-  : 'opaque'
-
-/**
- * One expression in a context state `S`: a `|`-union of terms, or a single
- * term. Plain dotted paths take two cheap checks: one skips the union scanner,
- * and the next skips trimming and group or `%var` handling.
- */
-type ParseExpr<Expr extends string, S extends string> = Expr extends `${string}|${string}` | `(${string}` | `%${string}`
-  ? ParseUnion<Expr, S>
-  : Expr extends `${infer Root}.${infer Rest}`
-    ? Root extends keyof R4Resources & string
-      ? ParseSegments<Rest, Root>
-      : ParseSegments<Expr, S>
-    : Expr extends keyof R4Resources & string
-      ? Expr
-      : ParseSegments<Expr, S>
-
-/**
- * Split off the leftmost top-level `|`. A candidate fragment whose quotes or
- * parens are cut mid-way (the `|` sat inside a literal or a group) is not a
- * split point: the fragment absorbs the `|` and the scan continues. With no
- * top-level `|` at all, the whole expression is one term — its own parse is
- * the validation, so this branch needs no separate completeness check.
- */
-type SplitUnion<Expr extends string, Acc extends string = ''> = Expr extends `${infer L}|${infer R}`
-  ? CompleteFragment<`${Acc}${L}`> extends true
-    ? { term: `${Acc}${L}`; rest: R }
-    : SplitUnion<R, `${Acc}${L}|`>
-  : { whole: `${Acc}${Expr}` }
-
-/** Fold the split terms into one union state. */
-type ParseUnion<Expr extends string, S extends string> =
-  SplitUnion<Expr> extends { term: infer T extends string; rest: infer R extends string }
-    ? UnionStates<ParseTerm<Trim<T>, S>, ParseUnion<R, S>>
-    : SplitUnion<Expr> extends { whole: infer W extends string }
-      ? ParseTerm<Trim<W>, S>
-      : 'opaque'
-
-/**
- * The union of two term states. If EITHER side failed to parse, the whole
- * union is 'opaque' — a known name must never absorb a failed parse. A broad
- * member needs no special case: `string` swallows the other names, and
- * unknowable-joined-with-anything is unknowable.
- */
-type UnionStates<A extends string, B extends string> = [A] extends ['opaque']
-  ? 'opaque'
-  : [B] extends ['opaque']
-    ? 'opaque'
-    : A | B
-
-/**
- * One union term (or a whole single-term expression): a parenthesized group,
- * a `%var` root, a resource-rooted path, or a path relative to the context
- * state `S`. The top level passes S = 'opaque', so relative terms degrade
- * there; select() passes its input state, so its sub-paths resolve.
- */
-type ParseTerm<Term extends string, S extends string> = Term extends `(${infer Body}`
-  ? ExtractGroup<Body, '', S>
-  : Term extends `%${infer Var}`
-    ? ParseVarTerm<Var>
-    : Term extends `${infer Root}.${infer Rest}`
-      ? Root extends keyof R4Resources & string
-        ? ParseSegments<Rest, Root>
-        : ParseSegments<Term, S>
-      : Term extends keyof R4Resources & string
-        ? Term
-        : ParseSegments<Term, S>
-
-/**
- * A `%var` root enters the broad state: the variable's value is unknowable
- * here, and broad is exactly "unknowable" — plain navigation stays
- * `unknown[]`, while a fixed-return call (`%rowIndex.toString()`) keeps its
- * input-independent type. The name must look like a name: a glued operator
- * (`%a = b`) would make the runtime evaluate a comparison, not a variable.
- */
-type ParseVarTerm<Var extends string> = Var extends `${infer Name}.${infer Rest}`
-  ? GluedName<Name> extends true
-    ? 'opaque'
-    : ParseSegments<Rest, string>
-  : GluedName<Var> extends true
-    ? 'opaque'
-    : string
-
-/**
- * Find the `)` closing a group's opening paren: scan `)` by `)`, and the
- * first one whose interior is a complete fragment closes the group. What
- * follows must be nothing or a `.`-chain — anything else (`(A | B) = (C)`)
- * is a glued operator.
- */
-type ExtractGroup<Body extends string, Acc extends string, S extends string> = Body extends `${infer L})${infer R}`
-  ? CompleteFragment<`${Acc}${L}`> extends true
-    ? GroupTail<ParseExpr<`${Acc}${L}`, S>, R>
-    : ExtractGroup<R, `${Acc}${L})`, S>
-  : 'opaque'
-
-/** Continue after a group: `(…)` ends the term, `(…).rest` walks on from the group's state. */
-type GroupTail<G extends string, Tail extends string> = Tail extends ''
-  ? G
-  : Tail extends `.${infer Rest}`
-    ? ParseSegments<Rest, G>
+export type EmptyFhirpathTypeContext = EmptyContextMap
+
+/** A host declaration that the type-level evaluator can use without reading a runtime value. */
+export interface FhirpathTypeDeclaration<
+  Type extends FhirTypeName = FhirTypeName,
+  Collection extends boolean = boolean,
+> {
+  /** One candidate type, or every candidate a value may hold. */
+  type: Type | readonly Type[]
+  /** Omitted means at most one item; true means the value may contain many. */
+  collection?: Collection
+  /** Resource targets when `type` includes Reference. */
+  targets?: FhirTypeName | readonly FhirTypeName[]
+}
+
+export type FhirpathTypeDeclarations = Readonly<Record<string, FhirpathTypeDeclaration>>
+
+/** The static fields of a native, expression-defined, or overloaded custom function. */
+export type FhirpathFunctionDeclaration =
+  | {
+      readonly signature?: {
+        readonly input?: { readonly types?: readonly string[] }
+        readonly args?: readonly string[]
+        readonly result?: { readonly types?: readonly string[]; readonly single?: boolean }
+      }
+      readonly expression?: string | { readonly source: string }
+      readonly criteria?: boolean
+      readonly env?: Readonly<Record<string, unknown>>
+      readonly envTypes?: FhirpathTypeDeclarations
+    }
+  | { readonly overloads: readonly FhirpathFunctionDeclaration[] }
+
+/** Type information supplied by a host around a literal FHIRPath expression. */
+export interface FhirpathTypeContext {
+  env?: FhirpathTypeDeclarations
+  vars?: FhirpathTypeDeclarations
+  /** The same declarations accepted by `EvaluateOptions.functions`. */
+  functions?: Readonly<Record<string, FhirpathFunctionDeclaration>>
+}
+
+/** The inferred result of evaluating a literal FHIRPath expression. */
+export type FhirpathResult<
+  Expression extends string,
+  Context extends FhirpathTypeContext = EmptyFhirpathTypeContext,
+> = FhirpathResultIn<Expression, 'opaque', Context>
+
+/**
+ * The inferred result with an explicit FHIR input type. Non-literal,
+ * malformed, over-budget, or unsupported expressions safely become
+ * `unknown[]`.
+ */
+export type FhirpathResultIn<
+  Expression extends string,
+  Input extends string,
+  Context extends FhirpathTypeContext = EmptyFhirpathTypeContext,
+> = FhirpathResultForContext<Expression, Input, Context>
+
+/** Internal inference entry point for contexts assembled from generic API options. */
+export type FhirpathResultForContext<
+  Expression extends string,
+  Input extends string,
+  Context extends object = EmptyFhirpathTypeContext,
+> = string extends Expression ? unknown[] : InferTypeExpression<Expression, Input, Context>
+
+/** Merge contexts by normalized name. The later context wins, matching per-call runtime options. */
+export type MergeFhirpathTypeContexts<Base extends object, Overlay extends object> = {
+  env: MergeContextMaps<ContextProperty<Base, 'env'>, ContextProperty<Overlay, 'env'>>
+  vars: MergeContextMaps<ContextProperty<Base, 'vars'>, ContextProperty<Overlay, 'vars'>>
+  functions: MergeContextMaps<ContextProperty<Base, 'functions'>, ContextProperty<Overlay, 'functions'>>
+}
+
+type LiteralVarDeclaration<Value> = Value extends string
+  ? string extends Value
+    ? FhirpathTypeDeclaration
+    : FhirpathTypeDeclaration & { readonly __expression: Value }
+  : Value extends { readonly source: infer Source extends string }
+    ? string extends Source
+      ? FhirpathTypeDeclaration
+      : FhirpathTypeDeclaration & { readonly __expression: Source }
+    : FhirpathTypeDeclaration
+
+type LiteralVarDeclarations<Values> =
+  Values extends Readonly<Record<PropertyKey, unknown>>
+    ? { readonly [Name in keyof Values]: LiteralVarDeclaration<Values[Name]> }
+    : EmptyFhirpathTypeContext
+
+type OptionEnvironmentContext<Options> = Options extends { readonly env?: infer Env }
+  ? InferredHostValueDeclarations<Exclude<Env, undefined>, ContextProperty<Options, 'envTypes'>>
+  : NormalizeContextMap<ContextProperty<Options, 'envTypes'>>
+
+/** The inference context retained from one literal engine or per-call options object. */
+export type FhirpathTypeContextOf<Options> = {
+  env: OptionEnvironmentContext<Options>
+  vars: MergeContextMaps<LiteralVarDeclarations<ContextProperty<Options, 'vars'>>, ContextProperty<Options, 'varTypes'>>
+  functions: NormalizeContextMap<ContextProperty<Options, 'functions'>>
+}
+
+type DeclarationElement<Declaration> = Declaration extends { readonly type: infer Type }
+  ? Type extends readonly FhirTypeName[]
+    ? R4TypeOf[Type[number]]
+    : Type extends FhirTypeName
+      ? R4TypeOf[Type]
+      : unknown
+  : unknown
+
+type DeclaredHostValue<Declaration> = Declaration extends { readonly collection: true }
+  ? DeclarationElement<Declaration> | readonly DeclarationElement<Declaration>[] | undefined
+  : DeclarationElement<Declaration> | readonly [] | readonly [DeclarationElement<Declaration>] | undefined
+
+type ConstrainedDeclaredValues<Values, Declarations> =
+  Values extends Readonly<Record<PropertyKey, unknown>>
+    ? {
+        [Name in keyof Values]: LookupNormalizedDeclaration<Declarations, Name> extends infer Declaration
+          ? [Declaration] extends [never]
+            ? Values[Name]
+            : Values[Name] extends DeclaredHostValue<Declaration>
+              ? Values[Name]
+              : never
+          : Values[Name]
+      }
+    : Values
+
+type LookupNormalizedDeclaration<Declarations, Name extends PropertyKey> =
+  BareContextName<Name> extends keyof NormalizeContextMap<Declarations>
+    ? NormalizeContextMap<Declarations>[BareContextName<Name>]
+    : never
+
+/** Cross-check declarations and values when both remain visible in one literal options object. */
+export type CheckedFhirpathOptionValues<Options> = Options extends {
+  readonly env: infer Env
+  readonly envTypes: infer EnvTypes
+}
+  ? { readonly env: ConstrainedDeclaredValues<Env, EnvTypes> }
+  : unknown
+
+/** A model root known from a resource-shaped input; ambiguous and structural inputs stay opaque. */
+export type FhirpathRootOf<Input> = Input extends readonly (infer Item)[]
+  ? FhirpathRootOf<Item>
+  : Input extends { readonly resourceType: infer Root extends FhirTypeName }
+    ? Root
     : 'opaque'
 
-/** The unwrapped result element type for a state; `[…]` keeps unions whole. */
-type ResultOf<S extends string> = [S] extends [keyof R4TypeOf] ? R4TypeOf[S][] : unknown[]
-
-/**
- * The inferred result of evaluating `Expr` against its root resource.
- * `string` (a non-literal expression) and anything outside the subset give
- * `unknown[]`. The context is 'opaque': terms must be resource-rooted,
- * `%var`-rooted, or parenthesized groups of those — a relative term
- * (`id | …`) has no root to resolve against here and degrades.
- */
-export type FhirpathResult<Expr extends string> = FhirpathResultIn<Expr, 'opaque'>
-
-/**
- * The inferred result of evaluating `Expr` with `Input` as the context type —
- * what a DTO's `fhirType` gives its columns, so their paths can stay relative
- * (`clinicalStatus.coding.first().code`). A resource-rooted term still resolves
- * against its own root, and a type name outside the model degrades like any
- * other out-of-subset expression.
- */
-export type FhirpathResultIn<Expr extends string, Input extends string> = string extends Expr
-  ? unknown[]
-  : ResultOf<ParseExpr<Expr, Input>>
-
-/** The expected input resource for `Expr` (`Patient.name` wants a Patient). */
-export type FhirpathInput<Expr extends string> = string extends Expr
+/** The expected input resource for a resource-rooted literal expression. */
+export type FhirpathInput<Expression extends string> = string extends Expression
   ? unknown
-  : Expr extends `${infer Root}.${string}`
+  : Expression extends `${infer Root}.${string}`
     ? Root extends keyof R4Resources
       ? R4Resources[Root]
       : unknown
-    : Expr extends keyof R4Resources
-      ? R4Resources[Expr]
+    : Expression extends keyof R4Resources
+      ? R4Resources[Expression]
       : unknown

package/src/typed/inference-limits.ts

@@ -0,0 +1,9 @@
+/* v8 ignore file -- build-time constants consumed by the type parser and generation scripts */
+/** Maximum tokens the type-level scanner emits for one literal expression. */
+export const INFERENCE_TOKEN_LIMIT = 64
+
+/** Maximum source characters the type-level scanner visits for one literal expression. */
+export const INFERENCE_SOURCE_STEP_LIMIT = 256
+
+export type InferenceTokenLimit = typeof INFERENCE_TOKEN_LIMIT
+export type InferenceSourceStepLimit = typeof INFERENCE_SOURCE_STEP_LIMIT