{"version":3,"sources":["../../src/cognite/adapter.ts","../../src/utils/array.ts","../../src/calculator/exceptions.ts","../../src/calculator/models.ts","../../src/calculator/datapoints-retrieval.ts","../../src/calculator/formula-expression/ast.ts","../../src/calculator/formula-expression/exceptions.ts","../../src/calculator/formula-expression/functions.ts","../../src/calculator/formula-expression/ops.ts","../../src/calculator/formula-expression/compiler.ts","../../src/calculator/formula-expression/evaluator.ts","../../src/calculator/formula-expression/runtime.ts","../../src/calculator/formula-expression/core.ts","../../src/calculator/series-reducer.ts","../../src/calculator/validation.ts","../../src/calculator/calculator.ts"],"names":["items","requestIndex","COMPARE_OPS","cache","z"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { CogniteClient } from \"@cognite/sdk\";\nimport type { CognitePort } from \"./port\";\nimport type {\n  CogniteDatapointDeleteItem,\n  CogniteDatapointInsertItem,\n  CogniteDatapointLatestItem,\n  CogniteDatapointResponse,\n  CogniteDatapointResultItem,\n  CogniteDatapointRetrieveOptions,\n  CogniteFileDownloadUrl,\n  CogniteFileUploadInfo,\n  CogniteFileUploadResult,\n  DataModelId,\n  DataModelRetrieveOptions,\n  InstancesAggregateRequest,\n  InstancesAggregateResponse,\n  InstancesApplyRequest,\n  InstancesApplyResponse,\n  InstancesQueryRequest,\n  InstancesQueryResponse,\n  InstancesSearchRequest,\n  InstancesSearchResponse,\n  ViewDefinition,\n} from \"./types\";\n\nexport function createCogniteAdapter(client: CogniteClient): CognitePort {\n  return new CogniteSdkAdapter(client);\n}\n\nclass CogniteSdkAdapter implements CognitePort {\n  constructor(private readonly client: CogniteClient) {}\n\n  async retrieveDataModels(ids: DataModelId[], options?: DataModelRetrieveOptions) {\n    const response = await this.client.dataModels.retrieve(ids, options);\n    return {\n      items: response.items.map((item) => ({\n        createdTime: item.createdTime,\n        views: (item.views ?? []) as ViewDefinition[],\n      })),\n    };\n  }\n\n  async retrieveViews(\n    ids: Array<{ space: string; externalId: string; version: string }>,\n  ): Promise<{ items: ViewDefinition[] }> {\n    const cleanIds = ids.map(({ space, externalId, version }) => ({ space, externalId, version }));\n    const response = await this.client.views.retrieve(cleanIds);\n    return { items: response.items as ViewDefinition[] };\n  }\n\n  async queryInstances(request: InstancesQueryRequest): Promise<InstancesQueryResponse> {\n    const response = await this.client.instances.query(\n      request as Parameters<CogniteClient[\"instances\"][\"query\"]>[0],\n    );\n    return {\n      items: response.items as unknown as InstancesQueryResponse[\"items\"],\n      nextCursor: response.nextCursor,\n    };\n  }\n\n  async searchInstances(request: InstancesSearchRequest): Promise<InstancesSearchResponse> {\n    const response = await this.client.instances.search(\n      request as Parameters<CogniteClient[\"instances\"][\"search\"]>[0],\n    );\n    return {\n      items: response.items as unknown as InstancesSearchResponse[\"items\"],\n    };\n  }\n\n  async aggregateInstances(\n    request: InstancesAggregateRequest,\n  ): Promise<InstancesAggregateResponse> {\n    const response = await this.client.instances.aggregate(\n      request as Parameters<CogniteClient[\"instances\"][\"aggregate\"]>[0],\n    );\n    return {\n      items: response.items as unknown as InstancesAggregateResponse[\"items\"],\n    };\n  }\n\n  async applyInstances(request: InstancesApplyRequest): Promise<InstancesApplyResponse> {\n    // The Cognite SDK has no combined upsert+delete endpoint: `instances.upsert` writes\n    // items and `instances.delete` removes them, as two separate API calls.\n    const { items, delete: deleteItems = [], replace } = request;\n    const results: InstancesApplyResponse[\"items\"] = [];\n\n    if (deleteItems.length > 0) {\n      const deleteResponse = await this.client.instances.delete(\n        deleteItems as Parameters<CogniteClient[\"instances\"][\"delete\"]>[0],\n      );\n      results.push(\n        ...((deleteResponse as unknown as { items?: InstancesApplyResponse[\"items\"] }).items ?? []),\n      );\n    }\n\n    if (items.length > 0) {\n      const response = await this.client.instances.upsert({\n        items,\n        ...(replace === true ? { replace: true } : {}),\n      } as Parameters<CogniteClient[\"instances\"][\"upsert\"]>[0]);\n      results.push(...(response.items as unknown as InstancesApplyResponse[\"items\"]));\n    }\n\n    return { items: results };\n  }\n\n  async retrieveDatapoints(\n    options: CogniteDatapointRetrieveOptions,\n  ): Promise<{ items: CogniteDatapointResultItem[] }> {\n    const { items, ...rest } = options;\n    const sdkItems = items.map(({ space, externalId, ...itemRest }) => ({\n      ...itemRest,\n      instanceId: { space, externalId },\n    }));\n    const response = await this.client.datapoints.retrieve({\n      ...rest,\n      items: sdkItems,\n    } as Parameters<typeof this.client.datapoints.retrieve>[0]);\n    return { items: (response as unknown as CogniteDatapointResponse[]).map(mapDatapointResult) };\n  }\n\n  async retrieveLatestDatapoints(\n    items: CogniteDatapointLatestItem[],\n    options?: { ignoreUnknownIds?: boolean },\n  ): Promise<{ items: CogniteDatapointResultItem[] }> {\n    const sdkItems = items.map(({ space, externalId, before }) => ({\n      instanceId: { space, externalId },\n      ...(before !== undefined ? { before } : {}),\n    }));\n    const response = await this.client.datapoints.retrieveLatest(\n      sdkItems as Parameters<typeof this.client.datapoints.retrieveLatest>[0],\n      options,\n    );\n    return { items: (response as unknown as CogniteDatapointResponse[]).map(mapDatapointResult) };\n  }\n\n  async insertDatapoints(items: CogniteDatapointInsertItem[]): Promise<void> {\n    const sdkItems = items.map(({ space, externalId, datapoints }) => ({\n      instanceId: { space, externalId },\n      datapoints,\n    }));\n    await this.client.datapoints.insert(\n      sdkItems as Parameters<typeof this.client.datapoints.insert>[0],\n    );\n  }\n\n  async deleteDatapoints(items: CogniteDatapointDeleteItem[]): Promise<void> {\n    const sdkItems = items.map(({ space, externalId, inclusiveBegin, exclusiveEnd }) => ({\n      instanceId: { space, externalId },\n      inclusiveBegin,\n      ...(exclusiveEnd !== undefined ? { exclusiveEnd } : {}),\n    }));\n    await this.client.datapoints.delete(\n      sdkItems as Parameters<typeof this.client.datapoints.delete>[0],\n    );\n  }\n\n  async uploadFile(\n    fileInfo: CogniteFileUploadInfo,\n    content?: unknown,\n  ): Promise<CogniteFileUploadResult> {\n    const { instanceId, ...rest } = fileInfo;\n    const response = await this.client.files.upload(\n      { ...rest, instanceId } as Parameters<typeof this.client.files.upload>[0],\n      content as Parameters<typeof this.client.files.upload>[1],\n      false,\n      content !== undefined,\n    );\n    return mapFileResult(response as SdkFileInfo);\n  }\n\n  async getFileDownloadUrls(\n    ids: Array<{ instanceId: { space: string; externalId: string } }>,\n  ): Promise<CogniteFileDownloadUrl[]> {\n    const response = await this.client.files.getDownloadUrls(\n      ids as Parameters<typeof this.client.files.getDownloadUrls>[0],\n    );\n    return (\n      response as Array<{\n        instanceId?: { space?: string; externalId?: string };\n        downloadUrl: string;\n      }>\n    ).map((item) => ({\n      ...(item.instanceId !== undefined ? { instanceId: item.instanceId } : {}),\n      downloadUrl: item.downloadUrl,\n    }));\n  }\n}\n\ntype SdkFileInfo = {\n  instanceId?: { space?: string; externalId?: string };\n  name: string;\n  uploaded: boolean;\n  uploadedTime?: Date;\n  createdTime: Date;\n  lastUpdatedTime: Date;\n  mimeType?: string;\n  directory?: string;\n  source?: string;\n  uploadUrl?: string;\n};\n\nfunction mapFileResult(item: SdkFileInfo): CogniteFileUploadResult {\n  return {\n    ...(item.instanceId !== undefined ? { instanceId: item.instanceId } : {}),\n    name: item.name,\n    uploaded: item.uploaded,\n    createdTime: item.createdTime,\n    lastUpdatedTime: item.lastUpdatedTime,\n    ...(item.uploadedTime !== undefined ? { uploadedTime: item.uploadedTime } : {}),\n    ...(item.mimeType !== undefined ? { mimeType: item.mimeType } : {}),\n    ...(item.directory !== undefined ? { directory: item.directory } : {}),\n    ...(item.source !== undefined ? { source: item.source } : {}),\n    ...(item.uploadUrl !== undefined ? { uploadUrl: item.uploadUrl } : {}),\n  };\n}\n\nfunction mapDatapointResult(item: CogniteDatapointResponse): CogniteDatapointResultItem {\n  return {\n    ...(item.instanceId?.space !== undefined ? { space: item.instanceId.space } : {}),\n    ...(item.instanceId?.externalId !== undefined\n      ? { externalId: item.instanceId.externalId }\n      : {}),\n    isString: item.isString ?? false,\n    ...(item.unit !== undefined ? { unit: item.unit } : {}),\n    datapoints: item.datapoints ?? [],\n    ...(item.nextCursor !== undefined ? { nextCursor: item.nextCursor } : {}),\n  };\n}\n","export function chunks<TItem>(items: TItem[], size: number): TItem[][] {\n  const result: TItem[][] = [];\n  for (let index = 0; index < items.length; index += size) {\n    result.push(items.slice(index, index + size));\n  }\n  return result;\n}\n","/**\n * Base error for every failure raised by the calculator.\n *\n * {@link FormulaError} and its subclasses derive from this, so a caller that\n * only wants to distinguish \"the calculator failed\" from \"something else\n * failed\" can catch this single type.\n */\nexport class CalculatorError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"CalculatorError\";\n  }\n}\n\n/** Raised when Cognite returns datapoints the retriever cannot use. */\nexport class DatapointsRetrievalError extends CalculatorError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"DatapointsRetrievalError\";\n  }\n}\n","import type { DatapointAggregate, NodeId } from \"../types\";\n\n/**\n * A timestamped numeric value. Used both for the formula result\n * (`datapoints`) and for each aligned input series (`inputs`).\n */\nexport type DataPoint = {\n  timestamp: Date;\n  value: number;\n};\n\n/** How several time series behind one parameter are combined into one. */\nexport type ReducerType = \"min\" | \"max\" | \"sum\" | \"average\";\n\n/** How the time-series parameters of a query are joined on time. */\nexport type AlignmentMode = \"intersect\" | \"strict\";\n\n/** One time series' datapoints, ascending by timestamp once normalized. */\nexport type Series = DataPoint[];\n\n/**\n * A fixed scalar input to a calculation, broadcast across every timestamp in\n * the result. No datapoints are fetched for it.\n */\nexport type ConstantParameter = {\n  type: \"constant\";\n  /** The placeholder name used to reference this parameter in the formula. */\n  alias: string;\n  value: number;\n};\n\n/** Fields shared by every parameter that reads datapoints from Cognite. */\ntype TimeSeriesParameterBase = {\n  /** The placeholder name used to reference this parameter in the formula. */\n  alias: string;\n  /** Optional aggregate to apply; requires `granularity` when set. */\n  aggregateType?: DatapointAggregate;\n  /** Aggregate granularity (e.g. `\"1h\"`); required when `aggregateType` is set. */\n  granularity?: string;\n};\n\n/**\n * A single time series input to a calculation.\n *\n * When `aggregateType` is set the datapoints are fetched as aggregates and a\n * `granularity` is required; otherwise raw datapoints are used.\n */\nexport type TimeSeriesParameter = TimeSeriesParameterBase & {\n  type: \"single_timeseries\";\n  /** The time series instance to read datapoints from. */\n  timeSeries: NodeId;\n};\n\n/**\n * Two or more time series combined into a single input by `reducer`.\n *\n * The series are combined by intersecting on timestamp, so prefer\n * `aggregateType` + `granularity` here: raw datapoints from independent\n * series rarely share exact timestamps.\n */\nexport type MultiTimeSeriesParameter = TimeSeriesParameterBase & {\n  type: \"multi_timeseries\";\n  /** The time series instances to read datapoints from; at least two, unique. */\n  timeSeries: NodeId[];\n  reducer: ReducerType;\n};\n\n/** Any input a formula placeholder can resolve to. */\nexport type CalculatorParameter =\n  | ConstantParameter\n  | TimeSeriesParameter\n  | MultiTimeSeriesParameter;\n\n/** A parameter that reads datapoints from Cognite. */\nexport type AnyTimeSeriesParameter = TimeSeriesParameter | MultiTimeSeriesParameter;\n\n/** A formula plus the parameters its placeholders resolve to. */\nexport type CalculatorQuery = {\n  /** Formula referencing parameters by ``{alias}`` (see `evaluate`). */\n  formula: string;\n  parameters: CalculatorParameter[];\n  /** How time-series parameters are joined on time; defaults to `\"intersect\"`. */\n  alignment?: AlignmentMode;\n};\n\n/**\n * The datapoints produced by evaluating a `CalculatorQuery`, plus the aligned\n * parameter series the formula actually evaluated.\n *\n * `inputs[alias][i]` is the point used to compute `datapoints[i]`. These\n * series are already in memory at evaluation time (after retrieval, any\n * multi-series reduction, timestamp alignment, and constant broadcast), so\n * returning them does not refetch from CDF.\n */\nexport type CalculationResult = {\n  query: CalculatorQuery;\n  datapoints: DataPoint[];\n  /** Aligned series used by the formula, keyed by parameter alias. */\n  inputs: Record<string, DataPoint[]>;\n};\n\nexport function isConstantParameter(\n  parameter: CalculatorParameter,\n): parameter is ConstantParameter {\n  return parameter.type === \"constant\";\n}\n\nexport function isTimeSeriesParameter(\n  parameter: CalculatorParameter,\n): parameter is AnyTimeSeriesParameter {\n  return parameter.type === \"single_timeseries\" || parameter.type === \"multi_timeseries\";\n}\n\n/** The time series a parameter reads, in declaration order. */\nexport function instanceIdsOf(parameter: AnyTimeSeriesParameter): NodeId[] {\n  return parameter.type === \"multi_timeseries\" ? parameter.timeSeries : [parameter.timeSeries];\n}\n","import type {\n  CogniteAggregateDatapoint,\n  CogniteDatapointResultItem,\n  CogniteDatapointRetrieveItem,\n  CogniteDatapointRetrieveOptions,\n  CogniteNumericDatapoint,\n  CognitePort,\n} from \"../cognite\";\nimport type { DatapointAggregate } from \"../types\";\nimport { chunks } from \"../utils/array\";\nimport { DatapointsRetrievalError } from \"./exceptions\";\nimport { type AnyTimeSeriesParameter, instanceIdsOf, type Series } from \"./models\";\n\n// Cognite's datapoints retrieve endpoint accepts at most 100 items per request.\n// Exposed so integration tests can shrink the chunk size without provisioning\n// 100+ series to prove responses stay in request order across chunks.\nexport const retrievalLimits = {\n  maxTimeSeriesPerRequest: 100,\n};\n\ntype BuiltRequests = {\n  requests: CogniteDatapointRetrieveItem[];\n  /**\n   * For each parameter (by index), the index of the request serving each of\n   * its time series, in the order the parameter declares them.\n   */\n  indexMapping: number[][];\n};\n\n/**\n * Retrieves and de-duplicates the datapoints needed by a set of calculator\n * parameters. Time series that are shared (along with granularity, for\n * aggregates) are folded into a single Cognite request; aggregate requests\n * accumulate every aggregate their parameters ask for.\n */\nexport class DatapointsRetriever {\n  constructor(private readonly cognite: CognitePort) {}\n\n  /**\n   * Fetches datapoints for every parameter's time series, unreduced.\n   *\n   * Returns one entry per parameter, each holding one series per time series\n   * it references, in that order. Combining a parameter's series (when it\n   * references more than one) is the caller's responsibility — this class only\n   * retrieves and parses data.\n   */\n  async retrieveDatapoints(\n    parameters: AnyTimeSeriesParameter[],\n    start: Date,\n    end: Date,\n  ): Promise<Series[][]> {\n    const { requests, indexMapping } = this.buildRequests(parameters);\n\n    if (requests.length === 0) {\n      return parameters.map(() => []);\n    }\n\n    const responses = await Promise.all(\n      chunks(requests, retrievalLimits.maxTimeSeriesPerRequest).map(async (items) => {\n        const options: CogniteDatapointRetrieveOptions = { items, start, end };\n        const response = await this.cognite.retrieveDatapoints(options);\n        if (response.items.length !== items.length) {\n          throw new DatapointsRetrievalError(\n            `expected ${items.length} datapoint series from CDF, got ${response.items.length}`,\n          );\n        }\n        return response;\n      }),\n    );\n    const items = responses.flatMap((response) => response.items);\n\n    return parameters.map((parameter, index) =>\n      (indexMapping[index] as number[]).map((requestIndex) => {\n        const item = items[requestIndex];\n        if (item === undefined) {\n          throw new DatapointsRetrievalError(\n            `missing datapoints response for parameter '${parameter.alias}'`,\n          );\n        }\n        return parseDatapoints(item, parameter);\n      }),\n    );\n  }\n\n  private buildRequests(parameters: AnyTimeSeriesParameter[]): BuiltRequests {\n    const rawRequestIndex = new Map<string, number>();\n    const aggregateRequestIndex = new Map<string, number>();\n    const requests: CogniteDatapointRetrieveItem[] = [];\n    const indexMapping: number[][] = [];\n\n    for (const parameter of parameters) {\n      const parameterIndices: number[] = [];\n\n      for (const { space, externalId } of instanceIdsOf(parameter)) {\n        const tsKey = `${space}:${externalId}`;\n\n        if (parameter.aggregateType === undefined) {\n          let requestIndex = rawRequestIndex.get(tsKey);\n          if (requestIndex === undefined) {\n            requestIndex = requests.length;\n            rawRequestIndex.set(tsKey, requestIndex);\n            requests.push({ space, externalId });\n          }\n          parameterIndices.push(requestIndex);\n          continue;\n        }\n\n        const granularity = requireGranularity(parameter);\n        const aggregateKey = `${tsKey}|${granularity}`;\n        let requestIndex = aggregateRequestIndex.get(aggregateKey);\n        if (requestIndex === undefined) {\n          requestIndex = requests.length;\n          aggregateRequestIndex.set(aggregateKey, requestIndex);\n          requests.push({\n            space,\n            externalId,\n            aggregates: [parameter.aggregateType],\n            granularity,\n          });\n        } else {\n          const entry = requests[requestIndex] as CogniteDatapointRetrieveItem;\n          const aggregates = entry.aggregates as DatapointAggregate[];\n          if (!aggregates.includes(parameter.aggregateType)) {\n            aggregates.push(parameter.aggregateType);\n          }\n        }\n        parameterIndices.push(requestIndex);\n      }\n\n      indexMapping.push(parameterIndices);\n    }\n\n    return { requests, indexMapping };\n  }\n}\n\n/**\n * Returns the granularity that `aggregateType` needs.\n *\n * `validateCalculatorQuery` already rejects an aggregate without a\n * granularity, so this only fires for a parameter that skipped validation. It\n * also narrows `string | undefined` down to `string`.\n */\nfunction requireGranularity(parameter: AnyTimeSeriesParameter): string {\n  if (parameter.granularity === undefined) {\n    throw new DatapointsRetrievalError(\n      `Missing granularity for '${parameter.alias}' with aggregate '${parameter.aggregateType}'`,\n    );\n  }\n  return parameter.granularity;\n}\n\nfunction parseDatapoints(\n  item: CogniteDatapointResultItem,\n  parameter: AnyTimeSeriesParameter,\n): Series {\n  if (item.isString) {\n    throw new DatapointsRetrievalError(\"expected numeric datapoints, got string\");\n  }\n\n  const result: Series = [];\n  for (const datapoint of item.datapoints) {\n    const value = readValue(datapoint, parameter.aggregateType);\n    if (value === undefined || value === null) {\n      continue;\n    }\n    result.push({ timestamp: datapoint.timestamp, value });\n  }\n  return result;\n}\n\nfunction readValue(\n  datapoint: CogniteNumericDatapoint,\n  aggregateType: DatapointAggregate | undefined,\n): number | undefined {\n  if (aggregateType === undefined) {\n    return (datapoint as { value?: number }).value;\n  }\n  return (datapoint as CogniteAggregateDatapoint)[aggregateType];\n}\n","/** Binary arithmetic operators supported by the formula grammar. */\nexport type BinaryOp = \"add\" | \"sub\" | \"mul\" | \"div\" | \"pow\" | \"mod\";\n\n/** Unary arithmetic operators supported by the formula grammar. */\nexport type UnaryOp = \"pos\" | \"neg\";\n\n/** Comparison operators supported by the formula grammar. */\nexport type CompareOp = \"eq\" | \"ne\" | \"lt\" | \"le\" | \"gt\" | \"ge\";\n\n/** Boolean operators supported by the formula grammar. */\nexport type BoolOpKind = \"and\" | \"or\";\n\nexport type NameNode = { readonly kind: \"name\"; readonly id: string };\nexport type ConstantNode = { readonly kind: \"constant\"; readonly value: number };\nexport type BinOpNode = {\n  readonly kind: \"binop\";\n  readonly op: BinaryOp;\n  readonly left: ExprNode;\n  readonly right: ExprNode;\n};\nexport type UnaryOpNode = {\n  readonly kind: \"unaryop\";\n  readonly op: UnaryOp;\n  readonly operand: ExprNode;\n};\nexport type CompareNode = {\n  readonly kind: \"compare\";\n  readonly left: ExprNode;\n  readonly ops: readonly CompareOp[];\n  readonly comparators: readonly ExprNode[];\n};\nexport type BoolOpNode = {\n  readonly kind: \"boolop\";\n  readonly op: BoolOpKind;\n  readonly values: readonly ExprNode[];\n};\nexport type IfExpNode = {\n  readonly kind: \"ifexp\";\n  readonly test: ExprNode;\n  readonly body: ExprNode;\n  readonly orelse: ExprNode;\n};\nexport type CallNode = {\n  readonly kind: \"call\";\n  readonly name: string;\n  readonly args: readonly ExprNode[];\n};\n\n/** Any node of a compiled formula expression tree. */\nexport type ExprNode =\n  | NameNode\n  | ConstantNode\n  | BinOpNode\n  | UnaryOpNode\n  | CompareNode\n  | BoolOpNode\n  | IfExpNode\n  | CallNode;\n\n/** Nodes that make an expression require element-by-element evaluation. */\nexport type ConditionalNode = CompareNode | BoolOpNode | IfExpNode;\n\nexport function isConditionalNode(node: ExprNode): node is ConditionalNode {\n  return node.kind === \"compare\" || node.kind === \"boolop\" || node.kind === \"ifexp\";\n}\n\n/** Walk an expression tree in pre-order. */\nexport function walkExpr(node: ExprNode, visit: (node: ExprNode) => void): void {\n  visit(node);\n  switch (node.kind) {\n    case \"binop\":\n      walkExpr(node.left, visit);\n      walkExpr(node.right, visit);\n      break;\n    case \"unaryop\":\n      walkExpr(node.operand, visit);\n      break;\n    case \"compare\":\n      walkExpr(node.left, visit);\n      for (const comparator of node.comparators) {\n        walkExpr(comparator, visit);\n      }\n      break;\n    case \"boolop\":\n      for (const value of node.values) {\n        walkExpr(value, visit);\n      }\n      break;\n    case \"ifexp\":\n      walkExpr(node.test, visit);\n      walkExpr(node.body, visit);\n      walkExpr(node.orelse, visit);\n      break;\n    case \"call\":\n      for (const arg of node.args) {\n        walkExpr(arg, visit);\n      }\n      break;\n    default:\n      break;\n  }\n}\n\n/** Whether any compare / boolean / ``if`` node is present (including under calls). */\nexport function treeHasConditional(tree: ExprNode): boolean {\n  let found = false;\n  walkExpr(tree, (node) => {\n    if (isConditionalNode(node)) {\n      found = true;\n    }\n  });\n  return found;\n}\n","/**\n * Structural formula problems (bad syntax, unknown identifiers, missing\n * parameters, mismatched lengths or timestamps, non-numeric values) are\n * reported as a subclass of {@link FormulaError}.\n *\n * Value-dependent arithmetic failures (division/modulo by zero, overflowing\n * exponentiation) are intentionally *not* {@link FormulaError}s: they extend\n * {@link ArithmeticError} instead.\n */\n\nimport { CalculatorError } from \"../exceptions\";\n\n/** Base error for every structural formula problem. */\nexport class FormulaError extends CalculatorError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"FormulaError\";\n  }\n}\n\n/** Raised when formula syntax or operations are not supported. */\nexport class InvalidFormulaError extends FormulaError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"InvalidFormulaError\";\n  }\n}\n\n/** Raised when a formula references parameters that were not provided. */\nexport class MissingParameterError extends FormulaError {\n  readonly missing: readonly string[];\n\n  constructor(missing: string[]) {\n    super(`missing formula parameter(s): ${missing.join(\", \")}`);\n    this.name = \"MissingParameterError\";\n    this.missing = [...missing];\n  }\n}\n\n/** Raised when a parameter value is not a valid numeric sequence. */\nexport class ParameterError extends FormulaError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ParameterError\";\n  }\n}\n\n/** Raised when referenced parameters do not all share the same length. */\nexport class ParameterLengthError extends ParameterError {\n  readonly lengths: Readonly<Record<string, number>>;\n\n  constructor(lengths: Record<string, number>) {\n    const detail = Object.entries(lengths)\n      .map(([name, length]) => `'${name}' has ${length}`)\n      .join(\", \");\n    super(`parameter length mismatch: ${detail}`);\n    this.name = \"ParameterLengthError\";\n    this.lengths = { ...lengths };\n  }\n}\n\n/** Raised when a query has only constants and so has no time axis. */\nexport class MissingTimeAxisError extends ParameterError {\n  readonly aliases: readonly string[];\n\n  constructor(aliases: string[]) {\n    super(\n      \"query has no time-series parameter to define a time axis; \" +\n        `only constant parameter(s): ${aliases.join(\", \")}`,\n    );\n    this.name = \"MissingTimeAxisError\";\n    this.aliases = [...aliases];\n  }\n}\n\n/** Raised when time-series parameters do not share the same timestamps. */\nexport class ParameterTimestampError extends ParameterError {\n  readonly aliases: readonly string[];\n\n  constructor(aliases: string[]) {\n    super(`parameter timestamp mismatch: ${aliases.join(\", \")} do not share the same timestamps`);\n    this.name = \"ParameterTimestampError\";\n    this.aliases = [...aliases];\n  }\n}\n\n/**\n * Base for value-dependent arithmetic failures. Deliberately separate from\n * {@link FormulaError} because these depend on the data, not the formula.\n */\nexport class ArithmeticError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ArithmeticError\";\n  }\n}\n\n/** Raised when a division or modulo has a zero divisor. */\nexport class ZeroDivisionError extends ArithmeticError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ZeroDivisionError\";\n  }\n}\n\n/** Raised when an exponentiation overflows the floating-point range. */\nexport class OverflowError extends ArithmeticError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"OverflowError\";\n  }\n}\n","/** Simple moving average over the last ``window`` points (partial prefix).\n *\n * At index ``i`` the result is the mean of ``values[max(0, i-window+1):i+1]``.\n * The output is always the same length as ``values``. ``window`` is assumed\n * to be a positive integer (enforced at compile time).\n */\nexport function rollingAverage(values: readonly number[], window: number): number[] {\n  const length = values.length;\n  if (length === 0) {\n    return [];\n  }\n\n  const cumulative = new Array<number>(length + 1);\n  cumulative[0] = 0;\n  for (let index = 0; index < length; index += 1) {\n    cumulative[index + 1] = (cumulative[index] as number) + (values[index] as number);\n  }\n\n  const result = new Array<number>(length);\n  for (let index = 0; index < length; index += 1) {\n    const start = Math.max(0, index - window + 1);\n    result[index] =\n      ((cumulative[index + 1] as number) - (cumulative[start] as number)) / (index - start + 1);\n  }\n  return result;\n}\n\nexport type FunctionSpec = {\n  readonly arity: number;\n  readonly windowArg: number | null;\n  readonly apply: (values: readonly number[], window: number) => number[];\n};\n\nexport const ALLOWED_FUNCTIONS: Readonly<Record<string, FunctionSpec>> = {\n  rolling_average: {\n    arity: 2,\n    windowArg: 1,\n    apply: rollingAverage,\n  },\n};\n","import type { BinaryOp, UnaryOp } from \"./ast\";\nimport { OverflowError, ZeroDivisionError } from \"./exceptions\";\n\nexport const UNARY_OPS: Record<UnaryOp, (value: number) => number> = {\n  pos: (value) => value,\n  neg: (value) => -value,\n};\n\nexport const BINARY_OPS: Record<BinaryOp, (left: number, right: number) => number> = {\n  add: (left, right) => left + right,\n  sub: (left, right) => left - right,\n  mul: (left, right) => left * right,\n  div: (left, right) => {\n    if (right === 0) {\n      throw new ZeroDivisionError(\"float division by zero\");\n    }\n    return left / right;\n  },\n  mod: signedMod,\n  pow: safePow,\n};\n\n/** Remainder with the sign of the divisor, unlike JavaScript's ``%``. */\nfunction signedMod(left: number, right: number): number {\n  if (right === 0) {\n    throw new ZeroDivisionError(\"float modulo\");\n  }\n  return left - Math.floor(left / right) * right;\n}\n\n/**\n * Exponentiate in float space. Raising ``0`` to a negative power and\n * overflowing results are arithmetic errors rather than silent infinities.\n */\nfunction safePow(base: number, exponent: number): number {\n  if (base === 0 && exponent < 0) {\n    throw new ZeroDivisionError(\"0.0 cannot be raised to a negative power\");\n  }\n  const result = base ** exponent;\n  if (!Number.isFinite(result) && Number.isFinite(base) && Number.isFinite(exponent)) {\n    throw new OverflowError(\"(34, 'Numerical result out of range')\");\n  }\n  return result;\n}\n","import type { BinaryOp, BoolOpKind, CallNode, CompareOp, ExprNode, UnaryOp } from \"./ast\";\nimport { treeHasConditional, walkExpr } from \"./ast\";\nimport { ArithmeticError, InvalidFormulaError } from \"./exceptions\";\nimport { ALLOWED_FUNCTIONS } from \"./functions\";\nimport { BINARY_OPS, UNARY_OPS } from \"./ops\";\n\nconst PLACEHOLDER_RE = /\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g;\nconst UNRESOLVED_BRACE_RE = /[{}]/;\nconst SAFE_NAME_PREFIX = \"__formula_expression_param_\";\nconst CACHE_MAX_SIZE = 1024;\n\n/** A parsed, validated formula ready to be evaluated over parameter series. */\nexport type CompiledFormula = {\n  /** The whitespace-normalized formula text. */\n  readonly raw: string;\n  /** The formula text after placeholders were replaced with safe identifiers. */\n  readonly expression: string;\n  /** The validated expression tree. */\n  readonly tree: ExprNode;\n  /** Original parameter names in first-appearance order. */\n  readonly variables: readonly string[];\n  /** Mapping of original parameter name to its safe identifier. */\n  readonly nameMap: ReadonlyMap<string, string>;\n  /** Whether the formula needs element-by-element (short-circuiting) evaluation. */\n  readonly hasConditional: boolean;\n};\n\nconst cache = new Map<string, CompiledFormula>();\n\n/**\n * Normalize the formula text, then compile it (memoized by normalized text).\n * Use {@link clearCache} to inspect or reset the compilation cache.\n */\nexport function compileFormula(formula: string): CompiledFormula {\n  const normalized = normalizeFormulaText(formula);\n\n  const cached = cache.get(normalized);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  const compiled = compileNormalized(normalized);\n\n  if (cache.size >= CACHE_MAX_SIZE) {\n    const oldest = cache.keys().next().value;\n    if (oldest !== undefined) {\n      cache.delete(oldest);\n    }\n  }\n  cache.set(normalized, compiled);\n  return compiled;\n}\n\n/** Clear the memoized formula compilation cache. */\nexport function clearCache(): void {\n  cache.clear();\n}\n\nfunction normalizeFormulaText(formula: string): string {\n  if (typeof formula !== \"string\") {\n    throw new TypeError(\"formula must be a string\");\n  }\n  const trimmed = formula.trim();\n  if (trimmed === \"\") {\n    return \"\";\n  }\n  return trimmed.split(/\\s+/).join(\" \");\n}\n\nfunction compileNormalized(raw: string): CompiledFormula {\n  if (raw === \"\") {\n    throw new InvalidFormulaError(\"formula must not be empty\");\n  }\n\n  const variables: string[] = [];\n  const nameMap = new Map<string, string>();\n  const expression = replacePlaceholders(raw, variables, nameMap);\n\n  if (variables.length === 0) {\n    throw new InvalidFormulaError(\"formula must reference at least one parameter\");\n  }\n\n  if (UNRESOLVED_BRACE_RE.test(expression)) {\n    throw new InvalidFormulaError(\"formula contains invalid placeholder syntax\");\n  }\n\n  const parsed = parse(expression);\n  validateTree(parsed, new Set(nameMap.values()));\n  const tree = foldConstants(parsed);\n  validateFoldedFunctionArgs(tree);\n  const hasConditional = treeHasConditional(tree);\n\n  return { raw, expression, tree, variables, nameMap, hasConditional };\n}\n\nfunction replacePlaceholders(\n  formula: string,\n  variables: string[],\n  nameMap: Map<string, string>,\n): string {\n  return formula.replace(PLACEHOLDER_RE, (_match, name: string) => {\n    let safe = nameMap.get(name);\n    if (safe === undefined) {\n      safe = `${SAFE_NAME_PREFIX}${nameMap.size}`;\n      nameMap.set(name, safe);\n      variables.push(name);\n    }\n    return safe;\n  });\n}\n\nfunction validateTree(tree: ExprNode, allowedNames: ReadonlySet<string>): void {\n  walkExpr(tree, (node) => {\n    if (node.kind === \"name\" && !allowedNames.has(node.id)) {\n      throw new InvalidFormulaError(`unknown formula identifier: ${node.id}`);\n    }\n  });\n}\n\nfunction validateCallShape(node: CallNode, hasKeywords: boolean, hasStarred: boolean): void {\n  const spec = ALLOWED_FUNCTIONS[node.name];\n  if (spec === undefined) {\n    if (node.name.startsWith(SAFE_NAME_PREFIX)) {\n      throw new InvalidFormulaError(\"unsupported formula element: Call\");\n    }\n    throw new InvalidFormulaError(`unknown formula function: ${node.name}`);\n  }\n\n  if (hasKeywords) {\n    throw new InvalidFormulaError(`${node.name}() does not accept keyword arguments`);\n  }\n  if (hasStarred) {\n    throw new InvalidFormulaError(`${node.name}() does not accept starred arguments`);\n  }\n  if (node.args.length !== spec.arity) {\n    throw new InvalidFormulaError(\n      `${node.name}() takes ${spec.arity} arguments, got ${node.args.length}`,\n    );\n  }\n}\n\nfunction validateFoldedFunctionArgs(tree: ExprNode): void {\n  walkExpr(tree, (node) => {\n    if (node.kind !== \"call\") {\n      return;\n    }\n    const spec = ALLOWED_FUNCTIONS[node.name];\n    if (spec === undefined || spec.windowArg === null) {\n      return;\n    }\n    const windowNode = node.args[spec.windowArg];\n    if (windowNode === undefined || windowNode.kind !== \"constant\") {\n      throw new InvalidFormulaError(`${node.name}() window must be a numeric constant`);\n    }\n    if (toPositiveIntWindow(windowNode.value) === null) {\n      throw new InvalidFormulaError(`${node.name}() window must be a positive integer`);\n    }\n  });\n}\n\n/**\n * Accept exact integers and values that only fail ``Number.isInteger``\n * because of floating-point noise from folding (e.g. ``8.3 - 5.3``).\n */\nfunction toPositiveIntWindow(value: number): number | null {\n  if (!Number.isFinite(value) || value < 1) {\n    return null;\n  }\n  if (Number.isInteger(value)) {\n    return value;\n  }\n  const rounded = Math.round(value);\n  if (rounded < 1 || !Number.isSafeInteger(rounded)) {\n    return null;\n  }\n  const tolerance = Number.EPSILON * Math.max(1, Math.abs(value)) * 16;\n  if (Math.abs(value - rounded) <= tolerance) {\n    return rounded;\n  }\n  return null;\n}\n\n/**\n * Collapse constant-only subtrees to a single constant at compile time.\n *\n * A fold that raises (e.g. division by zero) is skipped so the original\n * runtime error semantics are preserved. Conditional/comparison nodes are\n * never collapsed to a single constant: only their constant-only\n * sub-expressions are folded.\n */\nfunction foldConstants(node: ExprNode): ExprNode {\n  switch (node.kind) {\n    case \"binop\": {\n      const left = foldConstants(node.left);\n      const right = foldConstants(node.right);\n      if (left.kind === \"constant\" && right.kind === \"constant\") {\n        try {\n          return { kind: \"constant\", value: BINARY_OPS[node.op](left.value, right.value) };\n        } catch (error) {\n          if (error instanceof ArithmeticError) {\n            return { kind: \"binop\", op: node.op, left, right };\n          }\n          throw error;\n        }\n      }\n      return { kind: \"binop\", op: node.op, left, right };\n    }\n    case \"unaryop\": {\n      const operand = foldConstants(node.operand);\n      if (operand.kind === \"constant\") {\n        return { kind: \"constant\", value: UNARY_OPS[node.op](operand.value) };\n      }\n      return { kind: \"unaryop\", op: node.op, operand };\n    }\n    case \"ifexp\":\n      return {\n        kind: \"ifexp\",\n        test: foldConstants(node.test),\n        body: foldConstants(node.body),\n        orelse: foldConstants(node.orelse),\n      };\n    case \"compare\":\n      return {\n        kind: \"compare\",\n        left: foldConstants(node.left),\n        ops: node.ops,\n        comparators: node.comparators.map(foldConstants),\n      };\n    case \"boolop\":\n      return {\n        kind: \"boolop\",\n        op: node.op,\n        values: node.values.map(foldConstants),\n      };\n    case \"call\": {\n      const args = node.args.map(foldConstants);\n      return { kind: \"call\", name: node.name, args: foldCallWindowArg(node.name, args) };\n    }\n    default:\n      return node;\n  }\n}\n\nfunction foldCallWindowArg(name: string, args: readonly ExprNode[]): readonly ExprNode[] {\n  const spec = ALLOWED_FUNCTIONS[name];\n  if (spec === undefined || spec.windowArg === null) {\n    return args;\n  }\n  const windowNode = args[spec.windowArg];\n  if (windowNode === undefined || windowNode.kind !== \"constant\") {\n    return args;\n  }\n  const integer = toPositiveIntWindow(windowNode.value);\n  if (integer === null || integer === windowNode.value) {\n    return args;\n  }\n  return args.map((arg, index) =>\n    index === spec.windowArg ? { kind: \"constant\", value: integer } : arg,\n  );\n}\n\n// ─── Tokenizer ─────────────────────────────────────────────────────────────\n\ntype Token =\n  | { readonly type: \"number\"; readonly value: number }\n  | { readonly type: \"name\"; readonly value: string }\n  | { readonly type: \"op\"; readonly value: string };\n\nconst NUMBER_RE = /(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?/y;\nconst IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/y;\nconst TWO_CHAR_OPS = new Set([\"**\", \"==\", \"!=\", \"<=\", \">=\"]);\nconst ONE_CHAR_OPS = new Set([\"+\", \"-\", \"*\", \"/\", \"%\", \"(\", \")\", \"<\", \">\", \",\", \"=\"]);\n\nfunction tokenize(expression: string): Token[] {\n  const tokens: Token[] = [];\n  let index = 0;\n\n  while (index < expression.length) {\n    const char = expression[index];\n\n    if (char === \" \") {\n      index += 1;\n      continue;\n    }\n\n    if (isDigit(char) || (char === \".\" && isDigit(expression[index + 1]))) {\n      NUMBER_RE.lastIndex = index;\n      const match = NUMBER_RE.exec(expression);\n      if (match === null) {\n        throw new InvalidFormulaError(\"invalid formula syntax: malformed number\");\n      }\n      tokens.push({ type: \"number\", value: Number(match[0]) });\n      index = NUMBER_RE.lastIndex;\n      continue;\n    }\n\n    if (isIdentStart(char)) {\n      IDENT_RE.lastIndex = index;\n      const match = IDENT_RE.exec(expression);\n      // isIdentStart guarantees a match here.\n      const value = (match as RegExpExecArray)[0];\n      tokens.push({ type: \"name\", value });\n      index = IDENT_RE.lastIndex;\n      continue;\n    }\n\n    const twoChar = expression.slice(index, index + 2);\n    if (TWO_CHAR_OPS.has(twoChar)) {\n      tokens.push({ type: \"op\", value: twoChar });\n      index += 2;\n      continue;\n    }\n\n    if (char !== undefined && ONE_CHAR_OPS.has(char)) {\n      tokens.push({ type: \"op\", value: char });\n      index += 1;\n      continue;\n    }\n\n    throw new InvalidFormulaError(`invalid formula syntax: unexpected character '${char}'`);\n  }\n\n  return tokens;\n}\n\nfunction isDigit(char: string | undefined): boolean {\n  return char !== undefined && char >= \"0\" && char <= \"9\";\n}\n\nfunction isIdentStart(char: string | undefined): boolean {\n  if (char === undefined) {\n    return false;\n  }\n  return char === \"_\" || (char >= \"a\" && char <= \"z\") || (char >= \"A\" && char <= \"Z\");\n}\n\n// ─── Parser ────────────────────────────────────────────────────────────────\n\nconst KEYWORDS = new Set([\"and\", \"or\", \"if\", \"else\"]);\nconst CONSTANT_KEYWORDS = new Set([\"True\", \"False\", \"None\"]);\n\nconst COMPARE_OPS: Record<string, CompareOp> = {\n  \"==\": \"eq\",\n  \"!=\": \"ne\",\n  \"<\": \"lt\",\n  \"<=\": \"le\",\n  \">\": \"gt\",\n  \">=\": \"ge\",\n};\n\n/** Parse a placeholder-substituted expression into a validated tree. */\nfunction parse(expression: string): ExprNode {\n  const tokens = tokenize(expression);\n  const parser = new Parser(tokens);\n  const tree = parser.parseExpression();\n  parser.expectEnd();\n  return tree;\n}\n\nclass Parser {\n  private position = 0;\n\n  constructor(private readonly tokens: readonly Token[]) {}\n\n  parseExpression(): ExprNode {\n    return this.parseConditional();\n  }\n\n  expectEnd(): void {\n    if (this.position < this.tokens.length) {\n      throw new InvalidFormulaError(\"invalid formula syntax: unexpected trailing tokens\");\n    }\n  }\n\n  private parseConditional(): ExprNode {\n    const body = this.parseOr();\n    if (this.matchKeyword(\"if\")) {\n      const test = this.parseOr();\n      this.expectKeyword(\"else\");\n      const orelse = this.parseConditional();\n      return { kind: \"ifexp\", test, body, orelse };\n    }\n    return body;\n  }\n\n  private parseOr(): ExprNode {\n    const values = [this.parseAnd()];\n    while (this.matchKeyword(\"or\")) {\n      values.push(this.parseAnd());\n    }\n    return values.length === 1 ? (values[0] as ExprNode) : { kind: \"boolop\", op: \"or\", values };\n  }\n\n  private parseAnd(): ExprNode {\n    const values = [this.parseComparison()];\n    while (this.matchKeyword(\"and\")) {\n      values.push(this.parseComparison());\n    }\n    const op: BoolOpKind = \"and\";\n    return values.length === 1 ? (values[0] as ExprNode) : { kind: \"boolop\", op, values };\n  }\n\n  private parseComparison(): ExprNode {\n    const left = this.parseAdditive();\n    const ops: CompareOp[] = [];\n    const comparators: ExprNode[] = [];\n    while (true) {\n      const op = this.peekCompareOp();\n      if (op === undefined) {\n        break;\n      }\n      this.position += 1;\n      ops.push(op);\n      comparators.push(this.parseAdditive());\n    }\n    return ops.length === 0 ? left : { kind: \"compare\", left, ops, comparators };\n  }\n\n  private parseAdditive(): ExprNode {\n    let node = this.parseMultiplicative();\n    while (true) {\n      const op = this.peekOp();\n      if (op === \"+\" || op === \"-\") {\n        this.position += 1;\n        const right = this.parseMultiplicative();\n        node = { kind: \"binop\", op: op === \"+\" ? \"add\" : \"sub\", left: node, right };\n        continue;\n      }\n      break;\n    }\n    return node;\n  }\n\n  private parseMultiplicative(): ExprNode {\n    let node = this.parseUnary();\n    while (true) {\n      const op = this.peekOp();\n      if (op === \"*\" || op === \"/\" || op === \"%\") {\n        this.position += 1;\n        const right = this.parseUnary();\n        const kind: BinaryOp = op === \"*\" ? \"mul\" : op === \"/\" ? \"div\" : \"mod\";\n        node = { kind: \"binop\", op: kind, left: node, right };\n        continue;\n      }\n      break;\n    }\n    return node;\n  }\n\n  private parseUnary(): ExprNode {\n    const op = this.peekOp();\n    if (op === \"+\" || op === \"-\") {\n      this.position += 1;\n      const operand = this.parseUnary();\n      const kind: UnaryOp = op === \"+\" ? \"pos\" : \"neg\";\n      return { kind: \"unaryop\", op: kind, operand };\n    }\n    return this.parsePower();\n  }\n\n  private parsePower(): ExprNode {\n    const base = this.parseAtom();\n    if (this.peekOp() === \"**\") {\n      this.position += 1;\n      // Right operand is a unary expression so ``2 ** -1`` is accepted and\n      // ``**`` remains right-associative.\n      const exponent = this.parseUnary();\n      return { kind: \"binop\", op: \"pow\", left: base, right: exponent };\n    }\n    return base;\n  }\n\n  private parseAtom(): ExprNode {\n    const token = this.tokens[this.position];\n    if (token === undefined) {\n      throw new InvalidFormulaError(\"invalid formula syntax: unexpected end of expression\");\n    }\n\n    if (token.type === \"number\") {\n      this.position += 1;\n      return { kind: \"constant\", value: token.value };\n    }\n\n    if (token.type === \"name\") {\n      if (CONSTANT_KEYWORDS.has(token.value)) {\n        throw new InvalidFormulaError(\"only numeric constants are supported\");\n      }\n      if (KEYWORDS.has(token.value)) {\n        throw new InvalidFormulaError(\n          `invalid formula syntax: unexpected keyword '${token.value}'`,\n        );\n      }\n      this.position += 1;\n      if (this.peekOp() === \"(\") {\n        return this.parseCall(token.value);\n      }\n      return { kind: \"name\", id: token.value };\n    }\n\n    if (token.value === \"(\") {\n      this.position += 1;\n      const inner = this.parseExpression();\n      this.expectOp(\")\");\n      return inner;\n    }\n\n    throw new InvalidFormulaError(`invalid formula syntax: unexpected token '${token.value}'`);\n  }\n\n  private parseCall(name: string): CallNode {\n    this.expectOp(\"(\");\n    const args: ExprNode[] = [];\n    let hasKeywords = false;\n    let hasStarred = false;\n\n    if (this.peekOp() !== \")\") {\n      while (true) {\n        if (this.peekOp() === \"*\") {\n          hasStarred = true;\n          this.position += 1;\n          this.parseExpression();\n        } else if (this.isKeywordArg()) {\n          hasKeywords = true;\n          this.position += 1;\n          this.expectOp(\"=\");\n          this.parseExpression();\n        } else {\n          args.push(this.parseExpression());\n        }\n\n        if (this.peekOp() !== \",\") {\n          break;\n        }\n        this.position += 1;\n        if (this.peekOp() === \")\") {\n          break;\n        }\n      }\n    }\n\n    this.expectOp(\")\");\n    const node: CallNode = { kind: \"call\", name, args };\n    validateCallShape(node, hasKeywords, hasStarred);\n    return node;\n  }\n\n  private isKeywordArg(): boolean {\n    const token = this.tokens[this.position];\n    const next = this.tokens[this.position + 1];\n    return (\n      token !== undefined &&\n      token.type === \"name\" &&\n      next !== undefined &&\n      next.type === \"op\" &&\n      next.value === \"=\"\n    );\n  }\n\n  private peekOp(): string | undefined {\n    const token = this.tokens[this.position];\n    return token !== undefined && token.type === \"op\" ? token.value : undefined;\n  }\n\n  private peekCompareOp(): CompareOp | undefined {\n    const op = this.peekOp();\n    return op !== undefined ? COMPARE_OPS[op] : undefined;\n  }\n\n  private matchKeyword(keyword: string): boolean {\n    const token = this.tokens[this.position];\n    if (token !== undefined && token.type === \"name\" && token.value === keyword) {\n      this.position += 1;\n      return true;\n    }\n    return false;\n  }\n\n  private expectKeyword(keyword: string): void {\n    if (!this.matchKeyword(keyword)) {\n      throw new InvalidFormulaError(`invalid formula syntax: expected '${keyword}'`);\n    }\n  }\n\n  private expectOp(op: string): void {\n    if (this.peekOp() !== op) {\n      throw new InvalidFormulaError(`invalid formula syntax: expected '${op}'`);\n    }\n    this.position += 1;\n  }\n}\n","import type { CallNode, CompareOp, ExprNode } from \"./ast\";\nimport { ALLOWED_FUNCTIONS, type FunctionSpec } from \"./functions\";\nimport { BINARY_OPS, UNARY_OPS } from \"./ops\";\n\n/** Environment mapping safe identifiers to their aligned numeric series. */\nexport type Environment = Record<string, readonly number[]>;\n\n/**\n * A value is either a scalar (broadcast across the whole series) or an\n * already-materialized per-element sequence. Keeping constants as scalars\n * avoids allocating length-N arrays for them and skips the element-wise zip\n * whenever one side of an operation is constant.\n */\ntype Value = number | readonly number[];\n\n/**\n * Per-call memo of series-argument values at indexes a selected window has\n * already needed. Indexes that are never in a selected window stay unevaluated.\n */\ntype CallArgCache = WeakMap<CallNode, Map<number, number>>;\n\nconst COMPARE_OPS: Record<CompareOp, (left: number, right: number) => boolean> = {\n  eq: (left, right) => left === right,\n  ne: (left, right) => left !== right,\n  lt: (left, right) => left < right,\n  le: (left, right) => left <= right,\n  gt: (left, right) => left > right,\n  ge: (left, right) => left >= right,\n};\n\n/** Formula truthiness for floats: only exactly ``0`` is falsy (``NaN`` is truthy). */\nfunction isTruthy(value: number): boolean {\n  return value !== 0;\n}\n\nexport function evaluateTree(\n  tree: ExprNode,\n  environment: Environment,\n  length: number,\n  hasConditional: boolean,\n): number[] {\n  if (hasConditional) {\n    // ``if``/``else`` branches (and their guards) must only run for the\n    // elements that select them, so evaluate index-by-index.\n    const cache: CallArgCache = new WeakMap();\n    const result: number[] = new Array(length);\n    for (let index = 0; index < length; index += 1) {\n      result[index] = evaluateNodeAt(tree, environment, index, cache);\n    }\n    return result;\n  }\n\n  const value = evaluateNode(tree, environment);\n  if (Array.isArray(value)) {\n    return value as number[];\n  }\n  // The compiler guarantees at least one parameter, so a scalar result only\n  // happens for degenerate trees; broadcast it to the series length.\n  return new Array(length).fill(value as number);\n}\n\nfunction evaluateNode(node: ExprNode, environment: Environment): Value {\n  switch (node.kind) {\n    case \"name\": {\n      const series = environment[node.id];\n      // The runtime guarantees every referenced name is present.\n      return series as readonly number[];\n    }\n    case \"constant\":\n      return node.value;\n    case \"binop\": {\n      const left = evaluateNode(node.left, environment);\n      const right = evaluateNode(node.right, environment);\n      return applyBinary(BINARY_OPS[node.op], left, right);\n    }\n    case \"unaryop\": {\n      const operand = evaluateNode(node.operand, environment);\n      const op = UNARY_OPS[node.op];\n      return Array.isArray(operand) ? operand.map(op) : op(operand as number);\n    }\n    case \"call\":\n      return evaluateCall(node, environment);\n    default:\n      // Conditional nodes never reach the vectorized path.\n      throw new TypeError(`unsupported formula element: ${node.kind}`);\n  }\n}\n\nfunction applyBinary(\n  op: (left: number, right: number) => number,\n  left: Value,\n  right: Value,\n): Value {\n  if (Array.isArray(left)) {\n    if (Array.isArray(right)) {\n      const result: number[] = new Array(left.length);\n      for (let index = 0; index < left.length; index += 1) {\n        result[index] = op(left[index] as number, right[index] as number);\n      }\n      return result;\n    }\n    const scalar = right as number;\n    return left.map((value) => op(value, scalar));\n  }\n  const scalarLeft = left as number;\n  if (Array.isArray(right)) {\n    return right.map((value) => op(scalarLeft, value));\n  }\n  return op(scalarLeft, right as number);\n}\n\nfunction evaluateNodeAt(\n  node: ExprNode,\n  environment: Environment,\n  index: number,\n  cache: CallArgCache,\n): number {\n  switch (node.kind) {\n    case \"name\": {\n      const series = environment[node.id] as readonly number[];\n      return series[index] as number;\n    }\n    case \"constant\":\n      return node.value;\n    case \"binop\": {\n      const left = evaluateNodeAt(node.left, environment, index, cache);\n      const right = evaluateNodeAt(node.right, environment, index, cache);\n      return BINARY_OPS[node.op](left, right);\n    }\n    case \"unaryop\":\n      return UNARY_OPS[node.op](evaluateNodeAt(node.operand, environment, index, cache));\n    case \"compare\": {\n      let left = evaluateNodeAt(node.left, environment, index, cache);\n      for (let i = 0; i < node.ops.length; i += 1) {\n        const right = evaluateNodeAt(node.comparators[i] as ExprNode, environment, index, cache);\n        if (!COMPARE_OPS[node.ops[i] as CompareOp](left, right)) {\n          return 0;\n        }\n        left = right;\n      }\n      return 1;\n    }\n    case \"boolop\": {\n      if (node.op === \"and\") {\n        for (const value of node.values) {\n          if (!isTruthy(evaluateNodeAt(value, environment, index, cache))) {\n            return 0;\n          }\n        }\n        return 1;\n      }\n      for (const value of node.values) {\n        if (isTruthy(evaluateNodeAt(value, environment, index, cache))) {\n          return 1;\n        }\n      }\n      return 0;\n    }\n    case \"ifexp\": {\n      const test = evaluateNodeAt(node.test, environment, index, cache);\n      const branch = isTruthy(test) ? node.body : node.orelse;\n      return evaluateNodeAt(branch, environment, index, cache);\n    }\n    case \"call\":\n      return evaluateCallAt(node, environment, index, cache);\n    default:\n      throw new TypeError(\"unsupported formula element\");\n  }\n}\n\nfunction evaluateCall(node: CallNode, environment: Environment): Value {\n  const spec = callSpec(node);\n  const window = callWindow(node, environment);\n  const series = evaluateNode(node.args[0] as ExprNode, environment);\n  if (!Array.isArray(series)) {\n    return series;\n  }\n  return spec.apply(series, window);\n}\n\n/**\n * If index ``i`` selects the call, evaluate the series argument on\n * ``[max(0, i-window+1), i]`` only — including neighbors that would not\n * have selected the call themselves. Short-circuit still applies per\n * neighbor. Overlapping windows reuse already-computed argument values;\n * indexes that are never in a selected window are not evaluated.\n */\nfunction evaluateCallAt(\n  node: CallNode,\n  environment: Environment,\n  index: number,\n  cache: CallArgCache,\n): number {\n  const spec = callSpec(node);\n  const window = callWindow(node, environment);\n  const start = Math.max(0, index - window + 1);\n  const values: number[] = [];\n  for (let neighbor = start; neighbor <= index; neighbor += 1) {\n    values.push(evaluateCallArgAt(node, environment, neighbor, cache));\n  }\n  return spec.apply(values, window)[values.length - 1] as number;\n}\n\nfunction evaluateCallArgAt(\n  node: CallNode,\n  environment: Environment,\n  index: number,\n  cache: CallArgCache,\n): number {\n  let byIndex = cache.get(node);\n  if (byIndex === undefined) {\n    byIndex = new Map();\n    cache.set(node, byIndex);\n  }\n  if (byIndex.has(index)) {\n    return byIndex.get(index) as number;\n  }\n  const value = evaluateNodeAt(node.args[0] as ExprNode, environment, index, cache);\n  byIndex.set(index, value);\n  return value;\n}\n\nfunction callSpec(node: CallNode): FunctionSpec & { readonly windowArg: number } {\n  const spec = ALLOWED_FUNCTIONS[node.name];\n  if (spec === undefined || spec.windowArg === null) {\n    throw new TypeError(\"unsupported formula element\");\n  }\n  return spec as FunctionSpec & { readonly windowArg: number };\n}\n\nfunction callWindow(node: CallNode, environment: Environment): number {\n  const spec = callSpec(node);\n  const windowValue = evaluateNode(node.args[spec.windowArg] as ExprNode, environment);\n  return windowValue as number;\n}\n","import type { CompiledFormula } from \"./compiler\";\nimport type { Environment } from \"./evaluator\";\nimport { evaluateTree } from \"./evaluator\";\nimport { MissingParameterError, ParameterError, ParameterLengthError } from \"./exceptions\";\nimport type { EvaluationResult, Parameters } from \"./types\";\n\nexport function evaluateCompiled(\n  formula: CompiledFormula,\n  parameters: Parameters,\n): EvaluationResult {\n  const missing = formula.variables.filter((name) => !Object.hasOwn(parameters, name));\n  if (missing.length > 0) {\n    throw new MissingParameterError(missing);\n  }\n\n  const environment: Environment = {};\n  const lengthsByName: Record<string, number> = {};\n  for (const [originalName, safeName] of formula.nameMap) {\n    const series = normalizeParameter(originalName, parameters[originalName]);\n    environment[safeName] = series;\n    lengthsByName[originalName] = series.length;\n  }\n\n  const lengths = Object.values(lengthsByName);\n  if (new Set(lengths).size !== 1) {\n    throw new ParameterLengthError(lengthsByName);\n  }\n\n  const length = lengths[0] as number;\n  if (length === 0) {\n    // Every referenced parameter resolved to an empty series, so there is\n    // nothing to compute over: return an empty result rather than erroring.\n    return [];\n  }\n\n  return evaluateTree(formula.tree, environment, length, formula.hasConditional);\n}\n\nfunction normalizeParameter(name: string, value: unknown): number[] {\n  if (!Array.isArray(value)) {\n    throw new ParameterError(`parameter '${name}' must be a numeric sequence`);\n  }\n\n  const normalized: number[] = new Array(value.length);\n  for (let index = 0; index < value.length; index += 1) {\n    const item = value[index];\n    if (typeof item !== \"number\") {\n      throw new ParameterError(`parameter '${name}' must be a numeric sequence`);\n    }\n    normalized[index] = item;\n  }\n  return normalized;\n}\n","import { compileFormula } from \"./compiler\";\nimport { evaluateCompiled } from \"./runtime\";\nimport type { EvaluationResult, Parameters } from \"./types\";\n\n/**\n * Evaluate a formula over aligned numeric parameter sequences.\n *\n * Placeholders are written as ``{name}`` and each resolves to the matching\n * entry in `parameters`. The following operators are supported:\n *\n * - arithmetic: ``+`` ``-`` ``*`` ``/`` ``**`` ``%`` (binary) and ``+`` ``-`` (unary)\n * - comparisons: ``==`` ``!=`` ``<`` ``<=`` ``>`` ``>=``\n * - boolean: ``and`` ``or``\n * - conditional: ``{A} / {B} if {B} != 0 else 0``\n * - functions: ``rolling_average({A}, N)`` — same-length simple moving\n *   average. The window ``N`` must be a positive integer constant.\n *   Incomplete windows at the start of a series average whatever points\n *   exist so far, so the result stays aligned with the inputs. Put\n *   value-dependent guards *inside* the series argument: an outer\n *   ``if`` does not protect neighbors in the window of a selected index.\n *\n * Structural problems (bad syntax, unknown identifiers, missing parameters,\n * mismatched lengths, non-numeric values) throw a subclass of `FormulaError`.\n *\n * When every referenced parameter is an empty sequence the result is an empty\n * array — there is nothing to compute over, so this is treated as a valid\n * (empty) result rather than an error. A *mix* of empty and non-empty\n * parameters is still a length mismatch and throws `ParameterLengthError`.\n *\n * Arithmetic failures that depend on the parameter *values* are surfaced as\n * arithmetic errors (subclasses of `ArithmeticError`) rather than\n * `FormulaError`: dividing or taking a modulo by zero throws\n * `ZeroDivisionError` and an overflowing exponentiation throws `OverflowError`.\n *\n * Conditional expressions, comparisons and boolean operators are evaluated\n * element-by-element: for each series element only the selected branch is\n * evaluated, so a division-by-zero (or other value-dependent failure) in the\n * branch that is *not* selected for a given element never throws. If an\n * index selects ``rolling_average``, the series argument is also evaluated\n * on that index's window (including neighbors that would not have selected\n * the call). A call that is never selected, and indexes that are not in any\n * selected window, are not evaluated.\n */\nexport function evaluate(formula: string, parameters: Parameters = {}): EvaluationResult {\n  return evaluateCompiled(compileFormula(formula), parameters);\n}\n","import type { DataPoint, ReducerType, Series } from \"./models\";\n\n/** Returns a time-ordered series; duplicate timestamps keep the last value. */\nfunction prepare(leaf: Series): Series {\n  if (leaf.length < 2) {\n    return leaf;\n  }\n\n  let sortedOk = true;\n  let hasDuplicates = false;\n  let previous = (leaf[0] as DataPoint).timestamp.getTime();\n  for (let index = 1; index < leaf.length; index += 1) {\n    const timestamp = (leaf[index] as DataPoint).timestamp.getTime();\n    if (timestamp < previous) {\n      sortedOk = false;\n      break;\n    }\n    if (timestamp === previous) {\n      hasDuplicates = true;\n    }\n    previous = timestamp;\n  }\n\n  if (sortedOk && !hasDuplicates) {\n    return leaf;\n  }\n\n  const ordered = sortedOk\n    ? leaf\n    : [...leaf].sort((left, right) => left.timestamp.getTime() - right.timestamp.getTime());\n\n  const collapsed: Series = [ordered[0] as DataPoint];\n  for (let index = 1; index < ordered.length; index += 1) {\n    const point = ordered[index] as DataPoint;\n    const last = collapsed[collapsed.length - 1] as DataPoint;\n    if (last.timestamp.getTime() === point.timestamp.getTime()) {\n      collapsed[collapsed.length - 1] = point;\n    } else {\n      collapsed.push(point);\n    }\n  }\n  return collapsed;\n}\n\ntype AlignedRow = { timestamp: Date; values: number[] };\n\n/**\n * Walks several prepared series in lockstep, yielding only the timestamps\n * present in every one of them, in ascending order.\n */\nfunction* iterAlignedRows(prepared: Series[]): Generator<AlignedRow> {\n  const count = prepared.length;\n  const times = prepared.map((series) => series.map((point) => point.timestamp.getTime()));\n  const cursors = new Array<number>(count).fill(0);\n\n  while (true) {\n    let latest = Number.NEGATIVE_INFINITY;\n    for (let index = 0; index < count; index += 1) {\n      const time = (times[index] as number[])[cursors[index] as number];\n      if (time === undefined) {\n        return;\n      }\n      if (time > latest) {\n        latest = time;\n      }\n    }\n\n    // Advance every series to the latest head timestamp. A series that\n    // overshoots it means no row exists there; the next pass then computes a\n    // higher `latest`, which is what guarantees forward progress.\n    let aligned = true;\n    for (let index = 0; index < count; index += 1) {\n      const seriesTimes = times[index] as number[];\n      let cursor = cursors[index] as number;\n      while (cursor < seriesTimes.length && (seriesTimes[cursor] as number) < latest) {\n        cursor += 1;\n      }\n      cursors[index] = cursor;\n      if (seriesTimes[cursor] !== latest) {\n        aligned = false;\n        break;\n      }\n    }\n    if (!aligned) {\n      continue;\n    }\n\n    const values = new Array<number>(count);\n    let timestamp = new Date(latest);\n    for (let index = 0; index < count; index += 1) {\n      const point = (prepared[index] as Series)[cursors[index] as number] as DataPoint;\n      values[index] = point.value;\n      if (index === 0) {\n        timestamp = point.timestamp;\n      }\n    }\n    yield { timestamp, values };\n\n    for (let index = 0; index < count; index += 1) {\n      cursors[index] = (cursors[index] as number) + 1;\n    }\n  }\n}\n\nfunction reduceValues(values: number[], reducer: ReducerType): number {\n  switch (reducer) {\n    case \"min\": {\n      let result = values[0] as number;\n      for (const value of values) {\n        if (value < result) {\n          result = value;\n        }\n      }\n      return result;\n    }\n    case \"max\": {\n      let result = values[0] as number;\n      for (const value of values) {\n        if (value > result) {\n          result = value;\n        }\n      }\n      return result;\n    }\n    case \"sum\":\n      return sum(values);\n    case \"average\":\n      return sum(values) / values.length;\n  }\n}\n\nfunction sum(values: number[]): number {\n  let total = 0;\n  for (const value of values) {\n    total += value;\n  }\n  return total;\n}\n\n/**\n * Combines or aligns multiple time series by intersecting on timestamp.\n *\n * A timestamp survives only when every input series has a value for it.\n * This is stricter than a positional zip: it tolerates series with gaps or\n * misaligned points instead of silently pairing up unrelated values.\n *\n * Every input is normalized first (sorted by timestamp, duplicate timestamps\n * collapsed to their last value), including when a single series is passed, so\n * the output does not depend on how many series the caller happened to supply.\n */\nexport class SeriesReducer {\n  reduce(series: Series[], reducer: ReducerType): Series {\n    if (series.length === 0) {\n      return [];\n    }\n    if (series.length === 1) {\n      return prepare([...(series[0] as Series)]);\n    }\n    if (series.some((leaf) => leaf.length === 0)) {\n      return [];\n    }\n\n    const result: Series = [];\n    for (const row of iterAlignedRows(series.map(prepare))) {\n      result.push({ timestamp: row.timestamp, value: reduceValues(row.values, reducer) });\n    }\n    return result;\n  }\n\n  /** Filters each series to the timestamps present in every series. */\n  align(series: Series[]): Series[] {\n    if (series.length === 0) {\n      return [];\n    }\n    if (series.length === 1) {\n      return [prepare([...(series[0] as Series)])];\n    }\n    if (series.some((leaf) => leaf.length === 0)) {\n      return series.map(() => []);\n    }\n\n    const aligned: Series[] = series.map(() => []);\n    for (const row of iterAlignedRows(series.map(prepare))) {\n      for (let index = 0; index < row.values.length; index += 1) {\n        (aligned[index] as Series).push({\n          timestamp: row.timestamp,\n          value: row.values[index] as number,\n        });\n      }\n    }\n    return aligned;\n  }\n}\n","import { z } from \"zod\";\n\nconst nodeIdSchema = z.object({\n  space: z.string().min(1),\n  externalId: z.string().min(1),\n});\n\nconst aggregateSchema = z.enum([\n  \"average\",\n  \"max\",\n  \"min\",\n  \"count\",\n  \"sum\",\n  \"interpolation\",\n  \"stepInterpolation\",\n  \"totalVariation\",\n  \"continuousVariance\",\n  \"discreteVariance\",\n]);\n\nconst reducerSchema = z.enum([\"min\", \"max\", \"sum\", \"average\"]);\nconst alignmentSchema = z.enum([\"intersect\", \"strict\"]);\n\n// `alias`, `granularity` and `formula` are deliberately unconstrained beyond\n// their type: an empty formula is the formula engine's error to raise, not\n// this schema's.\nconst timeSeriesFields = {\n  alias: z.string(),\n  aggregateType: aggregateSchema.optional(),\n  granularity: z.string().optional(),\n};\n\ntype GranularityCheckable = {\n  alias: string;\n  aggregateType?: string | undefined;\n  granularity?: string | undefined;\n};\n\n/** An aggregate is meaningless without the granularity that buckets it. */\nfunction checkGranularity(parameter: GranularityCheckable, context: z.RefinementCtx): void {\n  if (parameter.aggregateType !== undefined && parameter.granularity === undefined) {\n    context.addIssue({\n      code: \"custom\",\n      message:\n        `Missing granularity for '${parameter.alias}' ` +\n        `with aggregate '${parameter.aggregateType}'`,\n    });\n  }\n}\n\nconst constantParameterSchema = z.object({\n  type: z.literal(\"constant\"),\n  alias: z.string(),\n  value: z.number(),\n});\n\nconst timeSeriesParameterSchema = z\n  .object({\n    type: z.literal(\"single_timeseries\"),\n    timeSeries: nodeIdSchema,\n    ...timeSeriesFields,\n  })\n  .superRefine(checkGranularity);\n\nconst multiTimeSeriesParameterSchema = z\n  .object({\n    type: z.literal(\"multi_timeseries\"),\n    timeSeries: z.array(nodeIdSchema),\n    reducer: reducerSchema,\n    ...timeSeriesFields,\n  })\n  .superRefine((parameter, context) => {\n    checkGranularity(parameter, context);\n\n    if (parameter.timeSeries.length < 2) {\n      context.addIssue({\n        code: \"custom\",\n        message:\n          `'${parameter.alias}' must reference at least two timeseries; ` +\n          \"use a single-timeseries parameter for one\",\n      });\n    }\n\n    const keys = parameter.timeSeries.map(({ space, externalId }) => `${space}:${externalId}`);\n    if (new Set(keys).size !== keys.length) {\n      context.addIssue({\n        code: \"custom\",\n        message: `'${parameter.alias}' has duplicate timeseries instance ids`,\n      });\n    }\n  });\n\nconst parameterSchema = z.discriminatedUnion(\"type\", [\n  constantParameterSchema,\n  timeSeriesParameterSchema,\n  multiTimeSeriesParameterSchema,\n]);\n\nconst querySchema = z\n  .object({\n    formula: z.string(),\n    parameters: z.array(parameterSchema),\n    alignment: alignmentSchema.optional(),\n  })\n  .superRefine((query, context) => {\n    const seen = new Set<string>();\n    const duplicates = new Set<string>();\n    for (const parameter of query.parameters) {\n      if (seen.has(parameter.alias)) {\n        duplicates.add(parameter.alias);\n      }\n      seen.add(parameter.alias);\n    }\n    if (duplicates.size > 0) {\n      context.addIssue({\n        code: \"custom\",\n        message: `duplicate parameter alias(es): ${[...duplicates].sort().join(\", \")}`,\n        path: [\"parameters\"],\n      });\n    }\n  });\n\nfunction formatIssues(error: z.ZodError, prefix: string): string[] {\n  return error.issues.map((issue) => {\n    const path = [prefix, ...issue.path].map(String).join(\".\");\n    return `${path}: ${issue.message}`;\n  });\n}\n\n/**\n * Rejects a query the calculator cannot evaluate.\n *\n * `Calculator` runs it for you; call it directly to fail early on a query\n * built from untrusted input, such as a JSON payload.\n */\nexport function validateCalculatorQuery(query: unknown): void {\n  validateCalculatorQueries([query]);\n}\n\n/** Validates several queries, reporting every problem across all of them. */\nexport function validateCalculatorQueries(queries: readonly unknown[]): void {\n  const messages: string[] = [];\n  queries.forEach((query, index) => {\n    const result = querySchema.safeParse(query);\n    if (!result.success) {\n      const prefix = queries.length === 1 ? \"query\" : `queries.${index}`;\n      messages.push(...formatIssues(result.error, prefix));\n    }\n  });\n\n  if (messages.length > 0) {\n    throw new Error(`Invalid calculator query:\\n- ${messages.join(\"\\n- \")}`);\n  }\n}\n","import type { CogniteClient } from \"@cognite/sdk\";\nimport { type CognitePort, createCogniteAdapter } from \"../cognite\";\nimport { DatapointsRetriever } from \"./datapoints-retrieval\";\nimport { evaluate, MissingTimeAxisError, ParameterTimestampError } from \"./formula-expression\";\nimport {\n  type AlignmentMode,\n  type AnyTimeSeriesParameter,\n  type CalculationResult,\n  type CalculatorQuery,\n  isConstantParameter,\n  isTimeSeriesParameter,\n  type Series,\n} from \"./models\";\nimport { SeriesReducer } from \"./series-reducer\";\nimport { validateCalculatorQueries } from \"./validation\";\n\n/**\n * Evaluates formula-based calculations over Cognite time series datapoints.\n *\n * Each {@link CalculatorQuery} pairs a formula with the parameters its\n * placeholders resolve to. The calculator fetches the required datapoints\n * (de-duplicating shared time series), joins the query's time-series\n * parameters onto a single time axis, and evaluates the formula\n * element-by-element.\n */\nexport class Calculator {\n  private readonly retriever: DatapointsRetriever;\n  private readonly seriesReducer = new SeriesReducer();\n\n  constructor(cognite: CogniteClient | CognitePort) {\n    const port = isCognitePort(cognite) ? cognite : createCogniteAdapter(cognite);\n    this.retriever = new DatapointsRetriever(port);\n  }\n\n  /** Evaluate a single query over the given time range. */\n  async calculate(query: CalculatorQuery, start: Date, end: Date): Promise<CalculationResult> {\n    const [result] = await this.calculateMultiples([query], start, end);\n    // calculateMultiples returns one result per query, so this is always set.\n    return result as CalculationResult;\n  }\n\n  /**\n   * Evaluate several queries over the given time range, retrieving every\n   * parameter's datapoints in a single de-duplicated round trip.\n   */\n  async calculateMultiples(\n    queries: CalculatorQuery[],\n    start: Date,\n    end: Date,\n  ): Promise<CalculationResult[]> {\n    validateCalculatorQueries(queries);\n\n    // Constants are never fetched, so a query's slice of the retrieved\n    // datapoints is as wide as its time-series parameters, not its parameters.\n    const timeSeriesCounts = queries.map(\n      (query) => query.parameters.filter(isTimeSeriesParameter).length,\n    );\n    const timeSeriesParameters = queries.flatMap((query) =>\n      query.parameters.filter(isTimeSeriesParameter),\n    );\n    const leafSeriesByParameter = await this.retriever.retrieveDatapoints(\n      timeSeriesParameters,\n      start,\n      end,\n    );\n\n    const results: CalculationResult[] = [];\n    let offset = 0;\n    queries.forEach((query, index) => {\n      const count = timeSeriesCounts[index] as number;\n      results.push(this.calculateOne(query, leafSeriesByParameter.slice(offset, offset + count)));\n      offset += count;\n    });\n    return results;\n  }\n\n  private calculateOne(\n    query: CalculatorQuery,\n    leafSeriesByParameter: Series[][],\n  ): CalculationResult {\n    const aliases: string[] = [];\n    let series: Series[] = [];\n    let cursor = 0;\n\n    for (const parameter of query.parameters) {\n      if (!isTimeSeriesParameter(parameter)) {\n        continue;\n      }\n      const leafSeries = leafSeriesByParameter[cursor] as Series[];\n      cursor += 1;\n      aliases.push(parameter.alias);\n      series.push(this.collapse(parameter, leafSeries));\n    }\n\n    if (aliases.length === 0 && query.parameters.length > 0) {\n      throw new MissingTimeAxisError(query.parameters.map((parameter) => parameter.alias));\n    }\n\n    series = this.alignSeries(query.alignment ?? \"intersect\", aliases, series);\n    const timestamps = (series[0] ?? []).map((point) => point.timestamp);\n\n    const valuesMap: Record<string, number[]> = {};\n    aliases.forEach((alias, index) => {\n      valuesMap[alias] = (series[index] as Series).map((point) => point.value);\n    });\n    for (const parameter of query.parameters) {\n      if (isConstantParameter(parameter)) {\n        valuesMap[parameter.alias] = new Array(timestamps.length).fill(parameter.value);\n      }\n    }\n\n    const values = evaluate(query.formula, valuesMap);\n\n    const inputs: Record<string, Series> = {};\n    aliases.forEach((alias, index) => {\n      inputs[alias] = series[index] as Series;\n    });\n    for (const parameter of query.parameters) {\n      if (isConstantParameter(parameter)) {\n        inputs[parameter.alias] = timestamps.map((timestamp) => ({\n          timestamp,\n          value: parameter.value,\n        }));\n      }\n    }\n\n    return {\n      query,\n      datapoints: timestamps.map((timestamp, index) => ({\n        timestamp,\n        value: values[index] as number,\n      })),\n      inputs,\n    };\n  }\n\n  /** Collapses a parameter's time series down to the single series it stands for. */\n  private collapse(parameter: AnyTimeSeriesParameter, leafSeries: Series[]): Series {\n    if (parameter.type === \"multi_timeseries\") {\n      return this.seriesReducer.reduce(leafSeries, parameter.reducer);\n    }\n    return leafSeries[0] ?? [];\n  }\n\n  private alignSeries(mode: AlignmentMode, aliases: string[], series: Series[]): Series[] {\n    if (mode === \"strict\") {\n      requireAlignedTimestamps(aliases, series);\n      return series;\n    }\n    return this.seriesReducer.align(series);\n  }\n}\n\nfunction requireAlignedTimestamps(aliases: string[], series: Series[]): void {\n  const reference = series[0];\n  if (reference === undefined) {\n    return;\n  }\n\n  const mismatched = aliases.slice(1).filter((_alias, index) => {\n    const candidate = series[index + 1] as Series;\n    return (\n      candidate.length !== reference.length ||\n      candidate.some(\n        (point, pointIndex) =>\n          point.timestamp.getTime() !==\n          (reference[pointIndex] as Series[number]).timestamp.getTime(),\n      )\n    );\n  });\n\n  if (mismatched.length > 0) {\n    throw new ParameterTimestampError([aliases[0] as string, ...mismatched]);\n  }\n}\n\nfunction isCognitePort(value: CogniteClient | CognitePort): value is CognitePort {\n  return typeof (value as CognitePort).retrieveDatapoints === \"function\";\n}\n"]}