tla-ts 0.0.0-stage → 0.0.2

package/dist/index.d.cts

@@ -0,0 +1,607 @@
+/**
+ * @license tla-ts
+ *
+ * Copyright (c) Aiden Bai
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+interface LocalResolution {
+  kind: "Local";
+}
+interface SourceLocation {
+  line: number;
+  column: number;
+  range?: SourceRange;
+}
+interface SourceRange {
+  module: string;
+  start: SourceLocation;
+  end: SourceLocation;
+}
+interface NumberExpression {
+  kind: "Number";
+  value: number;
+  text?: string;
+  location: SourceLocation;
+}
+interface DecimalExpression {
+  kind: "Decimal";
+  text: string;
+  location: SourceLocation;
+}
+interface StringExpression {
+  kind: "String";
+  value: string;
+  location: SourceLocation;
+}
+interface IdentifierExpression {
+  kind: "Identifier";
+  name: string;
+  location: SourceLocation;
+  resolution?: LocalResolution;
+}
+interface ApplyExpression {
+  kind: "Apply";
+  operator: string;
+  args: Expression[];
+  location: SourceLocation;
+  resolution?: LocalResolution;
+}
+interface OperatorReferenceExpression {
+  kind: "OperatorReference";
+  operator: string;
+  location: SourceLocation;
+}
+interface LambdaExpression {
+  kind: "Lambda";
+  params: string[];
+  body: Expression;
+  location: SourceLocation;
+}
+interface JunctionExpression {
+  kind: "And" | "Or";
+  operands: Expression[];
+  location: SourceLocation;
+}
+interface PrimeExpression {
+  kind: "Prime";
+  expression: Expression;
+  location: SourceLocation;
+}
+interface UnchangedExpression {
+  kind: "Unchanged";
+  expression: Expression;
+  location: SourceLocation;
+}
+interface EnabledExpression {
+  kind: "Enabled";
+  expression: Expression;
+  location: SourceLocation;
+}
+interface IfExpression {
+  kind: "If";
+  condition: Expression;
+  consequent: Expression;
+  alternative: Expression;
+  location: SourceLocation;
+}
+interface CaseArm {
+  condition: Expression;
+  body: Expression;
+}
+interface CaseExpression {
+  kind: "Case";
+  arms: CaseArm[];
+  other: Expression | undefined;
+  location: SourceLocation;
+}
+interface LetExpression {
+  kind: "Let";
+  definitions: Definition[];
+  instances?: Instance[];
+  body: Expression;
+  location: SourceLocation;
+}
+type BoundPattern = {
+  kind: "Name";
+  name: string;
+} | {
+  kind: "Tuple";
+  names: string[];
+};
+interface Bound {
+  pattern: BoundPattern;
+  set: Expression;
+}
+interface QuantifierExpression {
+  kind: "Forall" | "Exists";
+  bounds: Bound[];
+  body: Expression;
+  location: SourceLocation;
+}
+interface UnboundedQuantifierExpression {
+  kind: "UnboundedQuantifier";
+  names: string[];
+  isTemporal?: boolean;
+  body: Expression;
+  location: SourceLocation;
+}
+interface ChooseExpression {
+  kind: "Choose";
+  pattern: BoundPattern;
+  set: Expression | undefined;
+  body: Expression;
+  location: SourceLocation;
+}
+interface SetEnumerationExpression {
+  kind: "SetEnumeration";
+  elements: Expression[];
+  location: SourceLocation;
+}
+interface SetFilterExpression {
+  kind: "SetFilter";
+  bound: Bound;
+  predicate: Expression;
+  location: SourceLocation;
+}
+interface SetMapExpression {
+  kind: "SetMap";
+  expression: Expression;
+  bounds: Bound[];
+  location: SourceLocation;
+}
+interface TupleExpression {
+  kind: "Tuple";
+  elements: Expression[];
+  location: SourceLocation;
+}
+interface FunctionConstructionExpression {
+  kind: "FunctionConstruction";
+  bounds: Bound[];
+  body: Expression;
+  location: SourceLocation;
+  isRecursive?: boolean;
+}
+interface FunctionSetExpression {
+  kind: "FunctionSet";
+  domain: Expression;
+  range: Expression;
+  location: SourceLocation;
+}
+interface RecordField {
+  name: string;
+  value: Expression;
+}
+interface RecordExpression {
+  kind: "Record" | "RecordSet";
+  fields: RecordField[];
+  location: SourceLocation;
+}
+type ExceptPathStep = {
+  kind: "Field";
+  name: string;
+} | {
+  kind: "Index";
+  args: Expression[];
+};
+interface ExceptUpdate {
+  path: ExceptPathStep[];
+  value: Expression;
+}
+interface ExceptExpression {
+  kind: "Except";
+  function: Expression;
+  updates: ExceptUpdate[];
+  location: SourceLocation;
+}
+interface ExceptAtExpression {
+  kind: "ExceptAt";
+  location: SourceLocation;
+}
+interface FunctionApplicationExpression {
+  kind: "FunctionApplication";
+  function: Expression;
+  args: Expression[];
+  location: SourceLocation;
+}
+interface FieldAccessExpression {
+  kind: "FieldAccess";
+  record: Expression;
+  field: string;
+  location: SourceLocation;
+}
+interface ProductExpression {
+  kind: "Product";
+  factors: Expression[];
+  location: SourceLocation;
+}
+interface TemporalExpression {
+  kind: "Always" | "Eventually";
+  expression: Expression;
+  location: SourceLocation;
+}
+interface ActionExpression {
+  kind: "BoxAction" | "AngleAction";
+  action: Expression;
+  subscript: Expression;
+  location: SourceLocation;
+}
+interface FairnessExpression {
+  kind: "WeakFairness" | "StrongFairness";
+  subscript: Expression;
+  action: Expression;
+  enabled?: Expression;
+  location: SourceLocation;
+}
+interface LabelExpression {
+  kind: "Label";
+  name: string;
+  params: string[];
+  body: Expression;
+  location: SourceLocation;
+}
+type Selector = {
+  kind: "Name";
+  name: string;
+  args: Expression[];
+} | {
+  kind: "Operand";
+  operand: number | "<<" | ">>";
+} | {
+  kind: "Bound";
+  args: Expression[];
+} | {
+  kind: "At";
+} | {
+  kind: "Colon";
+};
+interface SubexpressionExpression {
+  kind: "Subexpression";
+  selectors: Selector[];
+  location: SourceLocation;
+}
+type Expression = NumberExpression | DecimalExpression | StringExpression | IdentifierExpression | ApplyExpression | OperatorReferenceExpression | LambdaExpression | JunctionExpression | PrimeExpression | UnchangedExpression | EnabledExpression | IfExpression | CaseExpression | LetExpression | QuantifierExpression | UnboundedQuantifierExpression | ChooseExpression | SetEnumerationExpression | SetFilterExpression | SetMapExpression | TupleExpression | FunctionConstructionExpression | FunctionSetExpression | RecordExpression | ExceptExpression | ExceptAtExpression | FunctionApplicationExpression | FieldAccessExpression | ProductExpression | TemporalExpression | ActionExpression | FairnessExpression | LabelExpression | SubexpressionExpression;
+interface OperatorParam {
+  name: string;
+  arity: number;
+}
+interface OperatorDefinition {
+  kind: "Operator";
+  name: string;
+  params: OperatorParam[];
+  body: Expression;
+  bodyRange?: SourceRange;
+  isLocal: boolean;
+  isRecursive: boolean;
+  location: SourceLocation;
+}
+interface FunctionDefinition {
+  kind: "Function";
+  name: string;
+  bounds: Bound[];
+  body: Expression;
+  isLocal: boolean;
+  isRecursive: boolean;
+  location: SourceLocation;
+}
+type Definition = OperatorDefinition | FunctionDefinition;
+interface Declaration {
+  name: string;
+  arity: number;
+  location: SourceLocation;
+}
+interface Assumption {
+  name: string | undefined;
+  expression: Expression;
+  isAxiom: boolean;
+  location: SourceLocation;
+}
+interface InstanceSubstitution {
+  name: string;
+  expression: Expression;
+}
+interface Instance {
+  kind: "Instance";
+  name: string | undefined;
+  params: OperatorParam[];
+  module: string;
+  substitutions: InstanceSubstitution[];
+  isLocal: boolean;
+  location: SourceLocation;
+}
+interface NewSymbol {
+  kind: "NewSymbol";
+  name: string;
+  arity: number;
+  level: "Constant" | "Variable" | "State" | "Action" | "Temporal";
+  set: Expression | undefined;
+  location: SourceLocation;
+}
+interface AssumeProve {
+  kind: "AssumeProve";
+  assumptions: (Expression | NewSymbol | AssumeProve)[];
+  conclusion: Expression;
+  location: SourceLocation;
+}
+type Fact = Expression | {
+  kind: "ModuleFact";
+  name: string;
+  location: SourceLocation;
+};
+interface UseOrHide {
+  kind: "Use" | "Hide";
+  isOnly: boolean;
+  facts: Fact[];
+  defs: Fact[];
+  location: SourceLocation;
+}
+type Proof = {
+  kind: "Obvious" | "Omitted";
+  location: SourceLocation;
+} | {
+  kind: "By";
+  isOnly: boolean;
+  facts: Fact[];
+  defs: Fact[];
+  location: SourceLocation;
+} | {
+  kind: "Steps";
+  level: number;
+  steps: ProofStep[];
+  location: SourceLocation;
+};
+interface DefineStep {
+  kind: "Define";
+  definitions: (Definition | Instance)[];
+  location: SourceLocation;
+}
+type StepBody = UseOrHide | Instance | DefineStep | {
+  kind: "Have";
+  expression: Expression;
+} | {
+  kind: "Take";
+  names: string[];
+  bounds: Bound[];
+} | {
+  kind: "Witness";
+  expressions: Expression[];
+} | {
+  kind: "Pick";
+  names: string[];
+  bounds: Bound[];
+  body: Expression;
+} | {
+  kind: "Case";
+  expression: Expression;
+} | {
+  kind: "Assert";
+  isSuffices: boolean;
+  statement: Expression | AssumeProve;
+} | {
+  kind: "Qed";
+};
+interface ProofStep {
+  name: string | undefined;
+  body: StepBody;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+interface Theorem {
+  name: string | undefined;
+  statement: Expression | AssumeProve;
+  proof: Proof | undefined;
+  location: SourceLocation;
+}
+interface Module {
+  name: string;
+  modules: Module[];
+  extends: string[];
+  constants: Declaration[];
+  variables: Declaration[];
+  definitions: Definition[];
+  instances: Instance[];
+  assumptions: Assumption[];
+  location: SourceLocation;
+  theorems: Theorem[];
+  uses: UseOrHide[];
+}
+type ConfigValue = {
+  kind: "Number";
+  value: number;
+} | {
+  kind: "String";
+  value: string;
+} | {
+  kind: "Boolean";
+  value: boolean;
+} | {
+  kind: "ModelValue";
+  name: string;
+} | {
+  kind: "Set";
+  elements: ConfigValue[];
+};
+interface ConstantAssignment {
+  name: string;
+  value: ConfigValue;
+  args?: ConfigValue[];
+  module?: string;
+}
+interface Substitution {
+  name: string;
+  target: string;
+  module?: string;
+}
+interface ModelConfig {
+  init: string | undefined;
+  next: string | undefined;
+  specification: string | undefined;
+  invariants: string[];
+  properties: string[];
+  constraints: string[];
+  actionConstraints: string[];
+  constants: ConstantAssignment[];
+  substitutions: Substitution[];
+  checkDeadlock: boolean;
+  symmetry: string | undefined;
+  view: string | undefined;
+  alias: string | undefined;
+  postconditions: string[];
+  possible: string[];
+  periodic: string | undefined;
+  rlReward: string | undefined;
+}
+export declare const parseConfig: (source: string) => ModelConfig;
+export declare class TlaError extends Error {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaSyntaxError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaConfigError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaEvaluationError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+export declare class TlaUnsupportedError extends TlaError {
+  constructor(message: string, cause?: unknown);
+}
+interface ModelValue {
+  kind: "ModelValue";
+  name: string;
+}
+interface SetValue {
+  kind: "Set";
+  elements: Value[];
+  hash: number;
+  fingerprint: number;
+}
+interface MixedSetValue {
+  kind: "MixedSet";
+  elements: Value[];
+}
+interface FunctionValue {
+  kind: "Function";
+  domain: Value[];
+  range: Value[];
+  hash: number;
+  fingerprint: number;
+  writtenKeys: Value[] | undefined;
+}
+interface IntervalValue {
+  kind: "Interval";
+  low: number;
+  high: number;
+}
+interface InfiniteSetValue {
+  kind: "InfiniteSet";
+  name: "Nat" | "Int" | "STRING" | "Any";
+}
+interface SubsetValue {
+  kind: "Subset";
+  base: Value;
+}
+interface FunctionSetValue {
+  kind: "FunctionSet";
+  domain: Value;
+  range: Value;
+}
+interface RecordSetValue {
+  kind: "RecordSet";
+  names: string[];
+  sets: Value[];
+}
+interface ProductSetValue {
+  kind: "ProductSet";
+  factors: Value[];
+}
+interface SequenceSetValue {
+  kind: "SequenceSet";
+  base: Value;
+}
+interface SetOperationValue {
+  kind: "SetOperation";
+  operator: "\\cup" | "\\cap" | "\\";
+  left: Value;
+  right: Value;
+}
+interface FilteredSetValue {
+  kind: "FilteredSet";
+  base: Value;
+  test: (element: Value) => boolean;
+}
+interface UnionValue {
+  kind: "Union";
+  base: Value;
+}
+interface LazyFunctionParameter {
+  name: string;
+  domain: Value;
+}
+interface LazyFunctionSource {
+  parameters: LazyFunctionParameter[];
+  body: string;
+}
+interface LazyFunctionValue {
+  kind: "LazyFunction";
+  domain: Value;
+  apply: (argument: Value) => Value;
+  source?: LazyFunctionSource;
+}
+type Value = boolean | number | string | ModelValue | SetValue | MixedSetValue | FunctionValue | IntervalValue | InfiniteSetValue | SubsetValue | FunctionSetValue | RecordSetValue | ProductSetValue | SequenceSetValue | SetOperationValue | FilteredSetValue | UnionValue | LazyFunctionValue;
+export declare const formatValue: (value: Value, isStrict?: boolean, isNormalized?: boolean) => string;
+interface CheckOptions {
+  source: string;
+  config: string | ModelConfig;
+  loadModule?: (name: string) => string | undefined;
+  loadClass?: (name: string) => Uint8Array | undefined;
+  onPrint?: (text: string) => void;
+  onPause?: () => void;
+  readFile?: (path: string) => string | undefined;
+  writeFile?: (path: string, content: string) => void;
+  seed?: bigint;
+  workers?: number;
+  livenessCheck?: "default" | "final";
+}
+type CheckStatus = "success" | "assumption-violation" | "invariant-violation" | "property-violation" | "liveness-violation" | "postcondition-violation" | "deadlock" | "error";
+interface TraceStep {
+  action: string | undefined;
+  label: string | undefined;
+  state: Record<string, Value>;
+}
+interface Violation {
+  name: string;
+  trace: TraceStep[];
+  loopStart: number | undefined;
+  loopLabel?: string;
+  message?: string;
+  counts?: string;
+  unwitnessed?: Postcondition;
+}
+interface Postcondition {
+  name: string;
+  message: string;
+  counts?: string;
+}
+interface EvaluationFailure {
+  message: string;
+  trace: TraceStep[];
+  initialState: Record<string, Value> | undefined;
+  exitCode: number;
+}
+interface CheckResult {
+  status: CheckStatus;
+  violation: Violation | undefined;
+  failure: EvaluationFailure | undefined;
+  generatedStates: number;
+  distinctStates: number;
+  queuedStates: number;
+  depth: number;
+  outDegrees: number[] | undefined;
+  fingerprintDistance: bigint | undefined;
+}
+export declare const check: (options: CheckOptions) => Promise<CheckResult>;
+export declare const parseModule: (source: string) => Module;
+export type { CheckOptions, CheckResult, CheckStatus, ConfigValue, ConstantAssignment, EvaluationFailure, ModelConfig, Module, Substitution, TraceStep, Value, Violation };