@venn-lang/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3654 @@
+import * as langium from "langium";
+import { AstNode, AstNode as AstNode$1, DefaultLexer, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LangiumSharedCoreServices, LanguageMetaData, LexerResult, Module, TokenizeOptions } from "langium";
+import { TypeSpec } from "@venn-lang/types";
+//#region src/generated/ast.d.ts
+declare const VennTerminals: {
+  NL: RegExp;
+  WS: RegExp;
+  COMMENT: RegExp;
+  INSTANT: RegExp;
+  STRING: RegExp;
+  NUMBER: RegExp;
+  ID: RegExp;
+};
+type VennTerminalNames = keyof typeof VennTerminals;
+type VennKeywordNames = "!" | "!=" | "%" | "&&" | "(" | ")" | "*" | "+" | "," | "-" | "->" | "." | "/" | ":" | "<" | "<=" | "=" | "==" | "=>" | ">" | ">=" | "?" | "?." | "??" | "@" | "[" | "]" | "afterEach" | "all" | "as" | "beforeEach" | "break" | "capture" | "catch" | "config" | "const" | "continue" | "dataset" | "deco" | "defer" | "else" | "expect" | "factory" | "false" | "finally" | "flow" | "fn" | "forEach" | "fragment" | "from" | "group" | "if" | "import" | "in" | "let" | "matrix" | "module" | "not" | "null" | "on" | "parallel" | "pub" | "race" | "repeat" | "report" | "return" | "run" | "setup" | "soft" | "step" | "teardown" | "true" | "try" | "type" | "use" | "while" | "{" | "|" | "||" | "}" | "~=";
+type VennTokenNames = VennTerminalNames | VennKeywordNames;
+interface ActionCall extends Declaration, Statement {
+  readonly $type: 'ActionCall';
+  args: Array<Expr>;
+  call?: ArgList;
+  called: boolean;
+  opts?: MapLit;
+  target: QualifiedName;
+}
+declare const ActionCall: {
+  readonly $type: 'ActionCall';
+  readonly annotations: 'annotations';
+  readonly args: 'args';
+  readonly call: 'call';
+  readonly called: 'called';
+  readonly opts: 'opts';
+  readonly target: 'target';
+};
+declare function isActionCall(item: unknown): item is ActionCall;
+interface Annotation extends langium.AstNode {
+  readonly $container: Declaration | FieldDecl | Param | Statement;
+  readonly $type: 'Annotation';
+  args?: ArgList;
+  name: string;
+}
+declare const Annotation: {
+  readonly $type: 'Annotation';
+  readonly args: 'args';
+  readonly name: 'name';
+};
+declare function isAnnotation(item: unknown): item is Annotation;
+interface Arg extends langium.AstNode {
+  readonly $container: ArgList;
+  readonly $type: 'Arg';
+  name?: string;
+  value: Expr;
+}
+declare const Arg: {
+  readonly $type: 'Arg';
+  readonly name: 'name';
+  readonly value: 'value';
+};
+declare function isArg(item: unknown): item is Arg;
+interface ArgList extends langium.AstNode {
+  readonly $container: ActionCall | Annotation | Call | RunStmt;
+  readonly $type: 'ArgList';
+  args: Array<Arg>;
+}
+declare const ArgList: {
+  readonly $type: 'ArgList';
+  readonly args: 'args';
+};
+declare function isArgList(item: unknown): item is ArgList;
+interface Binary extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Binary';
+  left: Expr;
+  operator: '!=' | '%' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '==' | '>' | '>=' | '??' | 'in' | '||' | '~=';
+  right: Expr;
+}
+declare const Binary: {
+  readonly $type: 'Binary';
+  readonly left: 'left';
+  readonly operator: 'operator';
+  readonly right: 'right';
+};
+declare function isBinary(item: unknown): item is Binary;
+interface Block extends langium.AstNode {
+  readonly $container: DecoDecl | FlowDecl | ForEachStmt | FragmentDecl | GroupDecl | IfStmt | LifecycleDecl | ParallelStmt | RaceStmt | RepeatStmt | StepDecl | TryStmt | WhileStmt;
+  readonly $type: 'Block';
+  stmts: Array<Statement>;
+}
+declare const Block: {
+  readonly $type: 'Block';
+  readonly stmts: 'stmts';
+};
+declare function isBlock(item: unknown): item is Block;
+interface BoolLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'BoolLit';
+  value: 'false' | 'true';
+}
+declare const BoolLit: {
+  readonly $type: 'BoolLit';
+  readonly value: 'value';
+};
+declare function isBoolLit(item: unknown): item is BoolLit;
+interface BreakStmt extends Statement {
+  readonly $type: 'BreakStmt';
+}
+declare const BreakStmt: {
+  readonly $type: 'BreakStmt';
+  readonly annotations: 'annotations';
+};
+declare function isBreakStmt(item: unknown): item is BreakStmt;
+interface Call extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Call';
+  args?: ArgList;
+  callee: Expr;
+}
+declare const Call: {
+  readonly $type: 'Call';
+  readonly args: 'args';
+  readonly callee: 'callee';
+};
+declare function isCall(item: unknown): item is Call;
+interface CaptureStmt extends Statement {
+  readonly $type: 'CaptureStmt';
+  name: string;
+  opts?: MapLit;
+  value: Expr;
+}
+declare const CaptureStmt: {
+  readonly $type: 'CaptureStmt';
+  readonly annotations: 'annotations';
+  readonly name: 'name';
+  readonly opts: 'opts';
+  readonly value: 'value';
+};
+declare function isCaptureStmt(item: unknown): item is CaptureStmt;
+interface ConfigDecl extends Declaration {
+  readonly $type: 'ConfigDecl';
+  body: MapLit;
+}
+declare const ConfigDecl: {
+  readonly $type: 'ConfigDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+};
+declare function isConfigDecl(item: unknown): item is ConfigDecl;
+interface ContinueStmt extends Statement {
+  readonly $type: 'ContinueStmt';
+}
+declare const ContinueStmt: {
+  readonly $type: 'ContinueStmt';
+  readonly annotations: 'annotations';
+};
+declare function isContinueStmt(item: unknown): item is ContinueStmt;
+interface DatasetDecl extends Declaration {
+  readonly $type: 'DatasetDecl';
+  declaredType?: TypeRef;
+  name: string;
+  value: Expr;
+}
+declare const DatasetDecl: {
+  readonly $type: 'DatasetDecl';
+  readonly annotations: 'annotations';
+  readonly declaredType: 'declaredType';
+  readonly name: 'name';
+  readonly value: 'value';
+};
+declare function isDatasetDecl(item: unknown): item is DatasetDecl;
+interface Declaration extends langium.AstNode {
+  readonly $type: 'ActionCall' | 'ConfigDecl' | 'DatasetDecl' | 'Declaration' | 'DecoDecl' | 'ExpectStmt' | 'FactoryDecl' | 'FlowDecl' | 'FnDecl' | 'ForEachStmt' | 'FragmentDecl' | 'IfStmt' | 'LetStmt' | 'LifecycleDecl' | 'MatrixDecl' | 'ParallelStmt' | 'RaceStmt' | 'RepeatStmt' | 'ReportDecl' | 'RunStmt' | 'TryStmt' | 'TypeDecl' | 'WhileStmt';
+  annotations: Array<Annotation>;
+}
+declare const Declaration: {
+  readonly $type: 'Declaration';
+  readonly annotations: 'annotations';
+};
+declare function isDeclaration(item: unknown): item is Declaration;
+interface DecoDecl extends Declaration {
+  readonly $type: 'DecoDecl';
+  body: Block;
+  export: boolean;
+  name: string;
+  params?: ParamList;
+}
+declare const DecoDecl: {
+  readonly $type: 'DecoDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly export: 'export';
+  readonly name: 'name';
+  readonly params: 'params';
+};
+declare function isDecoDecl(item: unknown): item is DecoDecl;
+interface Document extends langium.AstNode {
+  readonly $type: 'Document';
+  decls: Array<Declaration>;
+  imports: Array<ImportDecl>;
+  name?: QualifiedName;
+}
+declare const Document: {
+  readonly $type: 'Document';
+  readonly decls: 'decls';
+  readonly imports: 'imports';
+  readonly name: 'name';
+};
+declare function isDocument(item: unknown): item is Document;
+type ElseBranch = Block | IfStmt;
+declare const ElseBranch: {
+  readonly $type: 'ElseBranch';
+};
+declare function isElseBranch(item: unknown): item is ElseBranch;
+interface ExpectStmt extends Declaration, Statement {
+  readonly $type: 'ExpectStmt';
+  checks: Array<Expr>;
+  matcher?: MatcherClause;
+  modifier?: 'all' | 'soft';
+  negate: boolean;
+  subject?: Expr;
+}
+declare const ExpectStmt: {
+  readonly $type: 'ExpectStmt';
+  readonly annotations: 'annotations';
+  readonly checks: 'checks';
+  readonly matcher: 'matcher';
+  readonly modifier: 'modifier';
+  readonly negate: 'negate';
+  readonly subject: 'subject';
+};
+declare function isExpectStmt(item: unknown): item is ExpectStmt;
+type Expr = Binary | BoolLit | Call | FnExpr | Index | InstantLit | ListLit | MapLit | Member | NullLit | NumberLit | Ref | StringLit | Ternary | Unary;
+declare const Expr: {
+  readonly $type: 'Expr';
+};
+declare function isExpr(item: unknown): item is Expr;
+interface FactoryDecl extends Declaration {
+  readonly $type: 'FactoryDecl';
+  body: MapLit;
+  name: string;
+}
+declare const FactoryDecl: {
+  readonly $type: 'FactoryDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly name: 'name';
+};
+declare function isFactoryDecl(item: unknown): item is FactoryDecl;
+interface FieldDecl extends langium.AstNode {
+  readonly $container: TypeBody;
+  readonly $type: 'FieldDecl';
+  annotations: Array<Annotation>;
+  fieldType: TypeRef;
+  name: string;
+  optional: boolean;
+}
+declare const FieldDecl: {
+  readonly $type: 'FieldDecl';
+  readonly annotations: 'annotations';
+  readonly fieldType: 'fieldType';
+  readonly name: 'name';
+  readonly optional: 'optional';
+};
+declare function isFieldDecl(item: unknown): item is FieldDecl;
+interface FlowDecl extends Declaration {
+  readonly $type: 'FlowDecl';
+  body: Block;
+  title: string;
+}
+declare const FlowDecl: {
+  readonly $type: 'FlowDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly title: 'title';
+};
+declare function isFlowDecl(item: unknown): item is FlowDecl;
+interface FnBody extends langium.AstNode {
+  readonly $container: FnDecl | FnExpr;
+  readonly $type: 'FnBody';
+  locals: Array<LetStmt>;
+  result: Expr;
+}
+declare const FnBody: {
+  readonly $type: 'FnBody';
+  readonly locals: 'locals';
+  readonly result: 'result';
+};
+declare function isFnBody(item: unknown): item is FnBody;
+interface FnDecl extends Declaration {
+  readonly $type: 'FnDecl';
+  body: FnBody;
+  export: boolean;
+  name: string;
+  params?: ParamList;
+  returns?: TypeRef;
+}
+declare const FnDecl: {
+  readonly $type: 'FnDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly export: 'export';
+  readonly name: 'name';
+  readonly params: 'params';
+  readonly returns: 'returns';
+};
+declare function isFnDecl(item: unknown): item is FnDecl;
+interface FnExpr extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'FnExpr';
+  body: FnBody;
+  params: ParamList;
+  returns?: TypeRef;
+}
+declare const FnExpr: {
+  readonly $type: 'FnExpr';
+  readonly body: 'body';
+  readonly params: 'params';
+  readonly returns: 'returns';
+};
+declare function isFnExpr(item: unknown): item is FnExpr;
+interface ForEachStmt extends Declaration, Statement {
+  readonly $type: 'ForEachStmt';
+  body: Block;
+  item: string;
+  opts?: MapLit;
+  source: Expr;
+}
+declare const ForEachStmt: {
+  readonly $type: 'ForEachStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly item: 'item';
+  readonly opts: 'opts';
+  readonly source: 'source';
+};
+declare function isForEachStmt(item: unknown): item is ForEachStmt;
+interface FragmentDecl extends Declaration {
+  readonly $type: 'FragmentDecl';
+  body: Block;
+  export: boolean;
+  name: string;
+  params?: ParamList;
+  returns?: TypeRef;
+}
+declare const FragmentDecl: {
+  readonly $type: 'FragmentDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly export: 'export';
+  readonly name: 'name';
+  readonly params: 'params';
+  readonly returns: 'returns';
+};
+declare function isFragmentDecl(item: unknown): item is FragmentDecl;
+interface GroupDecl extends Statement {
+  readonly $type: 'GroupDecl';
+  body: Block;
+  title: string;
+}
+declare const GroupDecl: {
+  readonly $type: 'GroupDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly title: 'title';
+};
+declare function isGroupDecl(item: unknown): item is GroupDecl;
+interface IfStmt extends Declaration, Statement {
+  readonly $container: IfStmt;
+  readonly $type: 'IfStmt';
+  cond: Expr;
+  otherwise?: ElseBranch;
+  then: Block;
+}
+declare const IfStmt: {
+  readonly $type: 'IfStmt';
+  readonly annotations: 'annotations';
+  readonly cond: 'cond';
+  readonly otherwise: 'otherwise';
+  readonly then: 'then';
+};
+declare function isIfStmt(item: unknown): item is IfStmt;
+type ImportDecl = UseDecl | ValueImport;
+declare const ImportDecl: {
+  readonly $type: 'ImportDecl';
+};
+declare function isImportDecl(item: unknown): item is ImportDecl;
+interface Index extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Index';
+  index: Expr;
+  receiver: Expr;
+}
+declare const Index: {
+  readonly $type: 'Index';
+  readonly index: 'index';
+  readonly receiver: 'receiver';
+};
+declare function isIndex(item: unknown): item is Index;
+interface InstantLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'InstantLit';
+  value: string;
+}
+declare const InstantLit: {
+  readonly $type: 'InstantLit';
+  readonly value: 'value';
+};
+declare function isInstantLit(item: unknown): item is InstantLit;
+interface LetStmt extends Declaration, Statement {
+  readonly $container: FnBody;
+  readonly $type: 'LetStmt';
+  args: Array<Expr>;
+  declaredType?: TypeRef;
+  kind: 'const' | 'let';
+  name: string;
+  opts?: MapLit;
+  value: Expr;
+}
+declare const LetStmt: {
+  readonly $type: 'LetStmt';
+  readonly annotations: 'annotations';
+  readonly args: 'args';
+  readonly declaredType: 'declaredType';
+  readonly kind: 'kind';
+  readonly name: 'name';
+  readonly opts: 'opts';
+  readonly value: 'value';
+};
+declare function isLetStmt(item: unknown): item is LetStmt;
+interface LifecycleDecl extends Declaration, Statement {
+  readonly $type: 'LifecycleDecl';
+  arg?: Expr;
+  body: Block;
+  event?: string;
+  hook?: 'afterEach' | 'beforeEach' | 'defer' | 'setup' | 'teardown';
+}
+declare const LifecycleDecl: {
+  readonly $type: 'LifecycleDecl';
+  readonly annotations: 'annotations';
+  readonly arg: 'arg';
+  readonly body: 'body';
+  readonly event: 'event';
+  readonly hook: 'hook';
+};
+declare function isLifecycleDecl(item: unknown): item is LifecycleDecl;
+interface ListLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'ListLit';
+  items: Array<Expr>;
+}
+declare const ListLit: {
+  readonly $type: 'ListLit';
+  readonly items: 'items';
+};
+declare function isListLit(item: unknown): item is ListLit;
+interface LiteralType$1 extends langium.AstNode {
+  readonly $container: TypeRef;
+  readonly $type: 'LiteralType';
+  value: string;
+}
+declare const LiteralType$1: {
+  readonly $type: 'LiteralType';
+  readonly value: 'value';
+};
+declare function isLiteralType(item: unknown): item is LiteralType$1;
+interface MapEntry extends langium.AstNode {
+  readonly $container: MapLit;
+  readonly $type: 'MapEntry';
+  key: MapKey;
+  value: Expr;
+}
+declare const MapEntry: {
+  readonly $type: 'MapEntry';
+  readonly key: 'key';
+  readonly value: 'value';
+};
+declare function isMapEntry(item: unknown): item is MapEntry;
+type MapKey = Word | string;
+declare function isMapKey(item: unknown): item is MapKey;
+interface MapLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | ConfigDecl | DatasetDecl | ExpectStmt | FactoryDecl | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | MatrixDecl | Member | ParallelStmt | RaceStmt | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'MapLit';
+  entries: Array<MapEntry>;
+}
+declare const MapLit: {
+  readonly $type: 'MapLit';
+  readonly entries: 'entries';
+};
+declare function isMapLit(item: unknown): item is MapLit;
+interface MatcherClause extends langium.AstNode {
+  readonly $container: ExpectStmt;
+  readonly $type: 'MatcherClause';
+  args: Array<Expr>;
+  name: string;
+  opts?: MapLit;
+}
+declare const MatcherClause: {
+  readonly $type: 'MatcherClause';
+  readonly args: 'args';
+  readonly name: 'name';
+  readonly opts: 'opts';
+};
+declare function isMatcherClause(item: unknown): item is MatcherClause;
+interface MatrixDecl extends Declaration {
+  readonly $type: 'MatrixDecl';
+  body: MapLit;
+}
+declare const MatrixDecl: {
+  readonly $type: 'MatrixDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+};
+declare function isMatrixDecl(item: unknown): item is MatrixDecl;
+interface Member extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Member';
+  member: Word | string;
+  optional: boolean;
+  receiver: Expr;
+}
+declare const Member: {
+  readonly $type: 'Member';
+  readonly member: 'member';
+  readonly optional: 'optional';
+  readonly receiver: 'receiver';
+};
+declare function isMember(item: unknown): item is Member;
+interface NamedType extends langium.AstNode {
+  readonly $container: TypeRef;
+  readonly $type: 'NamedType';
+  args: Array<TypeRef>;
+  name: QualifiedName;
+}
+declare const NamedType: {
+  readonly $type: 'NamedType';
+  readonly args: 'args';
+  readonly name: 'name';
+};
+declare function isNamedType(item: unknown): item is NamedType;
+interface NullLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'NullLit';
+}
+declare const NullLit: {
+  readonly $type: 'NullLit';
+};
+declare function isNullLit(item: unknown): item is NullLit;
+interface NumberLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'NumberLit';
+  raw: string;
+}
+declare const NumberLit: {
+  readonly $type: 'NumberLit';
+  readonly raw: 'raw';
+};
+declare function isNumberLit(item: unknown): item is NumberLit;
+interface ParallelStmt extends Declaration, Statement {
+  readonly $type: 'ParallelStmt';
+  body: Block;
+  opts?: MapLit;
+}
+declare const ParallelStmt: {
+  readonly $type: 'ParallelStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly opts: 'opts';
+};
+declare function isParallelStmt(item: unknown): item is ParallelStmt;
+interface Param extends langium.AstNode {
+  readonly $container: ParamList;
+  readonly $type: 'Param';
+  annotations: Array<Annotation>;
+  name: string;
+  paramType?: TypeRef;
+}
+declare const Param: {
+  readonly $type: 'Param';
+  readonly annotations: 'annotations';
+  readonly name: 'name';
+  readonly paramType: 'paramType';
+};
+declare function isParam(item: unknown): item is Param;
+interface ParamList extends langium.AstNode {
+  readonly $container: DecoDecl | FnDecl | FnExpr | FragmentDecl;
+  readonly $type: 'ParamList';
+  params: Array<Param>;
+}
+declare const ParamList: {
+  readonly $type: 'ParamList';
+  readonly params: 'params';
+};
+declare function isParamList(item: unknown): item is ParamList;
+type QualifiedName = string;
+declare function isQualifiedName(item: unknown): item is QualifiedName;
+interface RaceStmt extends Declaration, Statement {
+  readonly $type: 'RaceStmt';
+  body: Block;
+  opts?: MapLit;
+}
+declare const RaceStmt: {
+  readonly $type: 'RaceStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly opts: 'opts';
+};
+declare function isRaceStmt(item: unknown): item is RaceStmt;
+interface Ref extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Ref';
+  name: RefName;
+}
+declare const Ref: {
+  readonly $type: 'Ref';
+  readonly name: 'name';
+};
+declare function isRef(item: unknown): item is Ref;
+type RefName = 'flow' | 'matrix' | 'step' | string;
+declare function isRefName(item: unknown): item is RefName;
+interface RepeatStmt extends Declaration, Statement {
+  readonly $type: 'RepeatStmt';
+  body: Block;
+  count: Expr;
+  index?: string;
+}
+declare const RepeatStmt: {
+  readonly $type: 'RepeatStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly count: 'count';
+  readonly index: 'index';
+};
+declare function isRepeatStmt(item: unknown): item is RepeatStmt;
+interface ReportDecl extends Declaration {
+  readonly $type: 'ReportDecl';
+  reporters: Array<Expr>;
+}
+declare const ReportDecl: {
+  readonly $type: 'ReportDecl';
+  readonly annotations: 'annotations';
+  readonly reporters: 'reporters';
+};
+declare function isReportDecl(item: unknown): item is ReportDecl;
+interface ReturnStmt extends Statement {
+  readonly $type: 'ReturnStmt';
+  value?: Expr;
+}
+declare const ReturnStmt: {
+  readonly $type: 'ReturnStmt';
+  readonly annotations: 'annotations';
+  readonly value: 'value';
+};
+declare function isReturnStmt(item: unknown): item is ReturnStmt;
+interface RunStmt extends Declaration, Statement {
+  readonly $type: 'RunStmt';
+  args?: ArgList;
+  bind?: string;
+  target: QualifiedName;
+}
+declare const RunStmt: {
+  readonly $type: 'RunStmt';
+  readonly annotations: 'annotations';
+  readonly args: 'args';
+  readonly bind: 'bind';
+  readonly target: 'target';
+};
+declare function isRunStmt(item: unknown): item is RunStmt;
+type SingleType = LiteralType$1 | NamedType;
+declare const SingleType: {
+  readonly $type: 'SingleType';
+};
+declare function isSingleType(item: unknown): item is SingleType;
+interface Statement extends langium.AstNode {
+  readonly $type: 'ActionCall' | 'BreakStmt' | 'CaptureStmt' | 'ContinueStmt' | 'ExpectStmt' | 'ForEachStmt' | 'GroupDecl' | 'IfStmt' | 'LetStmt' | 'LifecycleDecl' | 'ParallelStmt' | 'RaceStmt' | 'RepeatStmt' | 'ReturnStmt' | 'RunStmt' | 'Statement' | 'StepDecl' | 'TryStmt' | 'WhileStmt';
+  annotations: Array<Annotation>;
+}
+declare const Statement: {
+  readonly $type: 'Statement';
+  readonly annotations: 'annotations';
+};
+declare function isStatement(item: unknown): item is Statement;
+interface StepDecl extends Statement {
+  readonly $type: 'StepDecl';
+  body: Block;
+  title: string;
+}
+declare const StepDecl: {
+  readonly $type: 'StepDecl';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly title: 'title';
+};
+declare function isStepDecl(item: unknown): item is StepDecl;
+interface StringLit extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'StringLit';
+  value: string;
+}
+declare const StringLit: {
+  readonly $type: 'StringLit';
+  readonly value: 'value';
+};
+declare function isStringLit(item: unknown): item is StringLit;
+interface Ternary extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Ternary';
+  condition: Expr;
+  otherwise: Expr;
+  then: Expr;
+}
+declare const Ternary: {
+  readonly $type: 'Ternary';
+  readonly condition: 'condition';
+  readonly otherwise: 'otherwise';
+  readonly then: 'then';
+};
+declare function isTernary(item: unknown): item is Ternary;
+interface TryStmt extends Declaration, Statement {
+  readonly $type: 'TryStmt';
+  body: Block;
+  error?: string;
+  finalizer?: Block;
+  handler?: Block;
+}
+declare const TryStmt: {
+  readonly $type: 'TryStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly error: 'error';
+  readonly finalizer: 'finalizer';
+  readonly handler: 'handler';
+};
+declare function isTryStmt(item: unknown): item is TryStmt;
+interface TypeBody extends langium.AstNode {
+  readonly $container: TypeDecl;
+  readonly $type: 'TypeBody';
+  fields: Array<FieldDecl>;
+}
+declare const TypeBody: {
+  readonly $type: 'TypeBody';
+  readonly fields: 'fields';
+};
+declare function isTypeBody(item: unknown): item is TypeBody;
+interface TypeDecl extends Declaration {
+  readonly $type: 'TypeDecl';
+  alias?: TypeRef;
+  body?: TypeBody;
+  name: string;
+}
+declare const TypeDecl: {
+  readonly $type: 'TypeDecl';
+  readonly alias: 'alias';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly name: 'name';
+};
+declare function isTypeDecl(item: unknown): item is TypeDecl;
+interface TypeRef extends langium.AstNode {
+  readonly $container: DatasetDecl | FieldDecl | FnDecl | FnExpr | FragmentDecl | LetStmt | NamedType | Param | TypeDecl;
+  readonly $type: 'TypeRef';
+  members: Array<SingleType>;
+}
+declare const TypeRef: {
+  readonly $type: 'TypeRef';
+  readonly members: 'members';
+};
+declare function isTypeRef(item: unknown): item is TypeRef;
+interface Unary extends langium.AstNode {
+  readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+  readonly $type: 'Unary';
+  operand: Expr;
+  operator: '!' | '-';
+}
+declare const Unary: {
+  readonly $type: 'Unary';
+  readonly operand: 'operand';
+  readonly operator: 'operator';
+};
+declare function isUnary(item: unknown): item is Unary;
+interface UseDecl extends langium.AstNode {
+  readonly $container: Document;
+  readonly $type: 'UseDecl';
+  alias?: string;
+  pkg: string;
+}
+declare const UseDecl: {
+  readonly $type: 'UseDecl';
+  readonly alias: 'alias';
+  readonly pkg: 'pkg';
+};
+declare function isUseDecl(item: unknown): item is UseDecl;
+interface ValueImport extends langium.AstNode {
+  readonly $container: Document;
+  readonly $type: 'ValueImport';
+  default?: string;
+  export: boolean;
+  names: Array<string>;
+  path: string;
+  wildcard?: string;
+}
+declare const ValueImport: {
+  readonly $type: 'ValueImport';
+  readonly default: 'default';
+  readonly export: 'export';
+  readonly names: 'names';
+  readonly path: 'path';
+  readonly wildcard: 'wildcard';
+};
+declare function isValueImport(item: unknown): item is ValueImport;
+interface WhileStmt extends Declaration, Statement {
+  readonly $type: 'WhileStmt';
+  body: Block;
+  cond: Expr;
+}
+declare const WhileStmt: {
+  readonly $type: 'WhileStmt';
+  readonly annotations: 'annotations';
+  readonly body: 'body';
+  readonly cond: 'cond';
+};
+declare function isWhileStmt(item: unknown): item is WhileStmt;
+type Word = 'afterEach' | 'all' | 'as' | 'beforeEach' | 'break' | 'capture' | 'catch' | 'config' | 'const' | 'continue' | 'dataset' | 'deco' | 'defer' | 'else' | 'expect' | 'factory' | 'finally' | 'flow' | 'fn' | 'forEach' | 'fragment' | 'from' | 'group' | 'if' | 'import' | 'in' | 'let' | 'matrix' | 'module' | 'not' | 'on' | 'parallel' | 'pub' | 'race' | 'repeat' | 'report' | 'return' | 'run' | 'setup' | 'soft' | 'step' | 'teardown' | 'try' | 'type' | 'use' | 'while' | string;
+declare function isWord(item: unknown): item is Word;
+type VennAstType = {
+  ActionCall: ActionCall;
+  Annotation: Annotation;
+  Arg: Arg;
+  ArgList: ArgList;
+  Binary: Binary;
+  Block: Block;
+  BoolLit: BoolLit;
+  BreakStmt: BreakStmt;
+  Call: Call;
+  CaptureStmt: CaptureStmt;
+  ConfigDecl: ConfigDecl;
+  ContinueStmt: ContinueStmt;
+  DatasetDecl: DatasetDecl;
+  Declaration: Declaration;
+  DecoDecl: DecoDecl;
+  Document: Document;
+  ElseBranch: ElseBranch;
+  ExpectStmt: ExpectStmt;
+  Expr: Expr;
+  FactoryDecl: FactoryDecl;
+  FieldDecl: FieldDecl;
+  FlowDecl: FlowDecl;
+  FnBody: FnBody;
+  FnDecl: FnDecl;
+  FnExpr: FnExpr;
+  ForEachStmt: ForEachStmt;
+  FragmentDecl: FragmentDecl;
+  GroupDecl: GroupDecl;
+  IfStmt: IfStmt;
+  ImportDecl: ImportDecl;
+  Index: Index;
+  InstantLit: InstantLit;
+  LetStmt: LetStmt;
+  LifecycleDecl: LifecycleDecl;
+  ListLit: ListLit;
+  LiteralType: LiteralType$1;
+  MapEntry: MapEntry;
+  MapLit: MapLit;
+  MatcherClause: MatcherClause;
+  MatrixDecl: MatrixDecl;
+  Member: Member;
+  NamedType: NamedType;
+  NullLit: NullLit;
+  NumberLit: NumberLit;
+  ParallelStmt: ParallelStmt;
+  Param: Param;
+  ParamList: ParamList;
+  RaceStmt: RaceStmt;
+  Ref: Ref;
+  RepeatStmt: RepeatStmt;
+  ReportDecl: ReportDecl;
+  ReturnStmt: ReturnStmt;
+  RunStmt: RunStmt;
+  SingleType: SingleType;
+  Statement: Statement;
+  StepDecl: StepDecl;
+  StringLit: StringLit;
+  Ternary: Ternary;
+  TryStmt: TryStmt;
+  TypeBody: TypeBody;
+  TypeDecl: TypeDecl;
+  TypeRef: TypeRef;
+  Unary: Unary;
+  UseDecl: UseDecl;
+  ValueImport: ValueImport;
+  WhileStmt: WhileStmt;
+};
+declare class VennAstReflection extends langium.AbstractAstReflection {
+  readonly types: {
+    readonly ActionCall: {
+      readonly name: "ActionCall";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly call: {
+          readonly name: "call";
+          readonly optional: true;
+        };
+        readonly called: {
+          readonly name: "called";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+        readonly target: {
+          readonly name: "target";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly Annotation: {
+      readonly name: "Annotation";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly Arg: {
+      readonly name: "Arg";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+          readonly optional: true;
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ArgList: {
+      readonly name: "ArgList";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly Binary: {
+      readonly name: "Binary";
+      readonly properties: {
+        readonly left: {
+          readonly name: "left";
+        };
+        readonly operator: {
+          readonly name: "operator";
+        };
+        readonly right: {
+          readonly name: "right";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly Block: {
+      readonly name: "Block";
+      readonly properties: {
+        readonly stmts: {
+          readonly name: "stmts";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["ElseBranch"];
+    };
+    readonly BoolLit: {
+      readonly name: "BoolLit";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly BreakStmt: {
+      readonly name: "BreakStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly Call: {
+      readonly name: "Call";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly optional: true;
+        };
+        readonly callee: {
+          readonly name: "callee";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly CaptureStmt: {
+      readonly name: "CaptureStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly ConfigDecl: {
+      readonly name: "ConfigDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly ContinueStmt: {
+      readonly name: "ContinueStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly DatasetDecl: {
+      readonly name: "DatasetDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly declaredType: {
+          readonly name: "declaredType";
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly Declaration: {
+      readonly name: "Declaration";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly DecoDecl: {
+      readonly name: "DecoDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly export: {
+          readonly name: "export";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly Document: {
+      readonly name: "Document";
+      readonly properties: {
+        readonly decls: {
+          readonly name: "decls";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly imports: {
+          readonly name: "imports";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ElseBranch: {
+      readonly name: "ElseBranch";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly ExpectStmt: {
+      readonly name: "ExpectStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly checks: {
+          readonly name: "checks";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly matcher: {
+          readonly name: "matcher";
+          readonly optional: true;
+        };
+        readonly modifier: {
+          readonly name: "modifier";
+          readonly optional: true;
+        };
+        readonly negate: {
+          readonly name: "negate";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly subject: {
+          readonly name: "subject";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly Expr: {
+      readonly name: "Expr";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly FactoryDecl: {
+      readonly name: "FactoryDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly FieldDecl: {
+      readonly name: "FieldDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly fieldType: {
+          readonly name: "fieldType";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly FlowDecl: {
+      readonly name: "FlowDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly title: {
+          readonly name: "title";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly FnBody: {
+      readonly name: "FnBody";
+      readonly properties: {
+        readonly locals: {
+          readonly name: "locals";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly result: {
+          readonly name: "result";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly FnDecl: {
+      readonly name: "FnDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly export: {
+          readonly name: "export";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly optional: true;
+        };
+        readonly returns: {
+          readonly name: "returns";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly FnExpr: {
+      readonly name: "FnExpr";
+      readonly properties: {
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly params: {
+          readonly name: "params";
+        };
+        readonly returns: {
+          readonly name: "returns";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly ForEachStmt: {
+      readonly name: "ForEachStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly item: {
+          readonly name: "item";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+        readonly source: {
+          readonly name: "source";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly FragmentDecl: {
+      readonly name: "FragmentDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly export: {
+          readonly name: "export";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly optional: true;
+        };
+        readonly returns: {
+          readonly name: "returns";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly GroupDecl: {
+      readonly name: "GroupDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly title: {
+          readonly name: "title";
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly IfStmt: {
+      readonly name: "IfStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly cond: {
+          readonly name: "cond";
+        };
+        readonly otherwise: {
+          readonly name: "otherwise";
+          readonly optional: true;
+        };
+        readonly then: {
+          readonly name: "then";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement", "ElseBranch"];
+    };
+    readonly ImportDecl: {
+      readonly name: "ImportDecl";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly Index: {
+      readonly name: "Index";
+      readonly properties: {
+        readonly index: {
+          readonly name: "index";
+        };
+        readonly receiver: {
+          readonly name: "receiver";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly InstantLit: {
+      readonly name: "InstantLit";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly LetStmt: {
+      readonly name: "LetStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly declaredType: {
+          readonly name: "declaredType";
+          readonly optional: true;
+        };
+        readonly kind: {
+          readonly name: "kind";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly LifecycleDecl: {
+      readonly name: "LifecycleDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly arg: {
+          readonly name: "arg";
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly event: {
+          readonly name: "event";
+          readonly optional: true;
+        };
+        readonly hook: {
+          readonly name: "hook";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly ListLit: {
+      readonly name: "ListLit";
+      readonly properties: {
+        readonly items: {
+          readonly name: "items";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly LiteralType: {
+      readonly name: "LiteralType";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["SingleType"];
+    };
+    readonly MapEntry: {
+      readonly name: "MapEntry";
+      readonly properties: {
+        readonly key: {
+          readonly name: "key";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly MapLit: {
+      readonly name: "MapLit";
+      readonly properties: {
+        readonly entries: {
+          readonly name: "entries";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly MatcherClause: {
+      readonly name: "MatcherClause";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly MatrixDecl: {
+      readonly name: "MatrixDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly Member: {
+      readonly name: "Member";
+      readonly properties: {
+        readonly member: {
+          readonly name: "member";
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly receiver: {
+          readonly name: "receiver";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly NamedType: {
+      readonly name: "NamedType";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["SingleType"];
+    };
+    readonly NullLit: {
+      readonly name: "NullLit";
+      readonly properties: {};
+      readonly superTypes: ["Expr"];
+    };
+    readonly NumberLit: {
+      readonly name: "NumberLit";
+      readonly properties: {
+        readonly raw: {
+          readonly name: "raw";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly ParallelStmt: {
+      readonly name: "ParallelStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly Param: {
+      readonly name: "Param";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly paramType: {
+          readonly name: "paramType";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ParamList: {
+      readonly name: "ParamList";
+      readonly properties: {
+        readonly params: {
+          readonly name: "params";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly RaceStmt: {
+      readonly name: "RaceStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly opts: {
+          readonly name: "opts";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly Ref: {
+      readonly name: "Ref";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly RepeatStmt: {
+      readonly name: "RepeatStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly count: {
+          readonly name: "count";
+        };
+        readonly index: {
+          readonly name: "index";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly ReportDecl: {
+      readonly name: "ReportDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly reporters: {
+          readonly name: "reporters";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly ReturnStmt: {
+      readonly name: "ReturnStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly value: {
+          readonly name: "value";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly RunStmt: {
+      readonly name: "RunStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly args: {
+          readonly name: "args";
+          readonly optional: true;
+        };
+        readonly bind: {
+          readonly name: "bind";
+          readonly optional: true;
+        };
+        readonly target: {
+          readonly name: "target";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly SingleType: {
+      readonly name: "SingleType";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly Statement: {
+      readonly name: "Statement";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly StepDecl: {
+      readonly name: "StepDecl";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly title: {
+          readonly name: "title";
+        };
+      };
+      readonly superTypes: ["Statement"];
+    };
+    readonly StringLit: {
+      readonly name: "StringLit";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly Ternary: {
+      readonly name: "Ternary";
+      readonly properties: {
+        readonly condition: {
+          readonly name: "condition";
+        };
+        readonly otherwise: {
+          readonly name: "otherwise";
+        };
+        readonly then: {
+          readonly name: "then";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly TryStmt: {
+      readonly name: "TryStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly error: {
+          readonly name: "error";
+          readonly optional: true;
+        };
+        readonly finalizer: {
+          readonly name: "finalizer";
+          readonly optional: true;
+        };
+        readonly handler: {
+          readonly name: "handler";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+    readonly TypeBody: {
+      readonly name: "TypeBody";
+      readonly properties: {
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly TypeDecl: {
+      readonly name: "TypeDecl";
+      readonly properties: {
+        readonly alias: {
+          readonly name: "alias";
+          readonly optional: true;
+        };
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+          readonly optional: true;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["Declaration"];
+    };
+    readonly TypeRef: {
+      readonly name: "TypeRef";
+      readonly properties: {
+        readonly members: {
+          readonly name: "members";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly Unary: {
+      readonly name: "Unary";
+      readonly properties: {
+        readonly operand: {
+          readonly name: "operand";
+        };
+        readonly operator: {
+          readonly name: "operator";
+        };
+      };
+      readonly superTypes: ["Expr"];
+    };
+    readonly UseDecl: {
+      readonly name: "UseDecl";
+      readonly properties: {
+        readonly alias: {
+          readonly name: "alias";
+          readonly optional: true;
+        };
+        readonly pkg: {
+          readonly name: "pkg";
+        };
+      };
+      readonly superTypes: ["ImportDecl"];
+    };
+    readonly ValueImport: {
+      readonly name: "ValueImport";
+      readonly properties: {
+        readonly default: {
+          readonly name: "default";
+          readonly optional: true;
+        };
+        readonly export: {
+          readonly name: "export";
+          readonly defaultValue: false;
+          readonly optional: true;
+        };
+        readonly names: {
+          readonly name: "names";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly path: {
+          readonly name: "path";
+        };
+        readonly wildcard: {
+          readonly name: "wildcard";
+          readonly optional: true;
+        };
+      };
+      readonly superTypes: ["ImportDecl"];
+    };
+    readonly WhileStmt: {
+      readonly name: "WhileStmt";
+      readonly properties: {
+        readonly annotations: {
+          readonly name: "annotations";
+          readonly defaultValue: [];
+          readonly optional: true;
+        };
+        readonly body: {
+          readonly name: "body";
+        };
+        readonly cond: {
+          readonly name: "cond";
+        };
+      };
+      readonly superTypes: ["Declaration", "Statement"];
+    };
+  };
+}
+declare const reflection: VennAstReflection;
+//#endregion
+//#region src/ast/call-args.d.ts
+/**
+ * The arguments of a call, however it was written.
+ *
+ * The language spells a call two ways, `conn.close()` with brackets and
+ * `http.get "url"` without, and the parser keeps them in different places on
+ * the node. They are the same call with the same arguments, so every reader
+ * downstream asks here and sees one list.
+ */
+declare function callArgs(call: ActionCall): readonly Expr[];
+//#endregion
+//#region src/ast/dotted-path.d.ts
+/**
+ * The dotted name an expression spells, such as `http.get` or
+ * `data.faker.uuid`.
+ *
+ * The parser cannot tell a namespace from a field: `res.status` and `http.get`
+ * are the same shape. Only a registry knows which is which, so the name is
+ * carried this far as text and asked about there.
+ *
+ * @returns The dotted name, or `undefined` when the expression is not a plain
+ *   chain of identifiers.
+ */
+declare function dottedPath(expr: Expr | AstNode$1 | undefined): string | undefined;
+//#endregion
+//#region src/ast/is-statement.d.ts
+/**
+ * Whether a top-level node runs, or merely defines.
+ *
+ * A `flow`, a `fn`, a `type` are definitions: they exist for something else to
+ * reach. Everything else at the top of a file is a statement, and statements
+ * run in the order they are written. That holds in a script, where the file is
+ * the program, and in a test file, so the same lines mean the same thing in
+ * both.
+ */
+declare function isRunnable(node: Declaration): node is Declaration & Statement;
+//#endregion
+//#region src/ast/split-call.d.ts
+/** A call's arguments, told apart: what it takes, and what configures it. */
+interface SplitCall {
+  args: readonly Expr[];
+  opts?: MapLit;
+}
+/**
+ * Tell a verb's positional arguments from its options map.
+ *
+ * The language spells one call two ways, and the trailing `{ … }` means the
+ * same in both: `http.get "url" { headers }` and `http.get("url", { headers })`
+ * are the same request. Only the first spelling puts the map somewhere the
+ * parser can label, so the second is disambiguated here.
+ *
+ * A map beyond the declared positionals is the options; a map *within* them is
+ * an argument. `db.seed({ users: […] })` passes a map because seeding is what
+ * it does, and that must never be read as configuration.
+ *
+ * @param takes How many positional arguments the verb declares.
+ */
+declare function splitCall(args: readonly Expr[], takes: number): SplitCall;
+//#endregion
+//#region src/ast/walk.d.ts
+/** Every descendant of `root`, depth-first, for whole-document passes. */
+declare function walkAst(root: AstNode$1): AstNode$1[];
+//#endregion
+//#region src/problem/diff.types.d.ts
+/**
+ * One field of a structured comparison. Fields that agree are carried too: what
+ * makes a diff readable is the one line that moved standing among the ones that
+ * did not.
+ */
+interface DiffEntry {
+  /** Where the field sits under the subject: `.status`, `[2]`, `.items[0].id`. */
+  path: string;
+  expected: string;
+  actual: string;
+  same: boolean;
+}
+/** Structured expected-vs-actual (§16), never a `toString`. */
+type Diff = {
+  kind: "scalar";
+  expected: string;
+  actual: string;
+} | {
+  kind: "json";
+  path: string;
+  expected: unknown;
+  actual: unknown;
+} | {
+  kind: "text";
+  expected: string;
+  actual: string;
+} |
+/** The two sides walked field by field; a list position counts as a field. */
+{
+  kind: "fields";
+  label: string;
+  entries: readonly DiffEntry[];
+};
+//#endregion
+//#region src/problem/build-diff.d.ts
+/**
+ * Turn the two sides a producer compared into a {@link Diff}. Two structures are
+ * walked field by field, so the failure names the field that moved instead of
+ * printing the same rendering twice; anything else stays a plain pair.
+ */
+declare function buildDiff(args: {
+  /** Heading for the field-by-field form. */
+  label: string;
+  expected: unknown;
+  actual: unknown;
+  /**
+   * Whether the two sides correspond position by position. Pass `false` for a
+   * comparison that does not, such as `contains`. See {@link walkable}.
+   */
+  aligned?: boolean;
+}): Diff;
+//#endregion
+//#region src/problem/format-value.d.ts
+/**
+ * One side of a diff, rendered the way the language shows values: strings quoted
+ * so `"1"` never reads as `1`, structures as compact JSON. Never `[object
+ * Object]`, because a failure that hides what it compared is not a report.
+ */
+declare function formatValue(value: unknown): string;
+//#endregion
+//#region src/problem/span.types.d.ts
+/** The exact location of a problem in a source file (1-based line/column). */
+interface Span {
+  uri: string;
+  offset: number;
+  length: number;
+  line: number;
+  column: number;
+}
+//#endregion
+//#region src/problem/related.types.d.ts
+/** A secondary location, e.g. "here it was declared as…". */
+interface RelatedInfo {
+  span: Span;
+  label: string;
+}
+//#endregion
+//#region src/problem/severity.types.d.ts
+/** How loudly a problem is reported. Only `error` fails a run. */
+type Severity = "error" | "warning" | "hint";
+//#endregion
+//#region src/problem/problem.types.d.ts
+/**
+ * The single shape shared by compile diagnostics and runtime failures, so one
+ * renderer serves terminal, editor, and UI (§16). Optional fields are populated
+ * as each producer has the information.
+ */
+interface Problem {
+  code: string;
+  severity: Severity;
+  title: string;
+  span: Span;
+  help?: string;
+  related?: RelatedInfo[];
+  diff?: Diff;
+  note?: string;
+  docs?: string;
+}
+//#endregion
+//#region src/problem/problem-error.d.ts
+/**
+ * Carries a {@link Problem} across a throw boundary at runtime. Catch it to
+ * recover the structured problem; `message` is only the title.
+ */
+declare class ProblemError extends Error {
+  readonly problem: Problem;
+  constructor(problem: Problem);
+}
+//#endregion
+//#region src/codes/code.types.d.ts
+/** A catalog entry: a stable code plus its default severity. */
+interface CodeSpec {
+  code: string;
+  severity: Severity;
+}
+//#endregion
+//#region src/codes/build-problem.d.ts
+/** Construct a {@link Problem} from a catalog spec plus location and message. */
+declare function buildProblem(args: {
+  spec: CodeSpec;
+  span: Span;
+  title: string;
+  help?: string;
+  related?: RelatedInfo[];
+  diff?: Diff;
+  note?: string;
+}): Problem;
+//#endregion
+//#region src/codes/catalog.d.ts
+/**
+ * Every VNxxxx the kernel itself can raise. Codes are stable, googlable, and
+ * documented; families follow the leading digit (1 lex/syntax … 8 timeout).
+ */
+declare const CODES: {
+  readonly VN1001_LEX: {
+    readonly code: "VN1001";
+    readonly severity: "error";
+  };
+  readonly VN1002_PARSE: {
+    readonly code: "VN1002";
+    readonly severity: "error";
+  };
+  readonly VN2003_UNKNOWN_ACTION: {
+    readonly code: "VN2003";
+    readonly severity: "error";
+  };
+  readonly VN2004_UNKNOWN_MATCHER: {
+    readonly code: "VN2004";
+    readonly severity: "error";
+  };
+  readonly VN2005_UNKNOWN_FRAGMENT: {
+    readonly code: "VN2005";
+    readonly severity: "error";
+  };
+  readonly VN2006_UNKNOWN_ENV: {
+    readonly code: "VN2006";
+    readonly severity: "error";
+  };
+  readonly VN2007_NAMESPACE_NOT_IMPORTED: {
+    readonly code: "VN2007";
+    readonly severity: "error";
+  };
+  readonly VN2008_UNCALLED_ACTION: {
+    readonly code: "VN2008";
+    readonly severity: "error";
+  };
+  readonly VN2009_NOT_EXPORTED: {
+    readonly code: "VN2009";
+    readonly severity: "error";
+  };
+  readonly VN2013_UNKNOWN_DECORATOR: {
+    readonly code: "VN2013";
+    readonly severity: "error";
+  };
+  readonly VN2014_DECORATOR_TARGET: {
+    readonly code: "VN2014";
+    readonly severity: "error";
+  };
+  readonly VN2015_DECO_SIGNATURE: {
+    readonly code: "VN2015";
+    readonly severity: "error";
+  };
+  readonly VN2016_DECO_IMPURE: {
+    readonly code: "VN2016";
+    readonly severity: "error";
+  };
+  readonly VN2017_DECO_VERB: {
+    readonly code: "VN2017";
+    readonly severity: "error";
+  };
+  readonly VN3001_UNKNOWN_OPTION: {
+    readonly code: "VN3001";
+    readonly severity: "error";
+  };
+  readonly VN3010_TYPE_MISMATCH: {
+    readonly code: "VN3010";
+    readonly severity: "error";
+  };
+  readonly VN3012_UNIT_MISMATCH: {
+    readonly code: "VN3012";
+    readonly severity: "error";
+  };
+  readonly VN3013_NOT_CALLABLE: {
+    readonly code: "VN3013";
+    readonly severity: "error";
+  };
+  readonly VN3014_STILL_WAITING: {
+    readonly code: "VN3014";
+    readonly severity: "error";
+  };
+  readonly VN3015_NOT_A_LIST: {
+    readonly code: "VN3015";
+    readonly severity: "error";
+  };
+  readonly VN3016_NOT_A_NUMBER: {
+    readonly code: "VN3016";
+    readonly severity: "error";
+  };
+  readonly VN3017_DECO_ARGUMENTS: {
+    readonly code: "VN3017";
+    readonly severity: "error";
+  };
+  readonly VN5001_REMOVED_KEYWORD: {
+    readonly code: "VN5001";
+    readonly severity: "error";
+  };
+  readonly VN6001_ASSERTION_FAILED: {
+    readonly code: "VN6001";
+    readonly severity: "error";
+  };
+  readonly VN7001_ACTION_FAILED: {
+    readonly code: "VN7001";
+    readonly severity: "error";
+  };
+  readonly VN7004_HOOK_FAILED: {
+    readonly code: "VN7004";
+    readonly severity: "error";
+  };
+  readonly VN8002_LOOP_LIMIT: {
+    readonly code: "VN8002";
+    readonly severity: "error";
+  };
+};
+//#endregion
+//#region src/expr/eval-env.types.d.ts
+/**
+ * The scope the evaluator reads from: `let`/`const`, captures, parameters.
+ *
+ * Actions and matchers are deliberately absent. They belong to the runtime
+ * registry, which keeps the evaluator pure and free of protocol execution.
+ */
+interface EvalEnv {
+  lookup(name: string): unknown;
+}
+//#endregion
+//#region src/compile/compile.types.d.ts
+/**
+ * A compiled expression: everything the source decided is already captured, so
+ * running it needs only the environment.
+ */
+type Thunk = (env: EvalEnv) => unknown;
+/** A function body, compiled: its local bindings in order, then its result. */
+interface CompiledBody {
+  /** Every name that gets a slot: the parameters first, then the locals. */
+  readonly names: readonly string[];
+  /** How many names spill past the frame's inline slots. Usually none. */
+  readonly extra: number;
+  /** Every name the body reads but does not bind, in cell order. */
+  readonly free: readonly string[];
+  /**
+   * The body binds one name, reads nothing else, and asks for nothing by text,
+   * so a call hands the argument straight to `result` with no frame between.
+   */
+  readonly bare: boolean;
+  readonly locals: readonly CompiledLocal[];
+  readonly result: Thunk;
+}
+/** One of the body's `let` bindings, compiled. Filled in declaration order. */
+interface CompiledLocal {
+  /** Which slot of the frame this local writes to. */
+  readonly slot: number;
+  readonly value: Thunk;
+}
+//#endregion
+//#region src/expr/cell.types.d.ts
+/**
+ * A binding's storage, addressed once and read many times.
+ *
+ * The language has no assignment, so a name never changes what it holds, but it
+ * can be *filled in* after the function reading it was built. A recursive `fn`
+ * is the plain case: `fib` becomes a value before the name `fib` is bound, so
+ * anything resolved eagerly would capture nothing. The cell is handed out empty
+ * and filled when the binding happens, which is what lets a name be resolved at
+ * compile time and still read the right value.
+ */
+interface Cell {
+  value: unknown;
+}
+/** An environment that can hand out a cell per name: the top of the chain. */
+interface CellEnv extends EvalEnv {
+  cell(name: string): Cell;
+}
+/** Whether this environment addresses its bindings by cell. */
+declare function hasCells(env: EvalEnv): env is CellEnv;
+//#endregion
+//#region src/expr/closure.types.d.ts
+/** The brand that tells a function value apart from a map that happens to look like one. */
+declare const CLOSURE: unique symbol;
+/**
+ * A function value: its parameter names, its compiled body, and the environment
+ * it was defined in.
+ *
+ * Because `fn` is pure (§08), a closure runs entirely in the evaluator, which
+ * is what makes functions first-class and callable from any expression,
+ * interpolation included.
+ *
+ * The body arrives already compiled. A `fn (…) => …` written inside `map` is
+ * evaluated once per call to `map`, so compiling there would put the compiler
+ * back in the hot loop.
+ */
+interface Closure {
+  readonly [CLOSURE]: true;
+  readonly params: readonly string[];
+  readonly body: CompiledBody;
+  readonly env: EvalEnv;
+  /**
+   * A cell per free name of the body, resolved when this value was made.
+   * Absent when the defining environment does not address bindings by cell: a
+   * function nested inside another, whose free names live in its frame.
+   */
+  readonly up?: readonly Cell[];
+}
+//#endregion
+//#region src/compile/compile.d.ts
+/**
+ * Compile an expression into a function of the environment.
+ *
+ * Memoised per node, so asking twice for the same expression hands back the
+ * same thunk.
+ *
+ * @returns A thunk: give it an environment and it produces the value.
+ */
+declare function compileExpr(expr: Expr): Thunk;
+/**
+ * Build the function value for a top-level `fn name(…)`.
+ *
+ * The body is compiled against `env`, which is what lets a recursive
+ * declaration reach its own name: the cell is handed out before the binding
+ * that fills it exists.
+ *
+ * @returns The closure, ready to be bound under the declaration's name.
+ */
+declare function closureOfDecl(decl: FnDecl, env: EvalEnv): Closure;
+//#endregion
+//#region src/events/run-plan.types.d.ts
+/** One step of a {@link RunPlan}. */
+interface PlannedStep {
+  title: string;
+}
+/** One flow of a {@link RunPlan}, with the steps it will take. */
+interface PlannedFlow {
+  title: string;
+  steps: PlannedStep[];
+}
+/**
+ * What the run intends to do, carried on `run.started`. The UI draws it in
+ * grey before anything executes, so the shape of the run is visible up front.
+ */
+interface RunPlan {
+  flows: PlannedFlow[];
+}
+//#endregion
+//#region src/events/status.types.d.ts
+/** Where a flow, step or action stands when an event reports it. */
+type Status = "passed" | "failed" | "skipped" | "running";
+//#endregion
+//#region src/events/event-data.types.d.ts
+/**
+ * The payload per event kind. EventKind is DERIVED from these keys, so adding an
+ * event is a single edit here. This is the M1 subset of the §15 taxonomy.
+ */
+interface EventData {
+  "run.started": {
+    plan: RunPlan;
+  };
+  "run.finished": {
+    passed: number;
+    failed: number;
+    durationMs: number;
+  };
+  "flow.started": {
+    title: string;
+  };
+  "flow.finished": {
+    title: string;
+    status: Status;
+  };
+  "flow.retrying": {
+    title: string;
+    attempt: number;
+    reason: string;
+  };
+  "step.started": {
+    title: string;
+  };
+  "step.finished": {
+    title: string;
+    status: Status;
+  };
+  "action.started": {
+    namespace: string;
+    action: string;
+  };
+  "action.finished": {
+    namespace: string;
+    action: string;
+    status: Status;
+    durationMs: number;
+  };
+  "expect.passed": {
+    source: string;
+  };
+  "expect.failed": {
+    problem: Problem;
+  };
+  log: {
+    level: string;
+    message: string;
+  };
+}
+/** Every event name, derived from {@link EventData}. */
+type EventKind = keyof EventData;
+//#endregion
+//#region src/events/ids.types.d.ts
+/** A run identifier (ULID). Branded so it is not confused with a plain string. */
+type RunId = string & {
+  readonly __brand: "RunId";
+};
+/**
+ * A node path derived from `@id`, e.g. "checkout/flow-checkout/step-cart".
+ *
+ * The join key across the node graph, the editor margin, and the execution
+ * tree. Never a numeric index: an edit would silently desync history.
+ */
+type NodePath = string & {
+  readonly __brand: "NodePath";
+};
+//#endregion
+//#region src/events/envelope.types.d.ts
+/** The single contract between runner, host, and UI. Everything else derives from it. */
+interface Envelope<K extends EventKind = EventKind> {
+  /** Monotonic per run; the UI detects a gap and asks for a resync. */
+  seq: number;
+  /** ISO-8601 with milliseconds, from the runner's clock. */
+  ts: string;
+  run: RunId;
+  kind: K;
+  node?: NodePath;
+  parent?: NodePath;
+  /** Which parallel worker emitted this, so interleaved output can be split. */
+  worker?: number;
+  data: EventData[K];
+}
+//#endregion
+//#region src/expand/handles/handle.types.d.ts
+/**
+ * What a `deco` decorates, written as the type of its first parameter.
+ *
+ * These are the words the language uses about itself. A decorator author says
+ * `target: Fn` and never learns that the compiler calls that node a `FnDecl`,
+ * which is the whole reason this vocabulary exists.
+ */
+type TargetKind = "Fn" | "Flow" | "Step" | "Binding" | "Type" | "Node";
+/**
+ * The value a decorator body holds for its target: named members over the real
+ * declaration. Reading one may refuse, so the members are defined as getters.
+ */
+type TargetHandle = Record<string, unknown>;
+/** What a handle is, for a caller holding one: its kind and every name it answers to. */
+interface HandleSurface {
+  readonly kind: TargetKind;
+  readonly offered: readonly string[];
+}
+//#endregion
+//#region src/expand/handles/kind-of.d.ts
+/** Every kind a `deco` may name, in the order a diagnostic should list them. */
+declare const TARGET_KINDS: readonly TargetKind[];
+/** What kind of thing a node is, in the language's own words. */
+declare function kindOf(node: AstNode$1): TargetKind;
+/** Whether a written type name is one of the kinds. */
+declare function isTargetKind(name: string): name is TargetKind;
+//#endregion
+//#region src/expand/handles/make-handle.d.ts
+/**
+ * The typed mutable handle a decorator holds: verbs over the real declaration.
+ *
+ * Built like the native members of a list or a string, as a table of names and a
+ * value produced on read, because that is what it is: the built-in members of
+ * one more kind of value, whose receiver happens to be a piece of the program
+ * rather than a piece of its data.
+ *
+ * Every verb any kind has is installed. The ones this kind lacks throw a
+ * `ProblemError` naming the surface it does offer, so a reach for the wrong verb
+ * is refused rather than read as nothing.
+ */
+declare function makeHandle(args: {
+  node: AstNode$1;
+  kind: TargetKind;
+}): TargetHandle;
+/**
+ * What this handle answers to, or nothing when the value is not one.
+ *
+ * A getter can only refuse a name some kind has; a name no kind has would still
+ * read as nothing. The caller that reaches for one asks here instead, so
+ * `target.wobble` is refused in the same sentence as `target.addParam`.
+ */
+declare function handleSurface(value: unknown): HandleSurface | undefined;
+//#endregion
+//#region src/expand/accepted-kinds.d.ts
+/** The parameter that *is* the target: the first one, always. */
+declare function decoTarget(decl: DecoDecl): Param | undefined;
+/**
+ * The kinds a `deco` decorates, read off the type on its first parameter.
+ *
+ * The signature is the only statement of what a decorator is for; a separate
+ * list of node names would drift from it. Empty means the signature never said
+ * (no parameter, or one typed with something that is not a kind). That fault is
+ * reported where the `deco` is declared, so a use site stays quiet about a
+ * mistake it did not make.
+ *
+ * @returns the kinds the first parameter's type names, in written order.
+ */
+declare function acceptedKinds(decl: DecoDecl): readonly TargetKind[];
+//#endregion
+//#region src/expr/closure.d.ts
+/** Whether this value is a `fn`. The brand distinguishes it from a lookalike map. */
+declare function isClosure(value: unknown): value is Closure;
+/**
+ * An environment nested in `parent`, holding the given bindings.
+ *
+ * Only own properties of `bindings` count as bound, so a name such as
+ * `toString` resolves through to the parent rather than to JavaScript's own.
+ */
+declare function childEnv(parent: EvalEnv, bindings: Record<string, unknown>): EvalEnv;
+//#endregion
+//#region src/expr/evaluate.d.ts
+/**
+ * Evaluate a kernel expression against an injected environment.
+ *
+ * Compilation happens once per node and is remembered, so calling this in a
+ * loop pays for the tree only on the first pass.
+ *
+ * @returns The value, or a promise for it when the expression reached something
+ * that has not arrived yet.
+ * @throws ProblemError When the expression fails: a unit mismatch, a value that
+ * is not callable, or a placeholder that does not parse.
+ */
+declare function evaluate(expr: Expr, env: EvalEnv): unknown;
+//#endregion
+//#region src/expr/native.types.d.ts
+declare const NATIVE: unique symbol;
+/** A callable backed by a host function rather than by Venn source. */
+interface NativeFn {
+  readonly [NATIVE]: true;
+  call(values: readonly unknown[]): unknown;
+}
+/** Whether this value is a host-backed callable. */
+declare function isNativeFn(value: unknown): value is NativeFn;
+/**
+ * Wrap a host function so the language can call it.
+ *
+ * The wrapper takes the whole argument list: arity is the host function's own
+ * business, and a plugin verb reads what it needs and ignores the rest.
+ */
+declare function nativeFn(call: (values: readonly unknown[]) => unknown): NativeFn;
+//#endregion
+//#region src/expr/invoke.d.ts
+/**
+ * Call any Venn callable, a `fn` closure or a built-in method, with values.
+ *
+ * A callee declaring fewer parameters than it is handed ignores the rest.
+ *
+ * @throws ProblemError VN3013 when the value is not callable.
+ */
+declare function invoke(callee: unknown, values: readonly unknown[]): unknown;
+/** Whether {@link invoke} can call this, asked before committing to a call. */
+declare function isCallable(value: unknown): boolean;
+/**
+ * Call with a single value, without building an argument list for it.
+ *
+ * One argument is what most calls carry, and the array holding it would live
+ * exactly as long as the call takes to read it out again.
+ *
+ * @throws ProblemError VN3013 when the value is not callable.
+ */
+declare function invoke1(callee: unknown, arg: unknown): unknown;
+/**
+ * Run a closure's compiled body against the given argument values.
+ *
+ * One allocation for the call: the frame itself. The names, the body and every
+ * expression in it were settled when the function was compiled.
+ *
+ * @returns The body's result, or a promise for it when the body reached
+ * something that has not arrived yet.
+ */
+declare function callClosure(closure: Closure, values: readonly unknown[]): unknown;
+//#endregion
+//#region src/expr/member-value.d.ts
+/**
+ * One member of a value: `xs.len`, `m.user`, `target.wrap`.
+ *
+ * A map's own data wins; a list or a string only ever has built-in members.
+ * Lives here rather than in the compiler because the compiler is not the only
+ * reader: a decorator body reaches a handle's verbs by the same rule, and two
+ * spellings of "what does `.x` mean" would drift apart.
+ *
+ * @returns The member's value, undefined when there is none, or a promise when
+ * the receiver has not arrived yet.
+ */
+declare function memberValue(receiver: unknown, member: string): unknown;
+//#endregion
+//#region src/expr/namespace.d.ts
+/**
+ * A plugin namespace as a value (`fmt`, `data`, `crypto`), so its verbs can be
+ * called from any expression: `print(fmt.table(rows))`.
+ *
+ * Marked, because a name the user binds must still win over a namespace of the
+ * same name, and a bare `data.faker.uuid` must still read as a call rather than
+ * as the function itself.
+ */
+declare function namespaceValue(members: Record<string, unknown>): Record<string, unknown>;
+/** Whether this value is a namespace rather than an ordinary map. */
+declare function isNamespaceValue(value: unknown): boolean;
+//#endregion
+//#region src/units/unit.types.d.ts
+/**
+ * Unit-typed values.
+ *
+ * Each holds a canonical base unit (milliseconds, bytes, a ratio in 0..1, epoch
+ * milliseconds), so arithmetic never converts and only display does. The `kind`
+ * field is the brand that keeps a unit from reading as an ordinary map.
+ */
+/** Which unit a value carries. */
+type UnitKind = "duration" | "size" | "percent";
+/** A length of time, held in milliseconds. */
+interface Duration {
+  readonly kind: "duration";
+  readonly ms: number;
+}
+/** A quantity of data, held in bytes. */
+interface Size {
+  readonly kind: "size";
+  readonly bytes: number;
+}
+/** A proportion, held as a ratio in 0..1 rather than as 0..100. */
+interface Percent {
+  readonly kind: "percent";
+  readonly ratio: number;
+}
+/** A point in time. The source ISO text is kept so printing it back is exact. */
+interface Instant {
+  readonly kind: "instant";
+  readonly epochMs: number;
+  readonly iso: string;
+}
+/** Any value carrying a unit. */
+type UnitValue = Duration | Size | Percent;
+//#endregion
+//#region src/units/combine.d.ts
+/** Anything arithmetic accepts: a plain number, or a number carrying a unit. */
+type Numeric = number | UnitValue;
+/** Why two operands would not combine: the operator, and the kind of each side. */
+type UnitMismatch = {
+  op: string;
+  left: string;
+  right: string;
+};
+/** The outcome of {@link combine}: the value, or the mismatch behind VN3012. */
+type CombineResult = {
+  ok: true;
+  value: Numeric | boolean;
+} | {
+  ok: false;
+  mismatch: UnitMismatch;
+};
+/**
+ * Combine two numerics with an operator, checking that their units agree.
+ *
+ * `300ms + 1s` succeeds; `300ms + 2mb` reports a mismatch. Never throws: the
+ * caller decides whether a mismatch is a problem and where to point at it.
+ *
+ * @returns The combined value, or the mismatch that stopped it.
+ */
+declare function combine(args: {
+  op: string;
+  left: Numeric;
+  right: Numeric;
+}): CombineResult;
+//#endregion
+//#region src/units/parse-instant.d.ts
+/**
+ * Read an ISO-8601 lexeme into an {@link Instant}, keeping the source text.
+ *
+ * A lexeme that does not parse takes epoch 0 rather than NaN, so comparing two
+ * instants stays total. The grammar has already accepted the shape by here.
+ */
+declare function parseInstant(iso: string): Instant;
+//#endregion
+//#region src/units/parse-number.d.ts
+/**
+ * Read a NUMBER lexeme into the value it denotes.
+ *
+ * Accepts digit grouping and an optional unit suffix: "200", "1_000", "300ms",
+ * "2mb", "50%". A lexeme with no recognised suffix reads as a plain number.
+ *
+ * @returns A number, or the `UnitValue` the suffix asks for.
+ */
+declare function parseNumber(raw: string): number | UnitValue;
+//#endregion
+//#region src/units/unit-guards.d.ts
+/** Whether this value carries a unit: a duration, a size or a percent. */
+declare function isUnitValue(value: unknown): value is UnitValue;
+/** Whether this value is a point in time. */
+declare function isInstant(value: unknown): value is Instant;
+//#endregion
+//#region src/expr/prelude.d.ts
+/**
+ * Render a value the way `print` and `str` do: a string as itself, anything
+ * else as JSON. A value JSON cannot hold falls back to its plain text rather
+ * than throwing, because printing must never be the thing that fails a flow.
+ */
+declare function display(value: unknown): string;
+/**
+ * The name of a value's type, as the language talks about it: "null", "list",
+ * "fn", "map", "bool", "string", "number", or a unit's own kind.
+ */
+declare function typeName(value: unknown): string;
+/**
+ * The whole prelude of values: what has no receiver to hang off.
+ *
+ * `len(xs)`, `sum(xs)`, `keys(m)` and `round(x, 2)` are deliberately absent:
+ * they read better as `xs.len`, `xs.sum`, `m.keys` and `x.round(2)`, and a
+ * second spelling would only be a second way to say the same thing. Those names
+ * are also exactly the ones a script wants to bind (`const sum = …`), and a
+ * binding would silently shadow them.
+ */
+declare const PRELUDE_VALUES: Readonly<Record<string, unknown>>;
+//#endregion
+//#region src/expand/deco/deco-env.d.ts
+/**
+ * What a decorator body can see: its own parameters, its own `let`s, and the
+ * prelude.
+ *
+ * Nothing else, and deliberately so. The body runs before the program exists: no
+ * flow has started and no plugin has been asked for anything, so a name it did
+ * not bind itself cannot mean anything yet. The runner says exactly that instead
+ * of quietly evaluating to nothing.
+ */
+declare class DecoEnv implements EvalEnv {
+  private readonly bindings;
+  constructor(bindings: Record<string, unknown>);
+  lookup(name: string): unknown;
+  bind(name: string, value: unknown): void;
+}
+//#endregion
+//#region src/expand/deco/deco.types.d.ts
+/**
+ * A `deco`'s parameter list, read as what it means: the first parameter is the
+ * thing decorated and its type is what may be decorated; the rest are the
+ * decorator's own arguments, bound from `@name(…)`.
+ */
+interface DecoSignature {
+  /** The name the body calls its target by. */
+  readonly target: string;
+  /** The kinds the declared type allows. Several when it is a union. */
+  readonly kinds: readonly TargetKind[];
+  /** The remaining parameter names, in the order `@name(…)` fills them. */
+  readonly args: readonly string[];
+}
+/** A signature that reads, or the one-line reason it does not. */
+type SignatureResult = {
+  readonly ok: true;
+  readonly signature: DecoSignature;
+} | {
+  readonly ok: false;
+  readonly title: string;
+};
+/**
+ * A `pub deco` another file exported, with the file it was written in.
+ *
+ * The uri travels with the declaration because a fault in it (a signature that
+ * does not read, a verb its kind has not got) belongs to the line that wrote it,
+ * not to the line that imported it.
+ */
+interface ImportedDeco {
+  readonly decl: DecoDecl;
+  readonly uri: string;
+}
+/** Everything running one decorator's body needs. */
+interface DecoBodyArgs {
+  readonly body: Block;
+  readonly env: DecoEnv;
+  readonly uri: string;
+  readonly reject: (problem: Problem) => void;
+}
+//#endregion
+//#region src/expand/expand.types.d.ts
+/**
+ * A node a decorator may be attached to, as the decorator sees it.
+ *
+ * Deliberately structural: a decorator receives the real tree, not a copy and
+ * not a facade, so it can read anything the grammar produced and rewrite it.
+ * `$type` is how it knows what it is holding.
+ */
+type DecoratedNode = AstNode$1;
+/** What a decorator writes for the runtime to read later. */
+type NodeMeta = Record<string, unknown>;
+/**
+ * Everything a decorator is handed when it runs.
+ *
+ * Expansion happens once, between parsing and everything else, so a decorator
+ * sees the whole program before a single statement has run. What it leaves
+ * behind is what the checker checks and the runtime runs.
+ */
+interface ExpandContext {
+  /** The node carrying this decorator. */
+  readonly node: DecoratedNode;
+  /** The arguments, evaluated: `@retry(2, { backoff: 500ms })` gives `[2, {…}]`. */
+  readonly args: readonly unknown[];
+  /** The same arguments as syntax, for a decorator that transforms rather than reads. */
+  readonly written: readonly DecoratedNode[];
+  /** Where the node sits, for a decorator that needs to look around or reattach. */
+  readonly parent: DecoratedNode | undefined;
+  /** Put this node in place of the decorated one. */
+  replace(node: DecoratedNode): void;
+  /** Take the decorated node out of the tree entirely. */
+  remove(): void;
+  /** Leave something for the runtime, keyed by name. */
+  meta(key: string, value: unknown): void;
+  /** Refuse the program, in the language's own error vocabulary. */
+  reject(args: {
+    code: string;
+    title: string;
+  }): void;
+}
+/**
+ * A decorator: a named transformation of the tree, contributed by the kernel or
+ * by a plugin, and applied wherever a program writes `@name`.
+ */
+interface DecoratorDefinition {
+  readonly name: string;
+  readonly doc?: string;
+  /**
+   * The `$type`s this may decorate, such as `["FlowDecl", "StepDecl"]`. Omitted
+   * means anywhere: a decorator that reads nothing about its target constrains
+   * nothing about it.
+   *
+   * Node names are the plugin author's spelling, and they stay. A TypeScript
+   * decorator is handed the raw node, so nothing shorter describes what it is
+   * able to read.
+   */
+  readonly targets?: readonly string[];
+  /**
+   * The kinds this decorates, as a `deco` declared them, read off the type of
+   * its first parameter with `acceptedKinds`. Present only for a decorator the
+   * language itself declared, and it wins over `targets`: a signature says in
+   * the user's words what a list of node names only approximates.
+   */
+  readonly accepts?: readonly TargetKind[];
+  expand(ctx: ExpandContext): void;
+}
+/** Where expansion looks a decorator up. The kernel does not know what plugins are. */
+interface DecoratorSource {
+  get(name: string): DecoratorDefinition | undefined;
+}
+/** What expansion reports. The tree itself is rewritten in place. */
+interface ExpandResult {
+  problems: Problem[];
+}
+//#endregion
+//#region src/expand/deco/deco-decorator.d.ts
+/** A `deco` and everything reporting about it needs. */
+interface DecoArgs {
+  decl: DecoDecl;
+  uri: string;
+  problems: Problem[];
+}
+/**
+ * A `deco` written in the language, as a decorator the expansion phase applies.
+ *
+ * This is the very {@link DecoratorDefinition} a plugin's TypeScript
+ * `defineDecorator` produces: one mechanism, two doors. What the signature says
+ * it decorates becomes `accepts`, so the type error for `@memoize` on a flow
+ * comes from how the author wrote the parameters rather than from a list kept by
+ * hand beside them.
+ *
+ * @returns a definition that does nothing when the signature does not read. The
+ * reason is pushed onto `args.problems` once, here, rather than at every use.
+ */
+declare function decoDecorator(args: DecoArgs): DecoratorDefinition;
+//#endregion
+//#region src/expand/deco/document-decos.d.ts
+/** Every `deco` one document can reach, and the file it is being expanded for. */
+interface DocumentDecoArgs {
+  document: Document;
+  decorators: DecoratorSource;
+  uri: string;
+  problems: Problem[];
+  /** The `pub deco`s this file's imports reach, by name. */
+  imported?: ReadonlyMap<string, ImportedDeco>;
+}
+/**
+ * The document's own `deco`s, then the ones it imported, layered over whatever
+ * the host contributed.
+ *
+ * A local declaration wins against a plugin's and against a built-in of the same
+ * name: the more local one is what the author is looking at. All of them arrive
+ * as ordinary members of one {@link DecoratorSource}, so `@memoize` resolves
+ * without expansion ever asking where a decorator came from.
+ */
+declare function withDocumentDecos(args: DocumentDecoArgs): DecoratorSource;
+//#endregion
+//#region src/expand/deco/read-signature.d.ts
+/**
+ * Read a `deco`'s parameters as what they mean.
+ *
+ * The first parameter *is* the target and its type is what may carry the
+ * decorator; the rest are the decorator's own arguments, filled by `@name(…)` in
+ * order. Nobody writing a decorator ever names a node of the compiler's tree,
+ * and what it decorates follows from the signature rather than from a list kept
+ * beside it.
+ *
+ * @returns the signature, or the one-line reason it does not read.
+ */
+declare function readSignature(decl: DecoDecl): SignatureResult;
+//#endregion
+//#region src/expand/deco/run-body.d.ts
+/**
+ * The one sentence for a verb a decorator cannot reach.
+ *
+ * Exported because the static pass notices the same thing without ever running
+ * the body, and two wordings for one fact is how they start to disagree.
+ */
+declare function impure(target: string): string;
+//#endregion
+//#region src/expand/decorate-callable.d.ts
+/**
+ * The callable a decorated `fn` binds to: its own body with every `.wrap`,
+ * `.before` and `.after` a `deco` asked for already around it.
+ *
+ * An untouched function is handed straight back, so nothing pays for a feature
+ * it did not use.
+ */
+declare function decorateCallable(node: object, base: unknown): unknown;
+//#endregion
+//#region src/expand/decorations.d.ts
+/**
+ * Where `.wrap`, `.before` and `.after` leave their closures.
+ *
+ * Prefixed, because `meta` is open to any key a decorator invents and a program
+ * that writes `target.meta "before" x` must not be mistaken for one that wrote
+ * `target.before(f)`.
+ */
+declare const AROUND_KEYS: {
+  readonly wrap: "deco.wrap";
+  readonly before: "deco.before";
+  readonly after: "deco.after";
+};
+/** The closures a `deco` asked to run around this declaration. */
+interface Decorations {
+  readonly wrap: readonly unknown[];
+  readonly before: readonly unknown[];
+  readonly after: readonly unknown[];
+}
+/**
+ * What the behavioural verbs left on this node, or nothing at all.
+ *
+ * The language has no syntax for "around this body", so `.wrap` cannot rewrite
+ * the tree the way `.addParam` does. It records a fact about the declaration
+ * and the scheduler honours it.
+ */
+declare function readDecorations(node: object): Decorations | undefined;
+/** Append one closure to a behavioural list, keeping the order they were written. */
+declare function addDecoration(node: object, key: string, fn: unknown): void;
+//#endregion
+//#region src/expand/expand.d.ts
+/**
+ * Run every decorator the program wrote, before anything else reads the program.
+ *
+ * This is the one place a `@name` means anything. The kernel does not know what
+ * `@retry` is; it knows that a name written with an `@` is looked up, handed the
+ * node it sits on, and allowed to rewrite it. Built-in decorators come through
+ * here too, so there is no shorter path for them.
+ *
+ * Applied innermost first, so a decorator that rewrites a body finds a body its
+ * own decorators have already finished with.
+ *
+ * A `deco` the document declares, or one imported from a file that wrote `pub`,
+ * joins the same source the built-ins live in before any of them run. Nothing
+ * below here can tell whether `@memoize` was written in TypeScript, in this
+ * file, or in the one next to it.
+ *
+ * @returns the problems raised. The document itself is rewritten in place.
+ */
+declare function expand(args: {
+  document: Document;
+  decorators: DecoratorSource;
+  uri?: string;
+  /** The `pub deco`s this file's imports reach, by name. */
+  imported?: ReadonlyMap<string, ImportedDeco>;
+}): ExpandResult;
+//#endregion
+//#region src/expand/node-meta.d.ts
+/**
+ * What the decorators left on this node, or nothing.
+ *
+ * Metadata rather than a rewrite is how a decorator says something the grammar
+ * has no word for. `@retry(2)` cannot be expressed as a tree of existing
+ * statements, so it is expressed as a fact about one.
+ */
+declare function metaOf(node: object): NodeMeta | undefined;
+/** Read one key, typed by the caller who knows what it wrote. */
+declare function readMeta<T>(node: object, key: string): T | undefined;
+/** Attach a fact to a node. Non-enumerable, so it never lands in a serialised AST. */
+declare function writeMeta(node: object, key: string, value: unknown): void;
+//#endregion
+//#region src/expand/node-span.d.ts
+/** Where a node sits in its file, for a Problem that has to point at it. */
+declare function spanOf(node: AstNode$1, uri: string): Span;
+//#endregion
+//#region src/expand/swap-node.d.ts
+/**
+ * Put `next` where `node` is, in its parent's list or in the field holding it.
+ * Passing nothing takes the node out of the program entirely.
+ *
+ * The write goes straight into the parent's own array or field. That is the tree
+ * the checker and the runtime read, not a copy of it, so a decorator's rewrite
+ * is indistinguishable downstream from source the author wrote.
+ */
+declare function swapNode(node: AstNode$1, next: AstNode$1 | undefined): void;
+//#endregion
+//#region src/expand/wrong-kind.d.ts
+/** The kinds a signature allows, read as prose: "a function or a flow". */
+declare function kindWords(kinds: readonly TargetKind[]): string;
+/** Every kind, listed for an author who has to pick one. */
+declare function everyKindWritten(): string;
+/**
+ * What a node is called for someone reading a message.
+ *
+ * A plugin's decorator may name any node it is able to read, so an unlisted one
+ * has its word derived rather than printed: `FlowDecl` is the compiler talking
+ * to itself, and a word nobody ever typed has no business on a user's screen.
+ */
+declare function nodeWord(type: string): string;
+/** "@memoize decorates a function, and this is a flow." */
+declare function wrongKindTitle(args: {
+  name: string;
+  kinds: readonly TargetKind[];
+  node: AstNode$1;
+}): string;
+/**
+ * The same sentence for a plugin's decorator, whose reach is a list of node
+ * types. It still reads as prose: what the author wrote is what they are told
+ * about, and the list they never wrote stays out of it.
+ */
+declare function wrongTargetTitle(args: {
+  name: string;
+  targets: readonly string[];
+  node: AstNode$1;
+}): string;
+/**
+ * Why a `@name` does not belong on this node, if it does not.
+ *
+ * Nothing when the signature never said which kinds it takes: that is a fault
+ * committed once, where the `deco` is written, and repeating it at every use
+ * site would bury the one message that can be acted on.
+ */
+declare function wrongKind(args: {
+  name: string;
+  kinds: readonly TargetKind[];
+  node: AstNode$1;
+}): string | undefined;
+//#endregion
+//#region src/format/format.types.d.ts
+/** How to format a `.vn` file. Mirrors the `[format]` table of `venn.toml`. */
+interface FormatOptions {
+  /** Spaces per indent level. Ignored when {@link useTabs} is on. */
+  indentWidth: number;
+  useTabs: boolean;
+  /** Move every `use` above every `import`. */
+  organizeHeader: boolean;
+  /** Sort each header group alphabetically. */
+  sortHeader: boolean;
+}
+/** What the formatter does when `venn.toml` says nothing. */
+declare const DEFAULT_FORMAT: FormatOptions;
+//#endregion
+//#region src/format/format-text.d.ts
+/**
+ * Format a `.vn` source: group the header, then re-indent. Line-oriented by
+ * design, so it never joins or splits lines. That makes it idempotent, and a
+ * one-line block stays on one line.
+ */
+declare function formatText(source: string, options?: Partial<FormatOptions>): string;
+//#endregion
+//#region src/format/from-settings.d.ts
+/** The shape of the `[format]` table, loose enough for a parsed TOML record. */
+interface FormatTable {
+  indent?: unknown;
+  tabs?: unknown;
+  organize?: unknown;
+  sort?: unknown;
+}
+/**
+ * Map the raw `[format]` table of `venn.toml` onto formatter options. Keys the
+ * project did not set are dropped, so the defaults survive the merge.
+ */
+declare function formatOptionsFrom(settings: FormatTable | undefined): Partial<FormatOptions>;
+//#endregion
+//#region src/format/organize-header.d.ts
+/**
+ * Put every `use` above every `import`. A comment sitting directly on top of a
+ * line travels with it; a comment separated by a blank line is left where the
+ * header begins, so nothing is silently re-attached to the wrong statement.
+ */
+declare function organizeHeader(lines: readonly string[], sort: boolean): string[];
+//#endregion
+//#region src/format/reindent.d.ts
+/**
+ * Re-indent by bracket depth. Venn statements are newline terminated, so this
+ * only ever rewrites the leading whitespace of a line. It never joins or splits
+ * lines, which makes it idempotent by construction.
+ *
+ * @param unit The string for one indent level, either spaces or a tab.
+ */
+declare function reindent(lines: readonly string[], unit: string): string[];
+//#endregion
+//#region src/generated/module.d.ts
+declare const VennLanguageMetaData: {
+  readonly languageId: 'venn';
+  readonly fileExtensions: readonly [".vn"];
+  readonly caseInsensitive: false;
+  readonly mode: 'development';
+};
+declare const VennGeneratedSharedModule: Module<LangiumSharedCoreServices, LangiumGeneratedSharedCoreServices>;
+declare const VennGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices>;
+//#endregion
+//#region src/graph/graph.types.d.ts
+/** A node in the visual graph derived from the AST (§22). */
+interface GraphNode {
+  id: string;
+  kind: string;
+  label: string;
+  parent?: string;
+}
+/** A directed edge between two graph nodes (sequential flow or branch). */
+interface GraphEdge {
+  from: string;
+  to: string;
+  label?: string;
+}
+/** The graph the editor renders: nodes plus edges, derived purely from the AST. */
+interface Graph {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+//#endregion
+//#region src/graph/to-graph.d.ts
+/** Derive the node graph (§22) from a parsed document — a pure AST transform. */
+declare function toGraph(doc: Document): Graph;
+//#endregion
+//#region src/interpolation/template.types.d.ts
+/** One `${…}`, resolved from text to something the evaluator can just run. */
+interface TemplateHole {
+  /** The placeholder's source, kept for the error when it does not parse. */
+  readonly source: string;
+  /** The parsed expression, or undefined when the source is not one. */
+  readonly expr: Expr | undefined;
+}
+/**
+ * A string literal split once into the text around its placeholders and what
+ * fills them. `chunks` has exactly one more entry than `holes`: `chunks[i]`
+ * comes before `holes[i]`, and the last chunk is the tail.
+ */
+interface Template {
+  readonly chunks: readonly string[];
+  readonly holes: readonly TemplateHole[];
+}
+//#endregion
+//#region src/interpolation/compile-template.d.ts
+/**
+ * Split a string literal into the constant text around its placeholders and the
+ * parsed expression filling each one.
+ *
+ * @param text The literal's value, placeholders included.
+ * @returns The template, memoised: the same text always yields the same object.
+ */
+declare function compileTemplate(text: string): Template;
+//#endregion
+//#region src/interpolation/interpolation.types.d.ts
+/**
+ * One `${…}` placeholder found inside a string, located precisely enough to
+ * highlight, hover and jump to what is written inside it.
+ *
+ * Offsets are relative to the text handed to the scanner, so the runtime can
+ * scan the cooked value while the language server scans the raw source token.
+ * One description of what `${…}` means, serving both.
+ */
+interface InterpolationSlot {
+  /** Offset of the opening `${`. */
+  start: number;
+  /** Offset just past the closing `}`. */
+  end: number;
+  /** The expression source between the braces, trimmed. */
+  source: string;
+  /** Offset of {@link source} itself, past `${` and any leading blanks. */
+  sourceStart: number;
+}
+//#endregion
+//#region src/interpolation/scan-interpolations.d.ts
+/**
+ * Find every `${…}` placeholder in a string.
+ *
+ * The single description of where interpolation starts and stops: the evaluator
+ * substitutes what this returns, and the language server colours, hovers and
+ * resolves the very same spans. An unclosed `${` ends the scan, so the text
+ * after it is ordinary characters.
+ *
+ * @returns The slots, in the order they appear.
+ */
+declare function scanInterpolations(text: string): InterpolationSlot[];
+//#endregion
+//#region src/lang/default-services.d.ts
+/**
+ * The Langium core services that `parse()` uses, built once on first call.
+ * Constructing the Chevrotain parser is the expensive part of a first parse,
+ * so it must not happen per document.
+ */
+declare function vennServices(): LangiumCoreServices;
+//#endregion
+//#region src/lang/venn-lexer.d.ts
+/**
+ * Makes `NL` (a newline or `;`) significant between statements, but suppresses
+ * it inside `( )` and `[ ]` so calls, arg lists and list literals may still
+ * span multiple physical lines. Blocks and maps (`{ }`) keep their newlines.
+ */
+declare class VennLexer extends DefaultLexer {
+  tokenize(text: string, options?: TokenizeOptions): LexerResult;
+}
+//#endregion
+//#region src/lang/venn-module.d.ts
+/**
+ * Build the Langium core services on `EmptyFileSystem`, so no `node:*` is
+ * touched and this runs in both the CLI (Node) and the LSP (Web Worker).
+ *
+ * `production` skips Chevrotain's grammar validation, which dominates the cost
+ * of a first parse and only ever checks generated code against itself. That
+ * check belongs in a test, `venn-module.test.ts`, which is why this takes a
+ * mode at all.
+ *
+ * @param mode Langium language mode; `development` re-enables the validation.
+ */
+declare function createVennServices(mode?: LanguageMetaData["mode"]): LangiumCoreServices;
+//#endregion
+//#region src/module/specifier.d.ts
+/** What a specifier written in an `import` names. */
+type SpecifierKind = "relative" | "alias" | "package";
+/**
+ * Which of the three a specifier is.
+ *
+ * The rule is Node's, so there is no `npm:` prefix and nothing new to learn:
+ * `./util.vn` is a file beside this one, `#shared/auth.vn` goes through
+ * `[paths]`, and a bare `zod` is an installed package. The shape of what is
+ * written already says which it is.
+ */
+declare function specifierKind(spec: string): SpecifierKind;
+/** Whether the specifier names an installed package rather than a file. */
+declare function isPackageSpecifier(spec: string): boolean;
+//#endregion
+//#region src/parse/parse-output.types.d.ts
+/** The result of {@link parse}: a (possibly partial) AST plus VN1xxx problems. */
+interface ParseOutput {
+  ast: Document;
+  problems: Problem[];
+}
+//#endregion
+//#region src/parse/parse.d.ts
+/**
+ * Parse `.vn` source into an AST plus VN1xxx problems. Synchronous and
+ * filesystem-free (Chevrotain error recovery keeps a partial AST on failure).
+ * It never throws: bad syntax comes back in `problems`.
+ *
+ * @param options.uri Source URI recorded on every span, for editors and reports.
+ */
+declare function parse(text: string, options?: {
+  uri?: string;
+}): ParseOutput;
+//#endregion
+//#region src/parse/parse-expression.d.ts
+/**
+ * How far {@link parseExpression} shifts CST offsets. Exported because the
+ * editor maps the parsed expression back onto the `${…}` it came from, and a
+ * hand-counted constant there would rot the moment this wrapper changes.
+ */
+declare const EXPRESSION_OFFSET: number;
+/**
+ * Parse a standalone expression by wrapping it in a minimal flow and extracting
+ * the `expect` subject. Used by string interpolation (`${…}`).
+ *
+ * @returns The expression, or `undefined` when the source does not parse.
+ */
+declare function parseExpression(source: string): Expr | undefined;
+//#endregion
+//#region src/typecheck/builtin-types.d.ts
+/** What a built-in type is, and how it reads when written. */
+interface BuiltinType {
+  /** One line, in the reader's terms rather than the compiler's. */
+  doc: string;
+  /** How it is written where a type goes. */
+  example: string;
+}
+/**
+ * The types the language brings with it, described once.
+ *
+ * These are the words a reader meets first, so the hover and the completion list
+ * read from here. A built-in that cannot explain itself is a built-in nobody
+ * discovers.
+ */
+declare const BUILTIN_TYPES: Readonly<Record<string, BuiltinType>>;
+/** Whether a name is one of the language's own types. */
+declare function isBuiltinType(name: string): boolean;
+//#endregion
+//#region src/typecheck/type.types.d.ts
+/**
+ * A static type. `dynamic` is the escape hatch for the result of a plugin
+ * action, an HTTP response, `json`: anything the checker cannot know. It unifies
+ * with everything and never produces an error, so the effectful world places no
+ * annotation burden on the pure one.
+ */
+type Type = PrimType | LiteralType | ListType | RecordType | FnType | UnionType | OpaqueType | DynamicType | TypeVar;
+type PrimName = "number" | "string" | "bool" | "null" | "void" | "duration" | "size" | "percent" | "instant";
+interface PrimType {
+  readonly kind: "prim";
+  readonly name: PrimName;
+}
+/** One value, standing for itself: `"GET"`, `200`, `true`. */
+interface LiteralType {
+  readonly kind: "literal";
+  readonly value: string | number | boolean;
+}
+interface ListType {
+  readonly kind: "list";
+  readonly element: Type;
+}
+/** One of several. What makes `"GET" | "POST"` more than a string. */
+interface UnionType {
+  readonly kind: "union";
+  readonly members: readonly Type[];
+}
+/**
+ * A handle with a name and no visible inside: a server, a browser, a connection.
+ *
+ * This is the border with the world outside. Whatever a JavaScript class really
+ * is, it arrives here as a name its own namespace's verbs understand and nothing
+ * else can open, which keeps the object graph of another language out of this
+ * one.
+ */
+interface OpaqueType {
+  readonly kind: "opaque";
+  readonly name: string;
+  /** What it publishes. Absent means a name and nothing more. */
+  readonly members?: ReadonlyMap<string, Type>;
+}
+/** A map/object with known fields. `open` records tolerate extra fields. */
+interface RecordType {
+  readonly kind: "record";
+  readonly fields: ReadonlyMap<string, Type>;
+  readonly open: boolean;
+  /**
+   * What a key nobody listed holds: `Record<string, string>` written as a type.
+   * Without it an open record answers `dynamic` for everything it did not name,
+   * which is right for a loose map and wrong for `headers`.
+   */
+  readonly rest?: Type;
+}
+/** A function: what it takes, what it gives back, and how strictly it is called. */
+interface FnType {
+  readonly kind: "fn";
+  readonly params: readonly Type[];
+  readonly result: Type;
+  /** Takes any number of arguments, as `str(a, b, c)` and `range(1, 4)` do. Its
+   * params describe the shape it accepts, not a count to enforce. */
+  readonly variadic?: boolean;
+  /** Params from this index on are handed over but may be ignored: `map` offers
+   * the index to a callback that is free to take only the item. */
+  readonly ignorableFrom?: number;
+}
+interface DynamicType {
+  readonly kind: "dynamic";
+}
+/** A unification variable. `ref` is filled in as inference solves it. */
+interface TypeVar {
+  readonly kind: "var";
+  readonly id: number;
+  ref: Type | undefined;
+}
+/** The one `dynamic`. Shared, since it carries no state to keep apart. */
+declare const DYNAMIC: DynamicType;
+/** One value standing for itself, as `"GET"` does where a type is written. */
+declare function literal(value: string | number | boolean): LiteralType;
+/** A named handle, with the surface it publishes, or a bare name without one. */
+declare function opaque(name: string, members?: ReadonlyMap<string, Type>): OpaqueType;
+/** A union of one is that one: `string | string` helps nobody read anything. */
+declare function union(members: readonly Type[]): Type;
+//#endregion
+//#region src/typecheck/context.d.ts
+/**
+ * Per-run inference state: a fresh-variable source and the list of type
+ * mismatches found. Held in a context (not a module global) so two checks never
+ * share variable ids or leak diagnostics into each other.
+ */
+interface TypeContext {
+  fresh(): TypeVar;
+  mismatches: TypeMismatch[];
+}
+/** One place where two types could not be made equal, at a source node. */
+interface TypeMismatch {
+  node: AstNode$1;
+  expected: Type;
+  actual: Type;
+  note?: string;
+  /** A unit clash rather than a plain type clash: VN3012 instead of VN3010. */
+  unit?: boolean;
+}
+/** A fresh inference context: variable ids from zero, no mismatches recorded. */
+declare function createContext(): TypeContext;
+//#endregion
+//#region src/typecheck/builtins.d.ts
+/**
+ * The type of a built-in member: a property such as `length`, or a generic
+ * method such as `map`.
+ *
+ * These are where generics earn their keep. `list<T>.map` is
+ * `fn(fn(T, number) -> U) -> list<U>`, with a fresh `U` per use.
+ *
+ * @returns undefined when the receiver's type has no such member, so the caller
+ * can fall back to a record field or to `dynamic`.
+ */
+declare function memberType(receiver: Type, name: string, ctx: TypeContext): Type | undefined;
+/**
+ * A member as the language reads it: the built-in when there is one, otherwise
+ * the field the map carries.
+ *
+ * {@link memberType} alone stops at built-ins so inference can report an unknown
+ * field. Tooling wants the answer, not the distinction.
+ */
+declare function resolveMember(receiver: Type, name: string, ctx: TypeContext): Type | undefined;
+//#endregion
+//#region src/typecheck/catalog.types.d.ts
+/**
+ * What the checker knows that the file itself does not: the types the loaded
+ * plugins contribute.
+ *
+ * The core has no idea what a plugin is, and must not: it asks this interface
+ * two questions and takes the answers. Whoever owns the registry, the runtime or
+ * the language server, is the one that can answer them.
+ */
+interface TypeCatalog {
+  /** A named type: `http.Request`. Undefined when nothing declares it. */
+  typeOf(name: string): Type | undefined;
+  /** A verb's signature: `http.serve`, `http.on`. */
+  signatureOf(target: string): FnType | undefined;
+}
+//#endregion
+//#region src/typecheck/check-types.d.ts
+/** What one check of a document produced. */
+interface CheckTypesResult {
+  problems: Problem[];
+  /** Every expression's inferred type, keyed by node, for hover. */
+  types: Map<object, Type>;
+  /** Per string literal, the expression parsed from each of its ${…} slots. */
+  slots: Map<object, (Expr | undefined)[]>;
+}
+/** What the checker may be told about the world outside the file. */
+interface CheckTypesOptions {
+  uri?: string;
+  /** The types and signatures the loaded plugins contribute. */
+  catalog?: TypeCatalog;
+  /** The `pub deco`s this file's imports reach. Without them an imported
+   * `@name` is a name the checker knows nothing about, and says nothing about. */
+  decos?: ReadonlyMap<string, ImportedDeco>;
+  /** What the names this file imports turned out to be, from the files it names. */
+  imports?: ReadonlyMap<string, Type>;
+}
+/**
+ * Infer and check the types across a document.
+ *
+ * Errors are raised only where a type is actually known. Anything touching
+ * `dynamic`, such as a plugin that published no signature or an HTTP response,
+ * is left alone, so the checker helps without ever blocking.
+ *
+ * @returns the problems found, plus the inferred type of every expression and
+ * the expressions parsed out of each `${…}`, both of which the editor reads.
+ */
+declare function checkTypes(document: Document, options?: CheckTypesOptions): CheckTypesResult;
+//#endregion
+//#region src/typecheck/imported-types.d.ts
+/** What the names a file imported turned out to be, ready to bind in its env. */
+type ImportedTypes = ReadonlyMap<string, Type>;
+interface ImportedTypesArgs {
+  document: Document;
+  uri: string;
+  /** Every module the import graph reached, already parsed, by resolved URI. */
+  modules: ReadonlyMap<string, Document>;
+  /** How a specifier written in one file names another. */
+  resolve: (from: string, spec: string) => string;
+  catalog?: TypeCatalog;
+  /**
+   * What each installed package publishes, derived from its `.d.ts`.
+   *
+   * Keyed by the specifier as written, because that is what the import says.
+   * Absent for a host that has not derived any, which is every run in an editor
+   * that has not installed anything yet.
+   */
+  packages?: ReadonlyMap<string, Record<string, TypeSpec>>;
+}
+/**
+ * The types of the names a document imports, worked out from the files it names.
+ *
+ * Each module is checked on its own, with *its* imports resolved first, so a
+ * `pub fn` that calls another file has the signature it really has. That is what
+ * lets `triplo("texto")` be refused against a `fn(number) -> number` declared
+ * one file away.
+ *
+ * @returns a type per imported name. A name whose module publishes nothing for
+ * it is simply absent, and the checker treats it as `dynamic`.
+ */
+declare function importedTypes(args: ImportedTypesArgs): ImportedTypes;
+//#endregion
+//#region src/typecheck/kind-types.d.ts
+/**
+ * The kinds, published as types.
+ *
+ * Written as data, the same data `http.Request` is written as, so the checker,
+ * the hover and the completion list read one description of what a target
+ * offers. This is the static twin of the verb tables in
+ * `expand/handles/make-handle.ts`: whatever a kind has there it has here, and
+ * `kind-types.test.ts` fails the day they stop agreeing.
+ */
+declare const KIND_SPECS: Readonly<Record<TargetKind, TypeSpec>>;
+/**
+ * The same kinds as the checker's own types, built once.
+ *
+ * Safe to share across files and across edits: a handle's surface is fixed, so
+ * none of these holds an inference variable for a later document to write into.
+ */
+declare const KIND_TYPES: ReadonlyMap<string, Type>;
+//#endregion
+//#region src/typecheck/member-docs.d.ts
+/** What a built-in member does, and how it reads. */
+interface MemberDoc {
+  doc: string;
+  example?: string;
+}
+/** Documentation for every built-in member, by the kind of value it hangs off. */
+declare const MEMBER_DOCS: Readonly<Record<string, Record<string, MemberDoc>>>;
+/** Which table of members a type answers to, if any. */
+declare function memberKind(type: Type): string | undefined;
+//#endregion
+//#region src/typecheck/prelude-types.d.ts
+/** One argument of a prelude verb, named so the editor can point at it. */
+interface PreludeArg {
+  name: string;
+  type: string;
+  doc?: string;
+  optional?: boolean;
+}
+/** What the editor needs to describe a prelude name: its type, and what it is for. */
+interface PreludeSpec {
+  /** How it reads when written out. Shown as the hover's signature. */
+  signature: string;
+  doc: string;
+  example?: string;
+  type: Type;
+  /**
+   * The arguments, one by one. `signature` above is a whole line meant to be
+   * read; these are meant to be pointed at, one at a time, as each is typed.
+   */
+  args?: readonly PreludeArg[];
+}
+/**
+ * The prelude, described once: the checker reads the types, the editor reads
+ * the prose. Two tables would drift; this one cannot.
+ */
+declare const PRELUDE_SPECS: Readonly<Record<string, PreludeSpec>>;
+/** Whether a bare name is part of the prelude: no `use` needed, always in scope. */
+declare function isPrelude(name: string): boolean;
+//#endregion
+//#region src/typecheck/show.d.ts
+/** Render one type for a hover or a diagnostic, naming variables `a`, `b`, … */
+declare function showType(type: Type): string;
+/**
+ * Several types that belong together, named as one.
+ *
+ * Rendering them one at a time restarts the alphabet each time, so the two
+ * unrelated parameters of `fn (nome, idade)` would both come back as `a`. That
+ * says they are the same type, which is the opposite of what is known.
+ */
+declare function showTypes(types: readonly Type[]): string[];
+//#endregion
+//#region src/typecheck/spec-to-type.d.ts
+/** How a `ref` finds what it points at. Returning undefined is fine: the
+ * reference degrades to `dynamic` rather than failing. */
+type ResolveRef = (name: string) => Type | undefined;
+/**
+ * Read the published form of a type into the checker's own.
+ *
+ * The wire format is plain data with no inference variables; the checker's type
+ * is a live thing that unification writes into. Keeping them apart is what lets
+ * a signature be written by hand, generated from a `.d.ts`, or shipped as JSON
+ * without any of them reaching into the compiler.
+ */
+declare function specToType(spec: TypeSpec, resolve: ResolveRef): Type;
+//#endregion
+//#region src/typecheck/unify.d.ts
+/** Follow solved variables to the type they stand for. */
+declare function prune(type: Type): Type;
+//#endregion
+//#region src/value/equals.d.ts
+/** Strict equality with no coercion: "99.00" (string) never equals 99 (number). */
+declare function strictEquals(left: unknown, right: unknown): boolean;
+//#endregion
+//#region src/value/is-numeric.d.ts
+/** True for plain numbers and unit values (duration/size/percent). */
+declare function isNumeric(value: unknown): value is Numeric;
+//#endregion
+//#region src/value/truthiness.d.ts
+/** Boolean coercion for `!`, `&&`, `||`, and `if` conditions. */
+declare function truthy(value: unknown): boolean;
+//#endregion
+//#region src/value/value.types.d.ts
+/** A runtime value in the language: primitives, unit values, lists, and maps. */
+type Value = null | boolean | number | string | UnitValue | Instant | readonly Value[] | {
+  readonly [key: string]: Value;
+};
+//#endregion
+export { AROUND_KEYS, ActionCall, Annotation, Arg, ArgList, type AstNode, BUILTIN_TYPES, Binary, Block, BoolLit, BreakStmt, type BuiltinType, CODES, Call, CaptureStmt, type Cell, type CellEnv, type CheckTypesOptions, type CheckTypesResult, type Closure, type CodeSpec, type CombineResult, type CompiledBody, ConfigDecl, ContinueStmt, DEFAULT_FORMAT, DYNAMIC, DatasetDecl, Declaration, type DecoBodyArgs, DecoDecl, type DecoSignature, type DecoratedNode, type Decorations, type DecoratorDefinition, type DecoratorSource, type Diff, type DiffEntry, Document, type DocumentDecoArgs, type Duration, EXPRESSION_OFFSET, ElseBranch, type Envelope, type EvalEnv, type EventData, type EventKind, type ExpandContext, type ExpandResult, ExpectStmt, Expr, FactoryDecl, FieldDecl, FlowDecl, FnBody, FnDecl, FnExpr, type FnType, ForEachStmt, type FormatOptions, type FormatTable, FragmentDecl, type Graph, type GraphEdge, type GraphNode, GroupDecl, type HandleSurface, IfStmt, ImportDecl, type ImportedDeco, type ImportedTypes, Index, type Instant, InstantLit, type InterpolationSlot, KIND_SPECS, KIND_TYPES, LetStmt, LifecycleDecl, ListLit, LiteralType, MEMBER_DOCS, MapEntry, MapKey, MapLit, MatcherClause, MatrixDecl, Member, type MemberDoc, NamedType, type NativeFn, type NodeMeta, type NodePath, NullLit, NumberLit, type Numeric, type OpaqueType, PRELUDE_SPECS, PRELUDE_VALUES, ParallelStmt, Param, ParamList, type ParseOutput, type Percent, type PlannedFlow, type PlannedStep, type PreludeArg, type PreludeSpec, type Problem, ProblemError, QualifiedName, RaceStmt, type RecordType, Ref, RefName, type RelatedInfo, RepeatStmt, ReportDecl, type ResolveRef, ReturnStmt, type RunId, type RunPlan, RunStmt, type Severity, type SignatureResult, SingleType, type Size, type Span, type SpecifierKind, type SplitCall, Statement, type Status, StepDecl, StringLit, TARGET_KINDS, type TargetHandle, type TargetKind, type Template, type TemplateHole, Ternary, type Thunk, TryStmt, type Type, TypeBody, type TypeCatalog, TypeDecl, TypeRef, Unary, type UnionType, type UnitKind, type UnitMismatch, type UnitValue, UseDecl, type Value, ValueImport, VennAstReflection, VennAstType, VennGeneratedModule, VennGeneratedSharedModule, VennKeywordNames, VennLanguageMetaData, VennLexer, VennTerminalNames, VennTerminals, VennTokenNames, WhileStmt, Word, acceptedKinds, addDecoration, buildDiff, buildProblem, callArgs, callClosure, checkTypes, childEnv, closureOfDecl, combine, compileExpr, compileTemplate, createContext, createVennServices, impure as decoCannotCall, decoDecorator, decoTarget, decorateCallable, display, dottedPath, evaluate, everyKindWritten, expand, formatOptionsFrom, formatText, formatValue, handleSurface, hasCells, importedTypes, invoke, invoke1, isActionCall, isAnnotation, isArg, isArgList, isBinary, isBlock, isBoolLit, isBreakStmt, isBuiltinType, isCall, isCallable, isCaptureStmt, isClosure, isConfigDecl, isContinueStmt, isDatasetDecl, isDeclaration, isDecoDecl, isDocument, isElseBranch, isExpectStmt, isExpr, isFactoryDecl, isFieldDecl, isFlowDecl, isFnBody, isFnDecl, isFnExpr, isForEachStmt, isFragmentDecl, isGroupDecl, isIfStmt, isImportDecl, isIndex, isInstant, isInstantLit, isLetStmt, isLifecycleDecl, isListLit, isLiteralType, isMapEntry, isMapKey, isMapLit, isMatcherClause, isMatrixDecl, isMember, isNamedType, isNamespaceValue, isNativeFn, isNullLit, isNumberLit, isNumeric, isPackageSpecifier, isParallelStmt, isParam, isParamList, isPrelude, isQualifiedName, isRaceStmt, isRef, isRefName, isRepeatStmt, isReportDecl, isReturnStmt, isRunStmt, isRunnable, isSingleType, isStatement, isStepDecl, isStringLit, isTargetKind, isTernary, isTryStmt, isTypeBody, isTypeDecl, isTypeRef, isUnary, isUnitValue, isUseDecl, isValueImport, isWhileStmt, isWord, kindOf, kindWords, literal, makeHandle, memberKind, memberType, memberValue, metaOf, namespaceValue, nativeFn, nodeWord, opaque, organizeHeader, parse, parseExpression, parseInstant, parseNumber, prune, readDecorations, readMeta, readSignature, reflection, reindent, resolveMember, scanInterpolations, showType, showTypes, spanOf, specToType, specifierKind, splitCall, strictEquals, swapNode, toGraph, truthy, typeName, union, vennServices, walkAst, withDocumentDecos, writeMeta, wrongKind, wrongKindTitle, wrongTargetTitle };
+//# sourceMappingURL=index.d.ts.map