@venn-lang/runtime 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["nearest","distance","bind","planOf","resume","planOf","isDefer","planOf","isDefer","problem","problem"],"sources":["../src/scheduler/signals.ts","../src/scheduler/absorb-exit.ts","../src/scheduler/aliases.ts","../src/scheduler/bind-globals.ts","../src/scheduler/bind-imports.ts","../src/scope/create-scope.ts","../src/scheduler/collect.ts","../src/scheduler/create-cleanup-list.ts","../src/scheduler/filter.ts","../src/scheduler/invocation.ts","../src/scheduler/node-span.ts","../src/scheduler/annotations.ts","../src/scheduler/bind-namespaces.ts","../src/scheduler/bind-prelude.ts","../src/scheduler/base-scope.ts","../src/scheduler/flaky.ts","../src/scheduler/run-around.ts","../src/scheduler/run-attempts.ts","../src/scheduler/unknown-option.ts","../src/scheduler/call-params.ts","../src/scheduler/declared-arity.ts","../src/scheduler/local-call.ts","../src/scheduler/settled.ts","../src/scheduler/target.ts","../src/scheduler/run-action.ts","../src/scheduler/run-bindings.ts","../src/scheduler/run-matcher.ts","../src/scheduler/run-expect.ts","../src/scheduler/concurrency.ts","../src/scheduler/opts.ts","../src/scheduler/run-foreach.ts","../src/scheduler/run-group.ts","../src/scheduler/run-if.ts","../src/scheduler/branch-engine.ts","../src/scheduler/opts-text.ts","../src/scheduler/run-parallel.ts","../src/scheduler/run-race.ts","../src/scheduler/run-repeat.ts","../src/scheduler/run-run.ts","../src/scheduler/run-step.ts","../src/scheduler/run-try.ts","../src/scheduler/run-while.ts","../src/scheduler/run-statements.ts","../src/scheduler/block-plan.ts","../src/scheduler/run-block.ts","../src/scheduler/run-lifecycle.ts","../src/scheduler/run-flow.ts","../src/scheduler/run-prologue.ts","../src/scheduler/run-document.ts","../src/scheduler/script-lifecycle.ts","../src/scheduler/run-script.ts","../src/check/check-options.ts","../src/check/check-calls.ts","../src/check/check-deco-body.ts","../src/check/check-env.ts","../src/check/check-fragment-call.ts","../src/check/check-interpolation.ts","../src/check/check-uncalled.ts","../src/check/check-document.ts","../src/check/check-imports.ts","../src/decorators/builtin-decorators.ts","../src/decorators/create-decorator-source.ts","../src/emit/create-emitter.ts","../src/emit/run-id.ts","../src/eventsink/event-sink.port.ts","../src/eventsink/memory-sink.ts","../src/eventsink/ndjson-sink.ts","../src/ports/create-port-resolver.ts","../src/registry/build-registry.ts","../src/context/action-context.ts","../src/run/create-runner.ts","../src/run/resolve-imports.ts","../src/types/create-type-catalog.ts"],"sourcesContent":["// Control-flow signals thrown to unwind loops and fragments. Deliberately not\n// Errors, so a `try/catch` in a flow re-throws them instead of treating them as\n// failures.\n\nexport class BreakSignal {}\nexport class ContinueSignal {}\nexport class ReturnSignal {\n  constructor(readonly value: unknown) {}\n}\n/** Thrown at a statement boundary when the branch's race has already been won. */\nexport class CancelSignal {}\n/**\n * Thrown by `exit`, carrying the code the host should leave with.\n *\n * A signal and not an error: a run that exits has not failed. The code it\n * carries is the whole verdict, and `exit 0` is a clean ending, which an error\n * unwinding as a failure could not express.\n */\nexport class ExitSignal {\n  constructor(readonly code: number) {}\n}\n\nexport type ControlSignal = BreakSignal | ContinueSignal | ReturnSignal | CancelSignal | ExitSignal;\n\nexport function isControlSignal(value: unknown): value is ControlSignal {\n  return (\n    value instanceof BreakSignal ||\n    value instanceof ContinueSignal ||\n    value instanceof ReturnSignal ||\n    value instanceof CancelSignal ||\n    value instanceof ExitSignal\n  );\n}\n","import type { Engine } from \"./engine.types.js\";\nimport { ExitSignal } from \"./signals.js\";\n\n/**\n * Run `body`, letting an `exit` end it.\n *\n * The exit code travels on the engine rather than on the throw, so whatever\n * wraps this still finishes the way it always does: teardowns run, `run.finished`\n * is emitted, and the host reads one number off the result. Any other error keeps\n * unwinding untouched.\n */\nexport async function absorbExit(engine: Engine, body: () => Promise<void>): Promise<void> {\n  try {\n    await body();\n  } catch (error) {\n    if (!(error instanceof ExitSignal)) throw error;\n    engine.exit = error.code;\n  }\n}\n","import { type Document, isLetStmt, isUseDecl } from \"@venn-lang/core\";\nimport type { Registry } from \"../registry/index.js\";\n\n/**\n * The namespaces this file actually brought in with `use`: the alias when one\n * was given, otherwise the namespace the package contributes. A name outside\n * this set was never imported, however well the registry knows it.\n */\nexport function collectNamespaces(document: Document, registry: Registry): Set<string> {\n  const names = new Set<string>();\n  for (const decl of document.imports) {\n    if (!isUseDecl(decl)) continue;\n    const bound = decl.alias ?? registry.namespaceOf(decl.pkg);\n    if (bound) names.add(bound);\n  }\n  return names;\n}\n\n/**\n * The names this file binds at the top level.\n *\n * `page.click()` reads like a namespace and a verb, and is neither: it is a\n * method on something the file holds. The registry has no schema for it, so it\n * is known here and verified nowhere, which beats reporting it as an unknown\n * action it plainly is not.\n */\nexport function collectBoundNames(document: Document): Set<string> {\n  const names = new Set<string>();\n  for (const decl of document.decls) {\n    if (isLetStmt(decl)) names.add(decl.name);\n  }\n  return names;\n}\n\n/** `use \"venn/http\" as h` → `{ h → \"http\" }`, resolved through the registry. */\nexport function collectAliases(document: Document, registry: Registry): Map<string, string> {\n  const aliases = new Map<string, string>();\n  for (const decl of document.imports) {\n    if (!isUseDecl(decl) || !decl.alias) continue;\n    const namespace = registry.namespaceOf(decl.pkg);\n    if (namespace) aliases.set(decl.alias, namespace);\n  }\n  return aliases;\n}\n","import {\n  closureOfDecl,\n  type Document,\n  decorateCallable,\n  evaluate,\n  isFnDecl,\n  isLetStmt,\n  type LetStmt,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\n\n/**\n * Bind every top-level `fn` as a callable closure. Hoisted so a function can be\n * called before its textual position, and so functions may reference each other\n * regardless of order.\n *\n * A `deco` that asked to `wrap` one is honoured here, at the only moment the\n * function becomes a value: the name a caller reaches is already the decorated\n * one, so a middleware cannot be stepped around by calling from somewhere else.\n */\nexport function bindFunctions(doc: Document, scope: Scope): void {\n  for (const decl of doc.decls) {\n    if (isFnDecl(decl)) scope.set(decl.name, decorateCallable(decl, closureOfDecl(decl, scope)));\n  }\n}\n\n/**\n * Bind top-level functions and the plain `const`/`let` globals every flow can\n * read without anything having run yet.\n *\n * Only pure values. One that calls a verb is a statement, and statements run in\n * the prologue, in order and once, before the flows: opening a database is\n * something a program *does*, not something a name quietly is.\n */\nexport function bindGlobals(doc: Document, scope: Scope): void {\n  bindFunctions(doc, scope);\n  bindPlainValues(doc, scope);\n}\n\n/**\n * The `const`/`let` globals, evaluated where they stand.\n *\n * Separate from the functions because the order matters across files: a function\n * is hoisted and reads its scope when it is *called*, while a value is read now,\n * so anything a value might depend on has to be in place first.\n */\nexport function bindPlainValues(doc: Document, scope: Scope): void {\n  for (const decl of doc.decls) {\n    if (isLetStmt(decl) && isPlainValue(decl)) scope.set(decl.name, evaluate(decl.value, scope));\n  }\n}\n\nfunction isPlainValue(decl: LetStmt): boolean {\n  return decl.args.length === 0 && !decl.opts;\n}\n","import {\n  type Document,\n  isFnDecl,\n  isPackageSpecifier,\n  isValueImport,\n  type ValueImport,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { bindFunctions, bindPlainValues } from \"./bind-globals.js\";\n\n/** The files an import graph reached, and how one file names another. */\nexport interface ImportGraph {\n  modules: ReadonlyMap<string, Document>;\n  resolve: (from: string, spec: string) => string;\n  /** What each npm specifier loaded to, already a value. */\n  npm?: ReadonlyMap<string, Record<string, unknown>>;\n}\n\n/**\n * Bind the names a document imported, each to the value its own module made.\n *\n * A `pub fn` is a closure over the file it was written in (it calls that file's\n * private helpers and reads that file's globals) so it cannot simply be lifted\n * into the importer's scope. Each module gets a scope of its own, built the same\n * way the entry document's is, and the importer takes only the names it asked\n * for out of it.\n *\n * Three passes over every module at once, not one walk per import: two files\n * that call each other are ordinary, and no single order resolves them. Filling\n * every scope first and wiring afterwards has no order to get wrong, because a\n * function captures the scope object and wiring mutates that same object.\n *\n * Call this before the document's own globals are bound, so a local name of the\n * same spelling wins. That is the rule fragments already follow.\n */\nexport function bindImports(args: {\n  document: Document;\n  uri: string;\n  scope: Scope;\n  graph: ImportGraph;\n  /** How the scope a module is read in gets made: the same one the entry gets. */\n  base: () => Scope;\n}): void {\n  const built = new Map<string, Scope>();\n  for (const [uri, module] of args.graph.modules) {\n    const scope = args.base();\n    built.set(uri, scope);\n    bindFunctions(module, scope);\n  }\n  for (const [uri, module] of args.graph.modules) {\n    wire({ document: module, uri, into: scopeAt(built, uri), graph: args.graph, built });\n  }\n  // Last, because a value is read where it stands: whatever it names, local\n  // function or imported one, has to be in place by now.\n  for (const [uri, module] of args.graph.modules) bindPlainValues(module, scopeAt(built, uri));\n  wire({ document: args.document, uri: args.uri, into: args.scope, graph: args.graph, built });\n}\n\nfunction scopeAt(built: ReadonlyMap<string, Scope>, uri: string): Scope {\n  return built.get(uri) as Scope;\n}\n\ninterface Wiring {\n  document: Document;\n  uri: string;\n  into: Scope;\n  graph: ImportGraph;\n  built: ReadonlyMap<string, Scope>;\n}\n\nfunction wire(args: Wiring): void {\n  for (const decl of args.document.imports) {\n    if (!isValueImport(decl)) continue;\n    if (isPackageSpecifier(decl.path)) {\n      takePackage({ decl, graph: args.graph, into: args.into });\n      continue;\n    }\n    const from = args.graph.resolve(args.uri, decl.path);\n    const module = args.graph.modules.get(from);\n    const source = args.built.get(from);\n    if (module && source) take({ decl, module, source, into: args.into });\n  }\n}\n\n/**\n * The names an installed package published.\n *\n * Everything it exports is fair game: a package has no `pub`, its exports *are*\n * what it made public, so unlike a `.vn` module there is nothing to filter\n * against. `default` is bound too, under whichever name the import gave it,\n * because that is the only name it has here.\n */\nfunction takePackage(args: { decl: ValueImport; graph: ImportGraph; into: Scope }): void {\n  const module = args.graph.npm?.get(args.decl.path);\n  if (!module) return;\n  if (args.decl.wildcard) return void args.into.set(args.decl.wildcard, { ...module });\n  if (args.decl.default) return void args.into.set(args.decl.default, module.default);\n  for (const name of args.decl.names) {\n    if (name in module) args.into.set(name, module[name]);\n  }\n}\n\nfunction take(args: { decl: ValueImport; module: Document; source: Scope; into: Scope }): void {\n  const exported = exportedFunctions(args.module);\n  if (args.decl.wildcard) {\n    args.into.set(args.decl.wildcard, gathered(exported, args.source));\n    return;\n  }\n  // Only what the module offered. Reaching a private name would work here and\n  // then stop working the day that file rearranges its own insides.\n  for (const name of args.decl.names) {\n    if (exported.has(name)) args.into.set(name, args.source.lookup(name));\n  }\n}\n\n/** `import * as u`: one value holding everything the module published. */\nfunction gathered(names: ReadonlySet<string>, source: Scope): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const name of names) out[name] = source.lookup(name);\n  return out;\n}\n\n/** The names a module made `pub` that are values a caller can hold. */\nfunction exportedFunctions(document: Document): Set<string> {\n  const names = new Set<string>();\n  for (const decl of document.decls) {\n    if (isFnDecl(decl) && decl.export) names.add(decl.name);\n  }\n  return names;\n}\n","import type { Cell } from \"@venn-lang/core\";\nimport type { Scope } from \"./scope.types.js\";\n\n/**\n * A lexical scope.\n *\n * A class, not an object literal: a `forEach` over 50k items builds 50k scopes,\n * and a literal allocates a closure per method for each of them. One prototype\n * does for all.\n *\n * Bindings live in cells rather than as bare values, so a compiled function can\n * address one once and read it by index on every call after. The cell exists as\n * soon as anyone asks for it, which is what lets a recursive `fn` work: the\n * closure asks for its own name while being built, before the binding fills it.\n */\nclass MapScope implements Scope {\n  private readonly vars = new Map<string, Cell>();\n\n  constructor(private readonly parent?: Scope) {}\n\n  lookup(name: string): unknown {\n    // A cell always exists once asked for, so its presence answers whether this\n    // scope binds the name. A binding legitimately holding `undefined` reads as\n    // its own value rather than falling through to the parent.\n    const found = this.vars.get(name);\n    return found === undefined ? this.parent?.lookup(name) : found.value;\n  }\n\n  set(name: string, value: unknown): void {\n    const own = this.vars.get(name);\n    if (own) {\n      own.value = value;\n      return;\n    }\n    this.vars.set(name, { value });\n  }\n\n  /**\n   * The cell holding `name`, taken from wherever in the chain already has one.\n   *\n   * A function reading a global must get the global's own cell, not a fresh\n   * local one that the binding would never fill. Only a name nobody has bound\n   * anywhere gets its cell here, where a later `set` will land.\n   */\n  cell(name: string): Cell {\n    const own = this.vars.get(name);\n    if (own) return own;\n    const inherited = this.parent?.cell(name);\n    if (inherited) return inherited;\n    const made: Cell = { value: undefined };\n    this.vars.set(name, made);\n    return made;\n  }\n\n  child(): Scope {\n    return new MapScope(this);\n  }\n}\n\n/**\n * Create a scope; `lookup` falls back to the parent, `set` writes locally.\n *\n * @param parent The enclosing scope, or nothing for a root scope.\n */\nexport function createScope(parent?: Scope): Scope {\n  return new MapScope(parent);\n}\n","import {\n  type Document,\n  evaluate,\n  type FragmentDecl,\n  isConfigDecl,\n  isFragmentDecl,\n  isLifecycleDecl,\n  type LifecycleDecl,\n} from \"@venn-lang/core\";\nimport { createScope } from \"../scope/index.js\";\n\n/** Top-level lifecycle blocks, grouped by hook. */\nexport interface SuiteHooks {\n  setup: LifecycleDecl[];\n  teardown: LifecycleDecl[];\n  beforeEach: LifecycleDecl[];\n  afterEach: LifecycleDecl[];\n}\n\n/** Index the document's fragments by name for `run`. */\nexport function collectFragments(doc: Document): Map<string, FragmentDecl> {\n  const map = new Map<string, FragmentDecl>();\n  for (const decl of doc.decls) {\n    if (isFragmentDecl(decl)) map.set(decl.name, decl);\n  }\n  return map;\n}\n\n/** Evaluate the top-level `config { … }` block with `env` bound, for the action context. */\nexport function collectConfig(\n  doc: Document,\n  env: Record<string, unknown>,\n): Record<string, unknown> {\n  const decl = doc.decls.find(isConfigDecl);\n  if (!decl) return {};\n  const scope = createScope();\n  scope.set(\"env\", env);\n  return evaluate(decl.body, scope) as Record<string, unknown>;\n}\n\n/** Gather top-level setup/teardown/beforeEach/afterEach blocks. */\nexport function collectHooks(doc: Document): SuiteHooks {\n  const hooks: SuiteHooks = { setup: [], teardown: [], beforeEach: [], afterEach: [] };\n  for (const decl of doc.decls) {\n    if (isLifecycleDecl(decl)) addHook(hooks, decl);\n  }\n  return hooks;\n}\n\n/** Gather the `on <event> { … }` handlers a flow declared, for one event. */\nexport function collectOn(stmts: readonly unknown[], event: string): LifecycleDecl[] {\n  return stmts.filter(\n    (stmt): stmt is LifecycleDecl => isLifecycleDecl(stmt) && stmt.event === event,\n  );\n}\n\nfunction addHook(hooks: SuiteHooks, decl: LifecycleDecl): void {\n  const bucket = hooks[decl.hook as keyof SuiteHooks];\n  if (bucket) bucket.push(decl);\n}\n","import type { Cleanup, CleanupList } from \"./cleanup.types.js\";\n\n/**\n * The runtime's own sink, for a host that does not bring one.\n *\n * Closing runs newest first and survives a cleanup that throws: a program on its\n * way out still has to hand back everything else it was holding.\n */\nexport function createCleanupList(): CleanupList {\n  const pending: Cleanup[] = [];\n  return {\n    add: (cleanup) => pending.push(cleanup),\n    close: async () => {\n      for (const cleanup of pending.splice(0).reverse()) await cleanup().catch(() => {});\n    },\n  };\n}\n","/** A title matches when the needle is absent, or contained case-insensitively. */\nexport function matchesTitle(title: string, needle: string | undefined): boolean {\n  if (!needle) return true;\n  return title.toLowerCase().includes(needle.toLowerCase());\n}\n","import {\n  type AstNode,\n  type Call,\n  type Expr,\n  isCall,\n  isMember,\n  isRef,\n  type LetStmt,\n  type MapLit,\n} from \"@venn-lang/core\";\n\n/** What running an action needs, whichever syntax spelled it. */\nexport interface Invocation {\n  target: string;\n  args: readonly Expr[];\n  opts?: MapLit;\n  /**\n   * Where the call is written, for a failure with no smaller node to point at.\n   * Absent when the invocation *is* the node: a call spelled as a statement.\n   */\n  node?: AstNode;\n}\n\n/**\n * The dotted path an expression spells, such as `http.post`, or undefined when\n * it is not a plain path. The parser cannot tell a namespace from a field; only\n * the registry can, so the path is carried this far as an expression.\n */\nexport function actionTarget(expr: Expr | undefined): string | undefined {\n  if (!expr) return undefined;\n  if (isRef(expr)) return expr.name;\n  if (!isMember(expr) || expr.optional) return undefined;\n  const receiver = actionTarget(expr.receiver);\n  return receiver === undefined ? undefined : `${receiver}.${expr.member}`;\n}\n\n/**\n * The bareword action a `let` spells: `let auth = http.post url { … }`. The\n * trailing arguments or options map are what mark it as a call. A parenthesised\n * call (`f(x)`) is an ordinary expression the evaluator runs, since it may be a\n * `fn` or a method rather than an action; only {@link actionCall} rescues the\n * case where it turns out to name a plugin action.\n */\nexport function invocationOf(stmt: LetStmt): Invocation | undefined {\n  return remember(invocations, stmt, readInvocation);\n}\n\nfunction readInvocation(stmt: LetStmt): Invocation | undefined {\n  if (stmt.args.length === 0 && !stmt.opts) return undefined;\n  const target = actionTarget(stmt.value);\n  if (target === undefined) return undefined;\n  return { target, args: stmt.args, opts: stmt.opts, node: stmt };\n}\n\n/**\n * An action written in expression position: the bare path `data.faker.uuid`, or\n * the parenthesised `data.faker.uuid()`. Returns the target and its arguments,\n * or undefined when it is not a dotted path at all.\n */\nexport function actionCall(value: Expr): ActionShape | undefined {\n  return remember(calls, value, readActionCall);\n}\n\nfunction readActionCall(value: Expr): ActionShape | undefined {\n  const bare = actionTarget(value);\n  if (bare !== undefined) return { target: bare, args: [] };\n  if (!isCall(value)) return undefined;\n  const target = actionTarget(value.callee);\n  return target === undefined ? undefined : { target, args: argValues(value) };\n}\n\n/** An action in expression position: the path it names and its arguments. */\nexport interface ActionShape {\n  target: string;\n  args: readonly Expr[];\n}\n\n/**\n * What a node spells, worked out once.\n *\n * The shape of the tree decides whether `let y = x * 2` names an action, and the\n * tree does not change, so the answer is cached per node rather than rewalked\n * through the type guards on every execution. Whether the *name* resolves to an\n * action depends on the scope and the registry, so that part is not cached.\n */\nconst invocations = new WeakMap<LetStmt, Invocation | null>();\nconst calls = new WeakMap<Expr, ActionShape | null>();\n\nfunction remember<K extends object, V>(\n  cache: WeakMap<K, V | null>,\n  key: K,\n  read: (key: K) => V | undefined,\n): V | undefined {\n  const known = cache.get(key);\n  if (known !== undefined) return known ?? undefined;\n  const found = read(key) ?? null;\n  cache.set(key, found);\n  return found ?? undefined;\n}\n\nfunction argValues(call: Call): Expr[] {\n  return (call.args?.args ?? []).map((arg) => arg.value);\n}\n","import type { Span } from \"@venn-lang/core\";\n\n/** Minimal structural view of a Langium CST node (avoids importing langium). */\ninterface CstView {\n  offset?: number;\n  length?: number;\n  text?: string;\n  range?: { start?: { line?: number; character?: number } };\n}\ninterface WithCst {\n  $cstNode?: CstView;\n}\n\n/** The exact source text of an AST node, for the event stream. */\nexport function nodeSource(node: WithCst): string {\n  return node.$cstNode?.text ?? \"\";\n}\n\n/** A Span for an AST node, for a runtime Problem. */\nexport function nodeSpan(node: WithCst, uri: string): Span {\n  const cst = node.$cstNode;\n  return {\n    uri,\n    offset: cst?.offset ?? 0,\n    length: cst?.length ?? 0,\n    line: (cst?.range?.start?.line ?? 0) + 1,\n    column: (cst?.range?.start?.character ?? 0) + 1,\n  };\n}\n","import { type Annotation, readMeta } from \"@venn-lang/core\";\n\n/** Any AST node that carries decorators (`@tags`, `@timeout`, `@retry`…). */\nexport interface Annotated {\n  annotations: Annotation[];\n}\n\n/** A parsed `@retry(n, { backoff, factor })` specification. */\nexport interface RetrySpec {\n  attempts: number;\n  backoffMs: number;\n  factor: number;\n}\n\n/**\n * Whether a decorator set this flag on the node.\n *\n * The scheduler reads what expansion concluded, never the annotation list\n * itself, so a decorator is understood in exactly one place.\n */\nexport function hasAnnotation(node: Annotated, name: string): boolean {\n  return readMeta<boolean>(node, name) === true;\n}\n\n/** `@timeout(90s)` → milliseconds, or undefined. */\nexport function readTimeout(node: Annotated): number | undefined {\n  return readMeta<number>(node, \"timeout\");\n}\n\n/** `@retry(2, { backoff: 500ms, factor: 2 })` → a retry spec, or undefined. */\nexport function readRetry(node: Annotated): RetrySpec | undefined {\n  return readMeta<RetrySpec>(node, \"retry\");\n}\n\n/** `@lock(\"orders\")` → the lock name, or undefined. */\nexport function readLock(node: Annotated): string | undefined {\n  return readMeta<string>(node, \"lock\");\n}\n\n/** `@flaky(0.05)` → the tolerated failure ratio; bare `@flaky` tolerates all. */\nexport function readFlaky(node: Annotated): number | undefined {\n  return readMeta<number>(node, \"flaky\");\n}\n\n/** `@tags(smoke, critical)` → the tag names. */\nexport function readTags(node: Annotated): string[] {\n  return readMeta<string[]>(node, \"tags\") ?? [];\n}\n","import { namespaceValue, nativeFn } from \"@venn-lang/core\";\nimport type { ActionContext, ActionDefinition } from \"@venn-lang/sdk\";\nimport type { Registry } from \"../registry/index.js\";\nimport type { Scope } from \"../scope/index.js\";\n\n/**\n * Put every plugin namespace in the root scope as a value, so its verbs work\n * inside any expression (`print(fmt.table(rows))`, `\"${crypto.hash(x)}\"`) and\n * not only as a bare statement.\n *\n * A verb reached this way runs synchronously: it is the pure corner of the\n * stdlib (`fmt`, `data`, `crypto`). An action that does I/O returns its promise,\n * so those stay written as statements, where the runtime awaits them.\n */\nexport function bindNamespaces(args: {\n  registry: Registry;\n  ctx: ActionContext;\n  scope: Scope;\n}): void {\n  const byNamespace = new Map<string, Record<string, unknown>>();\n  for (const entry of args.registry.actions()) {\n    const members = byNamespace.get(entry.namespace) ?? {};\n    place({ members, path: entry.name, action: entry.action, ctx: args.ctx });\n    byNamespace.set(entry.namespace, members);\n  }\n  for (const [namespace, members] of byNamespace) {\n    args.scope.set(namespace, namespaceValue(members));\n  }\n}\n\n/** `jwt.decode` nests: `{ jwt: { decode: fn } }`, so the dotted call reads naturally. */\nfunction place(args: {\n  members: Record<string, unknown>;\n  path: string;\n  action: ActionDefinition;\n  ctx: ActionContext;\n}): void {\n  const parts = args.path.split(\".\");\n  const leaf = parts.pop();\n  if (!leaf) return;\n  let level = args.members;\n  for (const part of parts) {\n    level[part] = (level[part] as Record<string, unknown>) ?? {};\n    level = level[part] as Record<string, unknown>;\n  }\n  level[leaf] = verb(args.action, args.ctx);\n}\n\nfunction verb(action: ActionDefinition, ctx: ActionContext): unknown {\n  return nativeFn((values) => action.run(ctx, { args: values, params: params(action) }));\n}\n\n/** No options map in expression position, so let the schema supply its defaults. */\nfunction params(action: ActionDefinition): unknown {\n  if (!action.params) return {};\n  try {\n    return action.params.parse({});\n  } catch {\n    return {};\n  }\n}\n","import { PRELUDE_VALUES } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\n\n/**\n * Put the pure prelude values (`len`, `range`, `pretty`, `str`, `min`…) in the\n * root scope. Being values rather than verbs is what lets them appear in any\n * expression: `xs.take(len(ys))`, `\"${pretty(user)}\"`.\n */\nexport function bindPrelude(scope: Scope): void {\n  for (const [name, value] of Object.entries(PRELUDE_VALUES)) scope.set(name, value);\n}\n","import { createScope, type Scope } from \"../scope/index.js\";\nimport { bindNamespaces } from \"./bind-namespaces.js\";\nimport { bindPrelude } from \"./bind-prelude.js\";\nimport type { Engine } from \"./engine.types.js\";\n\n/**\n * What every scope in a run starts as: the prelude, the plugin namespaces and\n * `env`, plus the matrix variant when there is one.\n *\n * One place, shared by test runs and program runs, so `venn test` and `venn run`\n * cannot drift apart. Every scope a module is read in starts here too, which is\n * what makes an imported function see the same world its own file did.\n */\nexport function createBaseScope(args: {\n  engine: Engine;\n  /** The `matrix` variant, for a test run. A program has none. */\n  variant?: Record<string, unknown>;\n}): Scope {\n  const scope = createScope();\n  bindPrelude(scope);\n  bindNamespaces({ registry: args.engine.registry, ctx: args.engine.ctx, scope });\n  scope.set(\"env\", args.engine.env);\n  if (args.variant) scope.set(\"matrix\", args.variant);\n  return scope;\n}\n","import { type Annotated, readFlaky } from \"./annotations.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport type { FlakyTally } from \"./flaky.types.js\";\n\n/** Record one execution of a `@flaky(ratio)` node, and how much it failed by. */\nexport function recordFlaky(engine: Engine, node: Annotated, before: number): void {\n  const ratio = readFlaky(node);\n  if (ratio === undefined) return;\n  const tally = engine.flaky.get(node) ?? { ratio, runs: 0, failedRuns: 0, failedUnits: 0 };\n  const delta = engine.result.failed - before;\n  tally.runs += 1;\n  tally.failedRuns += delta > 0 ? 1 : 0;\n  tally.failedUnits += delta > 0 ? delta : 0;\n  engine.flaky.set(node, tally);\n}\n\n/**\n * Forgive the failures of every `@flaky` node whose observed failure ratio\n * stayed within its declared tolerance. Settled once, so the verdict does not\n * depend on the order iterations happened to fail in.\n */\nexport function settleFlaky(engine: Engine): void {\n  for (const tally of engine.flaky.values()) {\n    if (tally.failedRuns === 0 || tally.failedRuns / tally.runs > tally.ratio) continue;\n    engine.result.failed = Math.max(0, engine.result.failed - tally.failedUnits);\n    engine.emitter.emit({ kind: \"log\", data: { level: \"warn\", message: message(tally) } });\n  }\n}\n\nfunction message(tally: FlakyTally): string {\n  return `flaky tolerated: ${tally.failedRuns}/${tally.runs} runs failed, within ratio ${tally.ratio}`;\n}\n","import { invoke, readDecorations } from \"@venn-lang/core\";\n\n/**\n * Run the `.before` and `.after` closures a `deco` left on a flow or a step.\n *\n * The language has no syntax for \"around this body\", so the verbs leave a fact\n * behind and this is where it is honoured. `.after` runs from a `finally`,\n * because a hook that only runs when nothing went wrong is the one case it was\n * written for.\n */\nexport async function runAround(node: object, body: () => unknown): Promise<void> {\n  const around = readDecorations(node);\n  if (!around) {\n    await body();\n    return;\n  }\n  for (const fn of around.before) invoke(fn, []);\n  try {\n    await body();\n  } finally {\n    for (const fn of around.after) invoke(fn, []);\n  }\n}\n","import { VennError } from \"@venn-lang/contracts\";\nimport type { Annotation } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { type RetrySpec, readRetry, readTimeout } from \"./annotations.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { isControlSignal } from \"./signals.js\";\n\ninterface AnnotatedNode {\n  annotations: Annotation[];\n}\n\n/** Run a step/flow body applying its `@timeout` and `@retry` annotations. */\nexport async function runWithAnnotations(args: {\n  engine: Engine;\n  node: AnnotatedNode;\n  scope: Scope;\n  title: string;\n  run: () => Promise<void>;\n}): Promise<void> {\n  const timeout = readTimeout(args.node);\n  const retry = readRetry(args.node);\n  const attempt = (): Promise<void> => withTimeout(timeout, args.run);\n  if (!retry || retry.attempts === 0) return attempt();\n  await withRetry({ engine: args.engine, retry, title: args.title, run: attempt });\n}\n\n/** Hold the named mutex (`@lock`/`@serial`) around `run`, releasing on exit. */\nexport async function withLock(\n  engine: Engine,\n  name: string | undefined,\n  run: () => Promise<void>,\n): Promise<void> {\n  if (!name) return run();\n  const release = await engine.lock.acquire(name);\n  try {\n    await run();\n  } finally {\n    release();\n  }\n}\n\nasync function withTimeout(timeoutMs: number | undefined, run: () => Promise<void>): Promise<void> {\n  if (timeoutMs === undefined) return run();\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const guard = new Promise<never>((_resolve, reject) => {\n    timer = setTimeout(() => reject(timeoutError(timeoutMs)), timeoutMs);\n  });\n  try {\n    await Promise.race([run(), guard]);\n  } finally {\n    if (timer) clearTimeout(timer);\n  }\n}\n\nasync function withRetry(args: {\n  engine: Engine;\n  retry: RetrySpec;\n  title: string;\n  run: () => Promise<void>;\n}): Promise<void> {\n  const total = args.retry.attempts + 1;\n  for (let i = 1; i <= total; i++) {\n    const snapshot = { ...args.engine.result };\n    const outcome = await attempt(args.engine, args.run);\n    if (outcome.ok) return;\n    if (i >= total) {\n      if (outcome.error) throw outcome.error;\n      return;\n    }\n    Object.assign(args.engine.result, snapshot);\n    emitRetrying({ engine: args.engine, title: args.title, attempt: i });\n    await args.engine.clock.sleep(backoff(args.retry, i));\n  }\n}\n\ninterface AttemptOutcome {\n  ok: boolean;\n  error?: unknown;\n}\n\nasync function attempt(engine: Engine, run: () => Promise<void>): Promise<AttemptOutcome> {\n  const before = engine.result.failed;\n  try {\n    await run();\n    return { ok: engine.result.failed === before };\n  } catch (error) {\n    if (isControlSignal(error)) throw error;\n    return { ok: false, error };\n  }\n}\n\nfunction emitRetrying(args: { engine: Engine; title: string; attempt: number }): void {\n  args.engine.emitter.emit({\n    kind: \"flow.retrying\",\n    data: { title: args.title, attempt: args.attempt, reason: \"previous attempt failed\" },\n  });\n}\n\nfunction backoff(retry: RetrySpec, attempt: number): number {\n  return retry.backoffMs * retry.factor ** (attempt - 1);\n}\n\nfunction timeoutError(ms: number): VennError {\n  return new VennError({ code: \"VN8001\", message: `Timed out after ${ms}ms.` });\n}\n","import { buildProblem, CODES, type MapEntry, type MapLit, type Problem } from \"@venn-lang/core\";\nimport { type ParamSpec, paramSpecs } from \"@venn-lang/sdk\";\nimport { nodeSpan } from \"./node-span.js\";\n\n/**\n * The keys an options map spells that the schema behind it never declared,\n * whether that schema is an action's or a matcher's.\n *\n * One list, two readers: the checker squiggles them before anything runs, the\n * runtime refuses them when the line executes. Same code, same words, so a typo\n * cannot read one way in the editor and another in the terminal.\n *\n * A schema that declares no keys accepts a free-form map, and nothing there is\n * unknown: `grpc.request` takes a `z.record`, `db.seed` takes no schema at all\n * and reads the whole map as table names.\n */\nexport function unknownOptions(args: {\n  opts: MapLit | undefined;\n  params: unknown;\n  uri: string;\n}): Problem[] {\n  const specs = paramSpecs(args.params as never);\n  if (!args.opts || specs.length === 0 || welcomesMore(args.params)) return [];\n  const known = new Set(specs.map((spec) => spec.name));\n  return args.opts.entries\n    .filter((entry) => !known.has(entry.key))\n    .map((entry) => unknownOption({ entry, specs, uri: args.uri }));\n}\n\n/**\n * A schema written with a catchall (`z.looseObject`, `.catchall(…)`) names some\n * keys and takes the rest as well. A key it never named is still a key it asked\n * to receive, so there is nothing to report. Read structurally, past the\n * wrappers `.optional()` and `.default()` add, the way {@link paramSpecs} reads\n * the shape.\n */\nfunction welcomesMore(params: unknown): boolean {\n  const def = (params as { def?: { catchall?: unknown; innerType?: unknown } } | undefined)?.def;\n  if (def?.catchall !== undefined) return true;\n  return def?.innerType !== undefined && welcomesMore(def.innerType);\n}\n\nfunction unknownOption(args: {\n  entry: MapEntry;\n  specs: readonly ParamSpec[];\n  uri: string;\n}): Problem {\n  const { key } = args.entry;\n  const hint = nearest(key, args.specs);\n  const accepted = args.specs.map((spec) => spec.name).join(\", \");\n  const title = hint\n    ? `\"${key}\" is not an option here — did you mean \"${hint}\"?`\n    : `\"${key}\" is not an option here. Accepted: ${accepted}.`;\n  return buildProblem({\n    spec: CODES.VN3001_UNKNOWN_OPTION,\n    span: nodeSpan(args.entry, args.uri),\n    title,\n  });\n}\n\n/** The closest accepted key, when one is close enough to be worth suggesting. */\nfunction nearest(key: string, specs: readonly ParamSpec[]): string | undefined {\n  const scored = specs\n    .map((spec) => ({ name: spec.name, distance: distance(key, spec.name) }))\n    .sort((left, right) => left.distance - right.distance)[0];\n  return scored && scored.distance <= Math.max(2, Math.floor(key.length / 2))\n    ? scored.name\n    : undefined;\n}\n\n/** Levenshtein, small enough to keep here and precise enough for a \"did you mean\". */\nfunction distance(left: string, right: string): number {\n  let previous = Array.from({ length: right.length + 1 }, (_value, index) => index);\n  for (let i = 1; i <= left.length; i += 1) {\n    const current = [i];\n    for (let j = 1; j <= right.length; j += 1) {\n      const cost = left[i - 1] === right[j - 1] ? 0 : 1;\n      current[j] = Math.min(\n        (current[j - 1] ?? 0) + 1,\n        (previous[j] ?? 0) + 1,\n        (previous[j - 1] ?? 0) + cost,\n      );\n    }\n    previous = current;\n  }\n  return previous[right.length] ?? 0;\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  display,\n  type MapEntry,\n  type MapLit,\n  type Problem,\n  ProblemError,\n  typeName,\n} from \"@venn-lang/core\";\nimport type { ZodType } from \"@venn-lang/sdk\";\nimport { nodeSpan } from \"./node-span.js\";\nimport { unknownOptions } from \"./unknown-option.js\";\n\n/** The bits of a Zod failure this reads. Structural, so no Zod internals leak out. */\ninterface Issue {\n  code?: string;\n  path?: readonly PropertyKey[];\n  expected?: string;\n  values?: readonly unknown[];\n}\n\n/** Zod's word for a type, in the word the language uses for it. */\nconst WORDS: Record<string, string> = {\n  object: \"map\",\n  record: \"map\",\n  array: \"list\",\n  boolean: \"bool\",\n  int: \"number\",\n  bigint: \"number\",\n};\n\n/**\n * The options map of a call, an action's or a matcher's, validated before the\n * thing it belongs to ever sees it.\n *\n * Unknown keys are refused rather than stripped, because `z.object` drops them\n * in silence and `crypto.hash \"x\" { algorithmm: \"sha512\" }` would then hash with\n * the default. A rejected value becomes a `Problem` rather than escaping as a\n * ZodError, whose `message` is a JSON dump of issues.\n *\n * @param args.site Where the call is written, for a failure with no smaller node\n * to point at: a required option nobody typed leaves nothing to underline.\n * @returns The parsed options.\n * @throws ProblemError `VN3010` when a key is unknown or a value is rejected.\n */\nexport function callParams(args: {\n  schema: ZodType | undefined;\n  opts: MapLit | undefined;\n  raw: unknown;\n  site: AstNode;\n  uri: string;\n}): unknown {\n  const { schema, opts, raw, site, uri } = args;\n  if (!schema) return raw;\n  const unknown = unknownOptions({ opts, params: schema, uri });\n  if (unknown[0]) throw new ProblemError(unknown[0]);\n  return parsed({ schema, opts, raw, site, uri });\n}\n\n/** Parse, and turn a rejection into a sentence about the option that failed. */\nfunction parsed(args: {\n  schema: ZodType;\n  opts: MapLit | undefined;\n  raw: unknown;\n  site: AstNode;\n  uri: string;\n}): unknown {\n  try {\n    return args.schema.parse(args.raw);\n  } catch (error) {\n    const issue = firstIssue(error);\n    // Not a schema rejection: a transform threw, and it already says why.\n    if (!issue) throw error;\n    const { raw, opts, site, uri } = args;\n    throw new ProblemError(badOption({ issue, raw, opts, site, uri }));\n  }\n}\n\nfunction badOption(args: {\n  issue: Issue;\n  raw: unknown;\n  opts: MapLit | undefined;\n  site: AstNode;\n  uri: string;\n}): Problem {\n  const path = args.issue.path ?? [];\n  return buildProblem({\n    spec: CODES.VN3010_TYPE_MISMATCH,\n    // The entry that failed, else the map; a required option nobody wrote has\n    // neither, and then the call itself is the nearest true place.\n    span: nodeSpan(entryFor(args.opts, path) ?? args.opts ?? args.site, args.uri),\n    title: title({ key: path.join(\".\"), issue: args.issue, value: valueAt(args.raw, path) }),\n  });\n}\n\n/**\n * One line, naming the option and what it wanted. Only the shapes worth\n * modelling get their own sentence; anything else says so plainly rather than\n * dressing up an issue it does not understand.\n */\nfunction title(args: { key: string; issue: Issue; value: unknown }): string {\n  const { key, issue, value } = args;\n  if (!key) return \"These options are not valid here.\";\n  if (issue.code === \"invalid_value\" && issue.values) return oneOf(key, issue.values, value);\n  if (issue.code !== \"invalid_type\" || !issue.expected) return `\"${key}\" is not a valid option.`;\n  const needs = WORDS[issue.expected] ?? issue.expected;\n  if (value === undefined) return `\"${key}\" is required here, and it takes a ${needs}.`;\n  return `\"${key}\" needs a ${needs}, and ${shown(value)} is a ${typeName(value)}.`;\n}\n\n/** `{ algorithm: \"sha5\" }` against a schema that lists the digests it knows. */\nfunction oneOf(key: string, values: readonly unknown[], value: unknown): string {\n  const accepted = values.map((option) => shown(option)).join(\", \");\n  return `\"${key}\" must be one of ${accepted} — not ${shown(value)}.`;\n}\n\n/** A value as a message shows it: strings quoted, so `\"soon\"` reads as text. */\nfunction shown(value: unknown): string {\n  return typeof value === \"string\" ? JSON.stringify(value) : display(value);\n}\n\nfunction valueAt(raw: unknown, path: readonly PropertyKey[]): unknown {\n  let value = raw;\n  for (const key of path) value = (value as Record<PropertyKey, unknown> | undefined)?.[key];\n  return value;\n}\n\n/** The written entry to underline, when the failure names a key this map spells. */\nfunction entryFor(opts: MapLit | undefined, path: readonly PropertyKey[]): MapEntry | undefined {\n  const key = String(path[0] ?? \"\");\n  return opts?.entries.find((entry) => entry.key === key);\n}\n\n/** Zod's failure, read structurally: the runtime does not depend on zod itself. */\nfunction firstIssue(error: unknown): Issue | undefined {\n  const issues = (error as { issues?: unknown } | undefined)?.issues;\n  return Array.isArray(issues) ? (issues[0] as Issue) : undefined;\n}\n","import type { ActionDefinition } from \"@venn-lang/sdk\";\n\n/**\n * How many positional arguments a verb declared.\n *\n * Used to tell an argument that happens to be a map from the options map that\n * configures the call. A variadic verb such as `data.oneOf a b c` takes every\n * argument it is given, so nothing is left over to mistake for configuration.\n */\nexport function takes(action: ActionDefinition): number {\n  if (action.args?.some((each) => each.rest)) return Number.POSITIVE_INFINITY;\n  return action.args?.length ?? action.signature?.params.length ?? 0;\n}\n","import { isCallable, isNamespaceValue, memberValue } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\n\n/**\n * What a dotted statement target names, when it names something in scope.\n *\n * `conn.close()` and `http.get \"url\"` are written alike and mean different\n * things: one is a method on a value the program holds, the other a verb a\n * plugin contributes. Only the name can tell them apart, and a name the program\n * bound wins. That is the rule the evaluator already follows for `auth` the\n * variable against `auth` the namespace.\n *\n * Returns undefined whenever this is not that: no such name, a namespace, or a\n * path that leads somewhere uncallable. The caller then treats it as a verb,\n * and an unknown verb reports itself as it always did.\n */\nexport function localCallee(target: string, scope: Scope): unknown {\n  const segments = target.split(\".\");\n  const head = segments[0];\n  if (!head) return undefined;\n  const root = scope.lookup(head);\n  if (root === undefined || isNamespaceValue(root)) return undefined;\n  let value: unknown = root;\n  for (let at = 1; at < segments.length; at += 1) {\n    value = memberValue(value, segments[at] as string);\n  }\n  return isCallable(value) ? value : undefined;\n}\n","/**\n * Whether evaluating an expression produced something still running.\n *\n * Expressions compile synchronously, so a plugin verb called from inside one\n * hands back the promise it is running on rather than its result. Statement\n * position is already asynchronous, so it can wait, and `let id = newId()` binds\n * the id instead of `[object Promise]`.\n *\n * Callers branch on this rather than awaiting unconditionally: `await` on a\n * value that is not a promise still costs a turn of the event loop, and a\n * `forEach` over 50k items reads one expression per iteration.\n */\nexport function isPending(value: unknown): value is Promise<unknown> {\n  return value instanceof Promise;\n}\n\n/** Wait for a value only if there is something to wait for. */\nexport async function settle<T>(value: T | Promise<T>): Promise<T> {\n  return isPending(value) ? ((await value) as T) : (value as T);\n}\n","/**\n * Prelude verbs, callable without `use` (§12). `print` writes to the console,\n * `log` records into the event stream (what a reporter and a test see), and the\n * rest steer the run. Pure prelude *values* (`len`, `range`, `pretty`…) are not\n * here: they live in the root scope, so they work in any expression.\n */\nexport const PRELUDE: ReadonlySet<string> = new Set([\n  \"print\",\n  \"log\",\n  \"wait\",\n  \"skip\",\n  \"fail\",\n  \"exit\",\n]);\n\n/** Split an action target `namespace.action` into parts (no dot ⇒ namespace only). */\nexport function splitTarget(target: string): { namespace: string; name: string } {\n  const dot = target.indexOf(\".\");\n  if (dot < 0) return { namespace: target, name: \"\" };\n  return { namespace: target.slice(0, dot), name: target.slice(dot + 1) };\n}\n\n/** Split a target, mapping a `use \"…\" as h` alias back to its real namespace. */\nexport function resolveTarget(\n  target: string,\n  aliases: ReadonlyMap<string, string>,\n): { namespace: string; name: string } {\n  const { namespace, name } = splitTarget(target);\n  return { namespace: aliases.get(namespace) ?? namespace, name };\n}\n","import { ConsolePort, VennError } from \"@venn-lang/contracts\";\nimport {\n  type ActionCall,\n  type AstNode,\n  callArgs,\n  display,\n  evaluate,\n  invoke,\n  splitCall,\n} from \"@venn-lang/core\";\nimport type { ActionDefinition, ActionInput } from \"@venn-lang/sdk\";\nimport type { Scope } from \"../scope/index.js\";\nimport { callParams } from \"./call-params.js\";\nimport { takes } from \"./declared-arity.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport type { Invocation } from \"./invocation.js\";\nimport { localCallee } from \"./local-call.js\";\nimport { settle } from \"./settled.js\";\nimport { ExitSignal } from \"./signals.js\";\nimport { PRELUDE, resolveTarget } from \"./target.js\";\n\n/**\n * Resolve, invoke and time an action call.\n *\n * @returns Whatever the action produced. The caller names it: there is no\n * implicit `res` for a reader to know about.\n * @throws VennError `VN2003` when no plugin provides the target.\n */\nexport async function runAction(engine: Engine, call: Invocation, scope: Scope): Promise<unknown> {\n  if (PRELUDE.has(call.target)) return runPrelude(engine, call, scope);\n  // `conn.close()` is a method on something the program holds. A name it bound\n  // beats a namespace of the same name, so this is asked first.\n  const callee = localCallee(call.target, scope);\n  if (callee !== undefined) return callMethod(callee, call, scope);\n  const { namespace, name } = resolveTarget(call.target, engine.aliases);\n  const resolved = engine.registry.action({ namespace, name });\n  if (!resolved) throw unknownAction(call.target);\n  engine.emitter.emit({ kind: \"action.started\", data: { namespace, action: name } });\n  const start = engine.clock.now();\n  const value = await resolved.action.run(\n    engine.ctx,\n    await buildInput({ action: resolved.action, call, scope, uri: engine.uri }),\n  );\n  const durationMs = engine.clock.now() - start;\n  engine.emitter.emit({\n    kind: \"action.finished\",\n    data: { namespace, action: name, status: \"passed\", durationMs },\n  });\n  return value;\n}\n\n/** Call a value the program holds, and wait for it as any other call is waited for. */\nasync function callMethod(callee: unknown, call: Invocation, scope: Scope): Promise<unknown> {\n  const values = await Promise.all(call.args.map((expr) => settle(evaluate(expr, scope))));\n  return settle(invoke(callee, values));\n}\n\n/**\n * An action written as a bare statement: run it, drop what it returned.\n *\n * The arguments are normalised here because the two spellings, `conn.close()`\n * and `http.get \"url\"`, put them in different places on the node.\n */\nexport async function runActionStatement(\n  engine: Engine,\n  call: ActionCall,\n  scope: Scope,\n): Promise<void> {\n  await runAction(engine, { ...call, args: callArgs(call) }, scope);\n}\n\nasync function buildInput(args: {\n  action: ActionDefinition;\n  call: Invocation;\n  scope: Scope;\n  uri: string;\n}): Promise<ActionInput<unknown>> {\n  // The trailing `{ … }` is the options in both spellings, but only the bareword\n  // one puts it where the parser can label it. Splitting by declared arity is\n  // what stops `http.get(url, { headers })` sending no headers at all.\n  const split = splitCall(args.call.args, takes(args.action));\n  const opts = args.call.opts ?? split.opts;\n  const positional = await Promise.all(\n    split.args.map((expr) => settle(evaluate(expr, args.scope))),\n  );\n  const raw = await settle(opts ? evaluate(opts, args.scope) : {});\n  const schema = args.action.params;\n  const site = siteOf(args.call);\n  return {\n    args: positional,\n    params: callParams({ schema, opts, raw, site, uri: args.uri }),\n  };\n}\n\n/**\n * Where the call is written. A call spelled as a statement is its own node; one\n * rescued out of a `let` carries the statement that spells it, since the\n * invocation itself is a plain object with no place in the source.\n */\nfunction siteOf(call: Invocation): AstNode {\n  return call.node ?? (call as unknown as AstNode);\n}\n\nfunction unknownAction(target: string): VennError {\n  return new VennError({\n    code: \"VN2003\",\n    message: `Unknown action \"${target}\".`,\n    detail: { target },\n  });\n}\n\n/** Prelude verbs, available without `use` (§12): print, log, wait, skip, fail, exit. */\nasync function runPrelude(engine: Engine, call: Invocation, scope: Scope): Promise<void> {\n  const args = await Promise.all(call.args.map((arg) => settle(evaluate(arg, scope))));\n  if (call.target === \"print\") return printLine(engine, args);\n  if (call.target === \"log\") return logLine(engine, args);\n  const message = String(args[0] ?? \"\");\n  if (call.target === \"wait\") await engine.clock.sleep(waitMs(args[0]));\n  else if (call.target === \"skip\") skipLog(engine, message);\n  else if (call.target === \"exit\") throw new ExitSignal(exitCode(args[0]));\n  else if (call.target === \"fail\") throw failError(message);\n}\n\n/**\n * `print x y`: the program's own output, on standard output. Distinct from\n * `log`, which records into the event stream a reporter reads.\n */\nfunction printLine(engine: Engine, args: readonly unknown[]): void {\n  engine.ctx.port(ConsolePort).write(`${line(args)}\\n`);\n}\n\n/** `log a b c`: every argument, spaced, objects shown as JSON not `[object Object]`. */\nfunction logLine(engine: Engine, args: readonly unknown[]): void {\n  engine.emitter.emit({ kind: \"log\", data: { level: \"info\", message: line(args) } });\n}\n\nfunction line(args: readonly unknown[]): string {\n  return args.map(display).join(\" \");\n}\n\n/**\n * The code `exit` leaves with. Anything the machine cannot use as one still\n * ended badly, so `exit \"boom\"` leaves with 1 and never with 0, which would read\n * as success to whatever is waiting on this process.\n */\nfunction exitCode(value: unknown): number {\n  const code = Math.trunc(Number(value ?? 0));\n  return Number.isFinite(code) ? code : 1;\n}\n\nfunction skipLog(engine: Engine, message: string): void {\n  engine.emitter.emit({ kind: \"log\", data: { level: \"warn\", message: `skipped: ${message}` } });\n}\n\nfunction waitMs(value: unknown): number {\n  if (typeof value === \"number\") return value;\n  const duration = value as { kind?: string; ms?: number };\n  return duration?.kind === \"duration\" ? (duration.ms ?? 0) : 0;\n}\n\nfunction failError(message: string): VennError {\n  return new VennError({ code: \"VN6002\", message: message || \"fail\" });\n}\n","import {\n  type CaptureStmt,\n  evaluate,\n  isNamespaceValue,\n  type LetStmt,\n  type ReturnStmt,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { actionCall, type Invocation, invocationOf } from \"./invocation.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runAction } from \"./run-action.js\";\nimport { isPending } from \"./settled.js\";\nimport { ReturnSignal } from \"./signals.js\";\nimport { resolveTarget } from \"./target.js\";\n\n/**\n * `let plan = \"pro\"` binds a value; `let auth = http.post url { … }` binds what\n * the action returned. Naming the result is what makes it readable: there is no\n * implicit variable to know about.\n */\nexport function runLet(engine: Engine, stmt: LetStmt, scope: Scope): Pending {\n  const call = invocationOf(stmt) ?? impliedCall(engine, stmt, scope);\n  // Only a call suspends. Binding a plain expression is the common case, and\n  // an `async` here would cost a promise per iteration of every loop.\n  if (!call) return bind(stmt.name, evaluate(stmt.value, scope), scope);\n  return runAction(engine, call, scope).then((value) => scope.set(stmt.name, value));\n}\n\n/**\n * `let id = data.faker.uuid` or `let id = data.faker.uuid()`: a dotted path\n * naming a plugin action is a call, exactly as it would be as a statement.\n *\n * A binding in scope always wins, so `let code = res.status` reads a field and\n * `let parts = name.split(\" \")` calls a method. Neither turns into I/O, whatever\n * the registry happens to hold.\n */\nfunction impliedCall(engine: Engine, stmt: LetStmt, scope: Scope): Invocation | undefined {\n  const call = actionCall(stmt.value);\n  const dot = call ? call.target.indexOf(\".\") : -1;\n  if (!call || dot < 0 || bound(scope, call.target.slice(0, dot))) return undefined;\n  const resolved = engine.registry.action(resolveTarget(call.target, engine.aliases));\n  return resolved ? { target: call.target, args: call.args, node: stmt } : undefined;\n}\n\n/** A name the user bound. A plugin namespace in scope is not one, so the verb still calls. */\nfunction bound(scope: Scope, name: string): boolean {\n  const value = scope.lookup(name);\n  return value !== undefined && !isNamespaceValue(value);\n}\n\n/** Bind now, or once the value it is waiting on arrives. */\nfunction bind(name: string, value: unknown, scope: Scope): Pending {\n  if (isPending(value)) return value.then((settled) => scope.set(name, settled));\n  return void scope.set(name, value);\n}\n\n/** `capture` is removed in favour of `let`; still run, so old files keep working. */\nexport function runCapture(stmt: CaptureStmt, scope: Scope): void {\n  scope.set(stmt.name, evaluate(stmt.value, scope));\n}\n\n/** `return expr`: unwind to the enclosing fragment with the value. */\nexport function runReturn(stmt: ReturnStmt, scope: Scope): never {\n  const value = stmt.value ? evaluate(stmt.value, scope) : undefined;\n  throw new ReturnSignal(value);\n}\n","import { VennError } from \"@venn-lang/contracts\";\nimport {\n  buildDiff,\n  type Diff,\n  type ExpectStmt,\n  evaluate,\n  type MatcherClause,\n} from \"@venn-lang/core\";\nimport type { MatcherArgs, MatcherDefinition } from \"@venn-lang/sdk\";\nimport type { ResolvedMatcher } from \"../registry/index.js\";\nimport type { Scope } from \"../scope/index.js\";\nimport { callParams } from \"./call-params.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSource } from \"./node-span.js\";\n\n/** The pass/fail, the one-line message, and the diff that message summarises. */\nexport interface MatcherOutcome {\n  passed: boolean;\n  message?: string;\n  diff?: Diff;\n}\n\n/** Resolve a bareword matcher from the registry and run it against the subject. */\nexport async function evalMatcher(args: {\n  engine: Engine;\n  stmt: ExpectStmt;\n  scope: Scope;\n}): Promise<MatcherOutcome> {\n  const clause = args.stmt.matcher as MatcherClause;\n  const resolved = args.engine.registry.matcher(clause.name);\n  if (!resolved) throw unknownMatcher(clause.name);\n  const input = buildArgs({ ...args, resolved, clause });\n  const raw = await resolved.matcher.test(input);\n  if (args.stmt.negate ? !raw : raw) return { passed: true };\n  return failure({ matcher: resolved.matcher, input, stmt: args.stmt });\n}\n\n/**\n * A failing matcher hands back the two sides it compared, labelled with how the\n * flow spelled the subject. A negated expect gets no diff on purpose: under\n * `not` the two sides matched, and \"expected 200, actual 200\" explains nothing.\n */\nfunction failure(args: {\n  matcher: MatcherDefinition;\n  input: MatcherArgs<unknown>;\n  stmt: ExpectStmt;\n}): MatcherOutcome {\n  const message = args.matcher.message(args.input);\n  const detail = args.stmt.negate ? undefined : args.matcher.detail?.(args.input);\n  if (!detail) return { passed: false, message };\n  const label = subjectLabel(args.stmt);\n  return { passed: false, message, diff: buildDiff({ label, ...detail }) };\n}\n\n/** The diff's header: the subject as the flow spelled it, on one line. */\nfunction subjectLabel(stmt: ExpectStmt): string {\n  const source = stmt.subject ? nodeSource(stmt.subject).replace(/\\s+/g, \" \").trim() : \"\";\n  return source === \"\" ? \"value\" : source;\n}\n\nfunction buildArgs(args: {\n  resolved: ResolvedMatcher;\n  stmt: ExpectStmt;\n  clause: MatcherClause;\n  scope: Scope;\n  engine: Engine;\n}): MatcherArgs<unknown> {\n  const { stmt, clause, scope } = args;\n  const subject = stmt.subject ? evaluate(stmt.subject, scope) : undefined;\n  const positional = clause.args.map((expr) => evaluate(expr, scope));\n  return { subject, args: positional, params: matcherOptions(args) };\n}\n\n/**\n * A matcher's options map goes through the same gate an action's does: a key it\n * never declared is refused rather than dropped, and a value it rejects reads as\n * one line. Nothing checks these before the run, since `checkOptions` only ever\n * sees calls, so this is the only place `{ withinn: 1 }` is ever noticed.\n */\nfunction matcherOptions(args: {\n  resolved: ResolvedMatcher;\n  stmt: ExpectStmt;\n  clause: MatcherClause;\n  scope: Scope;\n  engine: Engine;\n}): unknown {\n  const { resolved, stmt, clause, scope, engine } = args;\n  const raw = clause.opts ? evaluate(clause.opts, scope) : {};\n  const schema = resolved.matcher.params;\n  return callParams({ schema, opts: clause.opts, raw, site: stmt, uri: engine.uri });\n}\n\nfunction unknownMatcher(name: string): VennError {\n  return new VennError({\n    code: \"VN2004\",\n    message: `Unknown matcher \"${name}\".`,\n    detail: { name },\n  });\n}\n","import { buildProblem, CODES, type ExpectStmt, evaluate, truthy } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSource, nodeSpan } from \"./node-span.js\";\nimport { evalMatcher, type MatcherOutcome } from \"./run-matcher.js\";\nimport { settle } from \"./settled.js\";\n\n/** Evaluate an `expect` (matcher clause, `.all` checks, negated, or subject) and emit the outcome. */\nexport async function runExpect(engine: Engine, stmt: ExpectStmt, scope: Scope): Promise<void> {\n  const outcome = stmt.matcher\n    ? await evalMatcher({ engine, stmt, scope })\n    : { passed: await evalBoolean({ stmt, scope }) };\n  record({ engine, stmt, outcome });\n}\n\nasync function evalBoolean(args: { stmt: ExpectStmt; scope: Scope }): Promise<boolean> {\n  return args.stmt.modifier === \"all\" ? evalChecks(args) : evalSubject(args);\n}\n\nasync function evalSubject(args: { stmt: ExpectStmt; scope: Scope }): Promise<boolean> {\n  if (!args.stmt.subject) return true;\n  const value = truthy(await settle(evaluate(args.stmt.subject, args.scope)));\n  return args.stmt.negate ? !value : value;\n}\n\nasync function evalChecks(args: { stmt: ExpectStmt; scope: Scope }): Promise<boolean> {\n  for (const check of args.stmt.checks) {\n    if (!truthy(await settle(evaluate(check, args.scope)))) return false;\n  }\n  return true;\n}\n\nfunction record(args: { engine: Engine; stmt: ExpectStmt; outcome: MatcherOutcome }): void {\n  if (args.outcome.passed) {\n    args.engine.result.passed += 1;\n    args.engine.emitter.emit({ kind: \"expect.passed\", data: { source: nodeSource(args.stmt) } });\n    return;\n  }\n  args.engine.result.failed += 1;\n  const problem = buildProblem({\n    spec: CODES.VN6001_ASSERTION_FAILED,\n    span: nodeSpan(args.stmt, args.engine.uri),\n    title: args.outcome.message ?? `Expectation failed: ${nodeSource(args.stmt)}`,\n    // The title is one line; the two sides it summarises travel as the body.\n    diff: args.outcome.diff,\n  });\n  args.engine.emitter.emit({ kind: \"expect.failed\", data: { problem } });\n}\n","/** Run `task` over `items` with at most `limit` in flight at once. */\nexport async function runPool<T>(\n  items: readonly T[],\n  limit: number,\n  task: (item: T, index: number) => Promise<void>,\n): Promise<void> {\n  const size = Math.max(1, limit);\n  let cursor = 0;\n  const worker = async (): Promise<void> => {\n    while (cursor < items.length) {\n      const index = cursor++;\n      await task(items[index] as T, index);\n    }\n  };\n  await Promise.all(Array.from({ length: Math.min(size, items.length) }, worker));\n}\n","import { evaluate, type MapLit } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\n\n/** Read a numeric field from an options map literal (e.g. `{ concurrency: 4 }`). */\nexport function optsNumber(\n  opts: MapLit | undefined,\n  key: string,\n  scope: Scope,\n): number | undefined {\n  const entry = opts?.entries.find((candidate) => candidate.key === key);\n  if (!entry) return undefined;\n  const value = evaluate(entry.value, scope);\n  return typeof value === \"number\" ? value : undefined;\n}\n","import {\n  buildProblem,\n  CODES,\n  evaluate,\n  type ForEachStmt,\n  ProblemError,\n  typeName,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { planOf } from \"./block-plan.js\";\nimport { runPool } from \"./concurrency.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSpan } from \"./node-span.js\";\nimport { optsNumber } from \"./opts.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runBlock, runSteps } from \"./run-block.js\";\nimport { settle } from \"./settled.js\";\nimport { BreakSignal, ContinueSignal } from \"./signals.js\";\n\n/** `forEach x in list { concurrency: N } { … }`: iterate, up to N in flight. */\nexport async function runForEach(engine: Engine, stmt: ForEachStmt, scope: Scope): Promise<void> {\n  const source = await settle(evaluate(stmt.source, scope));\n  if (!Array.isArray(source)) throw notAList({ engine, stmt, source });\n  const concurrency = optsNumber(stmt.opts, \"concurrency\", scope) ?? 1;\n  // One at a time is the default and by far the common case: run it as a plain\n  // loop rather than through the pool, which allocates a worker, an array and a\n  // `Promise.all` to supervise a single sequential walk.\n  if (concurrency === 1) return sequential(engine, stmt, source, scope);\n  await runPool(source, concurrency, (item) => runIteration({ engine, stmt, item, scope }));\n}\n\n/**\n * Anything but a list is refused, because iterating it zero times would report\n * success: a test that checked nothing, dressed as one that passed. Built here,\n * off the iteration path, so the loop itself pays nothing for it.\n */\nfunction notAList(args: { engine: Engine; stmt: ForEachStmt; source: unknown }): ProblemError {\n  return new ProblemError(\n    buildProblem({\n      spec: CODES.VN3015_NOT_A_LIST,\n      span: nodeSpan(args.stmt.source, args.engine.uri),\n      title: `forEach needs a list, and this is a ${typeName(args.source)}.`,\n      help: helpFor(args.source),\n    }),\n  );\n}\n\n/** The everyday cause: an endpoint answering `{ data: [...] }` rather than a list. */\nfunction helpFor(source: unknown): string | undefined {\n  if (typeName(source) !== \"map\") return undefined;\n  return \"Name the list inside it, as in `forEach item in res.data`.\";\n}\n\n/**\n * Walk the items one at a time, staying synchronous for as long as the body\n * does. A body of pure work (a binding, a comparison, arithmetic) never\n * suspends, so 50k iterations cost no promises at all. The first iteration that\n * does suspend hands the remainder to {@link resume}, from where it left off.\n */\nfunction sequential(\n  engine: Engine,\n  stmt: ForEachStmt,\n  items: readonly unknown[],\n  scope: Scope,\n): Pending {\n  const plan = planOf(stmt.body);\n  const name = stmt.item;\n  if (plan.defers) return slowSequential(engine, stmt, items, scope);\n  const child = scope.child();\n  for (let at = 0; at < items.length; at += 1) {\n    try {\n      child.set(name, items[at]);\n      const pending = runSteps(engine, plan.steps, child);\n      if (pending) return resume(engine, stmt, items, at + 1, scope, pending);\n    } catch (error) {\n      if (error instanceof BreakSignal) return undefined;\n      if (error instanceof ContinueSignal) continue;\n      throw error;\n    }\n  }\n  return undefined;\n}\n\nfunction slowSequential(\n  engine: Engine,\n  stmt: ForEachStmt,\n  items: readonly unknown[],\n  scope: Scope,\n): Pending {\n  for (let at = 0; at < items.length; at += 1) {\n    try {\n      const pending = iterate(engine, stmt, items[at], scope);\n      if (pending) return resume(engine, stmt, items, at + 1, scope, pending);\n    } catch (error) {\n      if (error instanceof BreakSignal) return undefined;\n      if (error instanceof ContinueSignal) continue;\n      throw error;\n    }\n  }\n  return undefined;\n}\n\nfunction iterate(engine: Engine, stmt: ForEachStmt, item: unknown, scope: Scope): Pending {\n  const child = scope.child();\n  child.set(stmt.item, item);\n  return runBlock(engine, stmt.body, child);\n}\n\nasync function resume(\n  engine: Engine,\n  stmt: ForEachStmt,\n  items: readonly unknown[],\n  from: number,\n  scope: Scope,\n  pending: Promise<void>,\n): Promise<void> {\n  try {\n    await pending;\n  } catch (error) {\n    if (error instanceof BreakSignal) return;\n    if (!(error instanceof ContinueSignal)) throw error;\n  }\n  for (let at = from; at < items.length; at += 1) {\n    try {\n      await iterate(engine, stmt, items[at], scope);\n    } catch (error) {\n      if (error instanceof BreakSignal) return;\n      if (error instanceof ContinueSignal) continue;\n      throw error;\n    }\n  }\n}\n\nasync function runIteration(args: {\n  engine: Engine;\n  stmt: ForEachStmt;\n  item: unknown;\n  scope: Scope;\n}): Promise<void> {\n  const child = args.scope.child();\n  child.set(args.stmt.item, args.item);\n  try {\n    await runBlock(args.engine, args.stmt.body, child);\n  } catch (error) {\n    if (error instanceof BreakSignal || error instanceof ContinueSignal) return;\n    throw error;\n  }\n}\n","import type { GroupDecl } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runBlock } from \"./run-block.js\";\n\n/** A group only clusters steps in the graph; it shares the enclosing scope. */\nexport async function runGroup(engine: Engine, stmt: GroupDecl, scope: Scope): Promise<void> {\n  await runBlock(engine, stmt.body, scope);\n}\n","import { evaluate, type IfStmt, isIfStmt, truthy } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { isPending } from \"./settled.js\";\n\n/** `if cond { … } else if … else { … }`: evaluate and run the taken branch. */\nexport function runIf(engine: Engine, stmt: IfStmt, scope: Scope): Pending {\n  const cond = evaluate(stmt.cond, scope);\n  if (isPending(cond)) return cond.then((value) => void taken(engine, stmt, scope, truthy(value)));\n  return taken(engine, stmt, scope, truthy(cond));\n}\n\nfunction taken(engine: Engine, stmt: IfStmt, scope: Scope, yes: boolean): Pending {\n  if (yes) return runBlock(engine, stmt.then, scope.child());\n  const branch = stmt.otherwise;\n  if (!branch) return undefined;\n  if (isIfStmt(branch)) return runIf(engine, branch, scope);\n  return runBlock(engine, branch, scope.child());\n}\n","import type { Engine } from \"./engine.types.js\";\n\n/**\n * A per-branch view of the engine carrying the cancellation signal.\n *\n * Into `ctx` as well as onto the engine: the statement walker checks the signal\n * between statements, but a branch parked inside a long action is only reachable\n * through the context the action was handed. Without it, cancelling a branch\n * waits for whatever it is already doing to finish on its own.\n */\nexport function branchEngine(engine: Engine, signal: AbortSignal): Engine {\n  return { ...engine, signal, ctx: { ...engine.ctx, signal } };\n}\n","import { evaluate, type MapLit } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\n\n/** Read a string field from an options map literal (e.g. `{ onError: \"cancel\" }`). */\nexport function optsText(opts: MapLit | undefined, key: string, scope: Scope): string | undefined {\n  const entry = opts?.entries.find((candidate) => candidate.key === key);\n  if (!entry) return undefined;\n  const value = evaluate(entry.value, scope);\n  return typeof value === \"string\" ? value : undefined;\n}\n","import type { ParallelStmt, Statement } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { branchEngine } from \"./branch-engine.js\";\nimport { runPool } from \"./concurrency.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { optsNumber } from \"./opts.js\";\nimport { optsText } from \"./opts-text.js\";\nimport { runStatement } from \"./run-statements.js\";\nimport { CancelSignal, isControlSignal } from \"./signals.js\";\n\n/**\n * `parallel { concurrency: 2, onError: \"collect\" } { … }`: run each child\n * statement concurrently.\n *\n * The block does not outlive itself. However it ends, every branch has either\n * finished or been cancelled by the time this returns: `Promise.all` on its own\n * rejects at the first failure and leaves the rest running, which is how a\n * finished test carries on making requests.\n */\nexport async function runParallel(engine: Engine, stmt: ParallelStmt, scope: Scope): Promise<void> {\n  const limit = optsNumber(stmt.opts, \"concurrency\", scope) ?? stmt.body.stmts.length;\n  const onError = optsText(stmt.opts, \"onError\", scope) ?? \"cancel\";\n  const controller = new AbortController();\n  const failures: unknown[] = [];\n  await runPool(stmt.body.stmts, Math.max(1, limit), (child) =>\n    branch({ engine, child, scope, controller, failures, onError }),\n  );\n  report(failures);\n}\n\ninterface BranchArgs {\n  engine: Engine;\n  child: Statement;\n  scope: Scope;\n  controller: AbortController;\n  failures: unknown[];\n  onError: string;\n}\n\n/**\n * One branch, and what its failure means for the others.\n *\n * `cancel`, the default, stops the siblings at their next statement boundary,\n * because a run that has already failed should stop working. `collect` lets them\n * all finish and reports every failure, which is what a set of independent\n * checks wants.\n */\nasync function branch(args: BranchArgs): Promise<void> {\n  const engine = branchEngine(args.engine, args.controller.signal);\n  try {\n    await runStatement(engine, args.child, args.scope.child());\n  } catch (error) {\n    if (error instanceof CancelSignal) return;\n    if (isControlSignal(error)) throw error;\n    args.failures.push(error);\n    if (args.onError === \"cancel\") args.controller.abort();\n  }\n}\n\n/**\n * One failure is raised as itself, so the reader sees the message the branch\n * produced. Several are raised together rather than one being picked.\n */\nfunction report(failures: readonly unknown[]): void {\n  if (failures.length === 0) return;\n  if (failures.length === 1) throw failures[0];\n  throw new AggregateError(failures, `${failures.length} parallel branches failed.`);\n}\n","import type { RaceStmt } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { branchEngine } from \"./branch-engine.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runStatement } from \"./run-statements.js\";\n\n/** `race { … }`: the first branch to settle wins, the losers are cancelled. */\nexport async function runRace(engine: Engine, stmt: RaceStmt, scope: Scope): Promise<void> {\n  const controller = new AbortController();\n  const branches = stmt.body.stmts.map((child) =>\n    Promise.resolve(runStatement(branchEngine(engine, controller.signal), child, scope.child())),\n  );\n  try {\n    await Promise.race(branches);\n  } finally {\n    controller.abort();\n    // The losers reject with CancelSignal once they reach a statement boundary.\n    for (const branch of branches) branch.catch(() => {});\n  }\n}\n","import {\n  buildProblem,\n  CODES,\n  evaluate,\n  ProblemError,\n  type RepeatStmt,\n  typeName,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSpan } from \"./node-span.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { BreakSignal, ContinueSignal } from \"./signals.js\";\n\n/** `repeat N as i { … }`: run the body N times, honouring break/continue. */\nexport async function runRepeat(engine: Engine, stmt: RepeatStmt, scope: Scope): Promise<void> {\n  const count = toCount(engine, stmt, evaluate(stmt.count, scope));\n  for (let i = 1; i <= count; i++) {\n    const child = scope.child();\n    if (stmt.index) child.set(stmt.index, i);\n    try {\n      const pending = runBlock(engine, stmt.body, child);\n      if (pending) await pending;\n    } catch (error) {\n      if (error instanceof BreakSignal) break;\n      if (error instanceof ContinueSignal) continue;\n      throw error;\n    }\n  }\n}\n\n/**\n * A count the machine cannot read as one is refused, because running the body\n * zero times would report success: `repeat cfg.times` with nothing behind\n * `times` would check nothing and pass.\n *\n * Zero and below still mean \"not at all\": a bound that computes to none is a\n * program saying so, not a mistake.\n */\nfunction toCount(engine: Engine, stmt: RepeatStmt, value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw notANumber(engine, stmt, value);\n  return value > 0 ? Math.floor(value) : 0;\n}\n\nfunction notANumber(engine: Engine, stmt: RepeatStmt, value: unknown): ProblemError {\n  return new ProblemError(\n    buildProblem({\n      spec: CODES.VN3016_NOT_A_NUMBER,\n      span: nodeSpan(stmt.count, engine.uri),\n      title: `repeat needs a number of times, and this is a ${typeName(value)}.`,\n      help: \"Give it a count, as in `repeat 3 { … }`.\",\n    }),\n  );\n}\n","import { VennError } from \"@venn-lang/contracts\";\nimport { evaluate, type FragmentDecl, type ParamList, type RunStmt } from \"@venn-lang/core\";\nimport { createScope, type Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { ReturnSignal } from \"./signals.js\";\n\n/** `run fragment(args) as x`: invoke a fragment and bind its return value. */\nexport async function runRun(engine: Engine, stmt: RunStmt, scope: Scope): Promise<void> {\n  const fragment = engine.fragments.get(stmt.target);\n  if (!fragment) throw unknownFragment(stmt.target);\n  const args = (stmt.args?.args ?? []).map((arg) => evaluate(arg.value, scope));\n  const fragScope = createScope();\n  bindParams(fragScope, fragment.params, args);\n  const value = await runFragment(engine, fragment, fragScope);\n  if (stmt.bind) scope.set(stmt.bind, value);\n}\n\nasync function runFragment(engine: Engine, fragment: FragmentDecl, scope: Scope): Promise<unknown> {\n  try {\n    await runBlock(engine, fragment.body, scope);\n    return undefined;\n  } catch (error) {\n    if (error instanceof ReturnSignal) return error.value;\n    throw error;\n  }\n}\n\nfunction bindParams(scope: Scope, params: ParamList | undefined, args: readonly unknown[]): void {\n  (params?.params ?? []).forEach((param, index) => {\n    scope.set(param.name, args[index]);\n  });\n}\n\nfunction unknownFragment(name: string): VennError {\n  return new VennError({\n    code: \"VN2005\",\n    message: `Unknown fragment \"${name}\".`,\n    detail: { fragment: name },\n  });\n}\n","import { type Block, isBlock, isStepDecl, type StepDecl } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { hasAnnotation, readLock } from \"./annotations.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { matchesTitle } from \"./filter.js\";\nimport { recordFlaky } from \"./flaky.js\";\nimport { runAround } from \"./run-around.js\";\nimport { runWithAnnotations, withLock } from \"./run-attempts.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { isControlSignal } from \"./signals.js\";\n\n/** Run a step honouring @skip/@only, @lock, @timeout and @retry; its bindings are step-local. */\nexport async function runStep(engine: Engine, step: StepDecl, parent: Scope): Promise<void> {\n  if (!included(engine, step)) return;\n  engine.emitter.emit({ kind: \"step.started\", data: { title: step.title } });\n  const before = engine.result.failed;\n  const scope = parent.child();\n  try {\n    await execute(engine, step, { parent, scope });\n  } catch (error) {\n    if (!isControlSignal(error)) finished(engine, step.title, \"failed\");\n    throw error;\n  }\n  recordFlaky(engine, step, before);\n  finished(engine, step.title, engine.result.failed > before ? \"failed\" : \"passed\");\n}\n\n/**\n * The gate `selectFlows` puts on a flow, put on a step: `@only` focuses, `@skip`\n * drops, and only then the `--step` title filter.\n *\n * A step is focused among the steps it stands with, meaning the block it was\n * written in, the way a flow is focused among the flows of its document.\n */\nfunction included(engine: Engine, step: StepDecl): boolean {\n  if (hasAnnotation(step, \"skip\")) return false;\n  if (focusing(step.$container) && !hasAnnotation(step, \"only\")) return false;\n  return matchesTitle(step.title, engine.filter.step);\n}\n\n/** Whether any step in this block asked to be the only one that runs. */\nconst focused = new WeakMap<Block, boolean>();\n\n/**\n * Answered once per block: the source cannot change mid-run, and a step inside a\n * `forEach` would otherwise re-read its siblings on every pass.\n */\nfunction focusing(container: unknown): boolean {\n  if (!isBlock(container)) return false;\n  const known = focused.get(container);\n  if (known !== undefined) return known;\n  const found = container.stmts.some((stmt) => isStepDecl(stmt) && hasAnnotation(stmt, \"only\"));\n  focused.set(container, found);\n  return found;\n}\n\nfunction execute(\n  engine: Engine,\n  step: StepDecl,\n  scopes: { parent: Scope; scope: Scope },\n): Promise<void> {\n  return withLock(engine, readLock(step), () =>\n    runWithAnnotations({\n      engine,\n      node: step,\n      scope: scopes.parent,\n      title: step.title,\n      // The caller wants a promise; a block that never suspended returns none.\n      run: () => runAround(step, () => runBlock(engine, step.body, scopes.scope)),\n    }),\n  );\n}\n\nfunction finished(engine: Engine, title: string, status: \"passed\" | \"failed\"): void {\n  engine.emitter.emit({ kind: \"step.finished\", data: { title, status } });\n}\n","import type { TryStmt } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { isControlSignal } from \"./signals.js\";\n\n/** `try { } catch e { } finally { }`: control signals pass through, errors go to catch. */\nexport async function runTry(engine: Engine, stmt: TryStmt, scope: Scope): Promise<void> {\n  try {\n    await runBlock(engine, stmt.body, scope.child());\n  } catch (error) {\n    if (isControlSignal(error)) throw error;\n    await runCatch({ engine, stmt, scope, error });\n  } finally {\n    if (stmt.finalizer) await runBlock(engine, stmt.finalizer, scope.child());\n  }\n}\n\nasync function runCatch(args: {\n  engine: Engine;\n  stmt: TryStmt;\n  scope: Scope;\n  error: unknown;\n}): Promise<void> {\n  if (!args.stmt.handler) return;\n  const child = args.scope.child();\n  if (args.stmt.error) child.set(args.stmt.error, toErrorValue(args.error));\n  await runBlock(args.engine, args.stmt.handler, child);\n}\n\nfunction toErrorValue(error: unknown): { message: string; code: string } {\n  const e = error as { message?: string; code?: string };\n  return { message: e?.message ?? String(error), code: e?.code ?? \"VN7000\" };\n}\n","import {\n  buildProblem,\n  CODES,\n  evaluate,\n  ProblemError,\n  truthy,\n  type WhileStmt,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSpan } from \"./node-span.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { settle } from \"./settled.js\";\nimport { BreakSignal, ContinueSignal } from \"./signals.js\";\n\n/**\n * Every `while` has an inherited timeout in the language; this is the hard cap\n * that stands in for it until timeouts are wired.\n */\nconst MAX_ITERATIONS = 100_000;\n\n/** `while cond { … }`: loop while the condition is truthy. */\nexport async function runWhile(engine: Engine, stmt: WhileStmt, scope: Scope): Promise<void> {\n  let guard = 0;\n  while (truthy(await settle(evaluate(stmt.cond, scope)))) {\n    if (++guard > MAX_ITERATIONS) throw neverFinished(engine, stmt);\n    try {\n      await runBlock(engine, stmt.body, scope.child());\n    } catch (error) {\n      if (error instanceof BreakSignal) break;\n      if (error instanceof ContinueSignal) continue;\n      throw error;\n    }\n  }\n}\n\n/**\n * Reaching the cap is not the loop finishing, so it is raised rather than\n * returned: stopping at the limit in silence would report a pass.\n */\nfunction neverFinished(engine: Engine, stmt: WhileStmt): ProblemError {\n  return new ProblemError(\n    buildProblem({\n      spec: CODES.VN8002_LOOP_LIMIT,\n      span: nodeSpan(stmt, engine.uri),\n      title: `This while loop ran ${MAX_ITERATIONS} times and its condition was still true.`,\n      help: \"Change something the condition reads inside the loop, or use `repeat n` to bound it.\",\n    }),\n  );\n}\n","import type {\n  ActionCall,\n  CaptureStmt,\n  ExpectStmt,\n  ForEachStmt,\n  GroupDecl,\n  IfStmt,\n  LetStmt,\n  ParallelStmt,\n  RaceStmt,\n  RepeatStmt,\n  ReturnStmt,\n  RunStmt,\n  Statement,\n  StepDecl,\n  TryStmt,\n  WhileStmt,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runActionStatement } from \"./run-action.js\";\nimport { runCapture, runLet, runReturn } from \"./run-bindings.js\";\nimport { runExpect } from \"./run-expect.js\";\nimport { runForEach } from \"./run-foreach.js\";\nimport { runGroup } from \"./run-group.js\";\nimport { runIf } from \"./run-if.js\";\nimport { runParallel } from \"./run-parallel.js\";\nimport { runRace } from \"./run-race.js\";\nimport { runRepeat } from \"./run-repeat.js\";\nimport { runRun } from \"./run-run.js\";\nimport { runStep } from \"./run-step.js\";\nimport { runTry } from \"./run-try.js\";\nimport { runWhile } from \"./run-while.js\";\nimport { BreakSignal, CancelSignal, ContinueSignal } from \"./signals.js\";\n\n/** Run a block's statements in order. */\nexport async function runStatements(\n  engine: Engine,\n  stmts: readonly Statement[],\n  scope: Scope,\n): Promise<void> {\n  for (const stmt of stmts) {\n    const pending = runStatement(engine, stmt, scope);\n    if (pending) await pending;\n  }\n}\n\n/**\n * Dispatch one statement to its handler. This is the single boundary where a\n * cancelled `race` branch stops advancing.\n *\n * Switched on `$type`, not on the `isXxx` guards: each guard asks Langium's\n * reflection whether one type is a subtype of another, and a chain of them costs\n * a double-digit share of a large `forEach`. `$type` is a plain string every\n * node carries, so one switch answers what thirteen questions would.\n */\nexport function runStatement(engine: Engine, stmt: Statement, scope: Scope): Pending {\n  if (engine.signal?.aborted) throw new CancelSignal();\n  switch (stmt.$type) {\n    case \"LetStmt\":\n      return runLet(engine, stmt as LetStmt, scope);\n    case \"ActionCall\":\n      return runActionStatement(engine, stmt as ActionCall, scope);\n    case \"ExpectStmt\":\n      return runExpect(engine, stmt as ExpectStmt, scope);\n    case \"IfStmt\":\n      return runIf(engine, stmt as IfStmt, scope);\n    case \"StepDecl\":\n      return runStep(engine, stmt as StepDecl, scope);\n    case \"GroupDecl\":\n      return runGroup(engine, stmt as GroupDecl, scope);\n    default:\n      return control(engine, stmt, scope);\n  }\n}\n\n/** Loops, concurrency and the control-flow signals: the rarer half. */\nfunction control(engine: Engine, stmt: Statement, scope: Scope): Pending {\n  switch (stmt.$type) {\n    case \"ForEachStmt\":\n      return runForEach(engine, stmt as ForEachStmt, scope);\n    case \"RepeatStmt\":\n      return runRepeat(engine, stmt as RepeatStmt, scope);\n    case \"WhileStmt\":\n      return runWhile(engine, stmt as WhileStmt, scope);\n    case \"ParallelStmt\":\n      return runParallel(engine, stmt as ParallelStmt, scope);\n    case \"RaceStmt\":\n      return runRace(engine, stmt as RaceStmt, scope);\n    case \"TryStmt\":\n      return runTry(engine, stmt as TryStmt, scope);\n    case \"RunStmt\":\n      return runRun(engine, stmt as RunStmt, scope);\n    default:\n      return leaf(stmt, scope);\n  }\n}\n\nfunction leaf(stmt: Statement, scope: Scope): Pending {\n  if (stmt.$type === \"CaptureStmt\") return runCapture(stmt as CaptureStmt, scope);\n  if (stmt.$type === \"ReturnStmt\") return runReturn(stmt as ReturnStmt, scope);\n  if (stmt.$type === \"BreakStmt\") throw new BreakSignal();\n  if (stmt.$type === \"ContinueStmt\") throw new ContinueSignal();\n  // LifecycleDecl (on/defer) is handled by runBlock / runFlow, not here.\n  return undefined;\n}\n","import {\n  type Block,\n  compileExpr,\n  isLetStmt,\n  isLifecycleDecl,\n  type LetStmt,\n  type Statement,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { actionCall } from \"./invocation.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runStatement } from \"./run-statements.js\";\nimport { isPending } from \"./settled.js\";\n\n/** One statement of a block, bound to everything the source already settled. */\nexport type Step = (engine: Engine, scope: Scope) => Pending;\n\n/** A block reduced to what running it needs, decided once from the source. */\nexport interface BlockPlan {\n  readonly steps: readonly Step[];\n  readonly defers: boolean;\n}\n\nconst plans = new WeakMap<Block, BlockPlan>();\n\n/** The plan for a block, built on first use and cached against the node itself. */\nexport function planOf(block: Block): BlockPlan {\n  const known = plans.get(block);\n  if (known) return known;\n  const built: BlockPlan = {\n    steps: block.stmts.map(stepOf),\n    defers: block.stmts.some(isDefer),\n  };\n  plans.set(block, built);\n  return built;\n}\n\nfunction isDefer(stmt: Statement): boolean {\n  return isLifecycleDecl(stmt) && stmt.hook === \"defer\";\n}\n\nfunction stepOf(stmt: Statement): Step {\n  return plainLet(stmt) ?? ((engine, scope) => runStatement(engine, stmt, scope));\n}\n\n/**\n * `const y = x * 2`: no trailing args, no options map, and a value that is not a\n * dotted path, so no registry lookup can turn it into a verb. The name, the\n * compiled expression and the decision are all fixed by the source.\n */\nfunction plainLet(stmt: Statement): Step | undefined {\n  if (!isLetStmt(stmt)) return undefined;\n  const let_ = stmt as LetStmt;\n  if (let_.args.length > 0 || let_.opts) return undefined;\n  const call = actionCall(let_.value);\n  if (call && call.target.indexOf(\".\") >= 0) return undefined;\n  const name = let_.name;\n  const thunk = compileExpr(let_.value);\n  return (_engine, scope) => bind(name, thunk(scope), scope);\n}\n\nfunction bind(name: string, value: unknown, scope: Scope): Pending {\n  if (isPending(value)) return value.then((settled) => scope.set(name, settled));\n  return void scope.set(name, value);\n}\n","import { type Block, isLifecycleDecl, type LifecycleDecl, type Statement } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { type BlockPlan, planOf, type Step } from \"./block-plan.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport type { Pending } from \"./pending.types.js\";\nimport { runStatement } from \"./run-statements.js\";\nimport { CancelSignal } from \"./signals.js\";\n\n/**\n * Run a block's statements in order, running any `defer { … }` bodies LIFO on\n * the way out, including on error or a control-flow signal.\n */\nexport function runBlock(engine: Engine, block: Block, scope: Scope): Pending {\n  const plan = planOf(block);\n  if (plan.defers) return withDefers(engine, block, scope);\n  return runSteps(engine, plan.steps, scope);\n}\n\n/** The walk over a plan, reusable by a loop that hoists `planOf` out of it. */\nexport function runSteps(engine: Engine, steps: readonly Step[], scope: Scope): Pending {\n  for (let at = 0; at < steps.length; at += 1) {\n    if (engine.signal?.aborted) throw new CancelSignal();\n    const pending = (steps[at] as Step)(engine, scope);\n    if (pending) return resume(engine, steps, at + 1, scope, pending);\n  }\n  return undefined;\n}\n\nasync function resume(\n  engine: Engine,\n  steps: readonly Step[],\n  from: number,\n  scope: Scope,\n  pending: Promise<void>,\n): Promise<void> {\n  await pending;\n  for (let at = from; at < steps.length; at += 1) {\n    if (engine.signal?.aborted) throw new CancelSignal();\n    const next = (steps[at] as Step)(engine, scope);\n    if (next) await next;\n  }\n}\n\nasync function withDefers(engine: Engine, block: Block, scope: Scope): Promise<void> {\n  const defers: Block[] = [];\n  try {\n    for (const stmt of block.stmts) {\n      if (isDefer(stmt)) {\n        defers.unshift(stmt.body);\n        continue;\n      }\n      const pending = runStatement(engine, stmt, scope);\n      if (pending) await pending;\n    }\n  } finally {\n    const cleanup: Engine = { ...engine, signal: undefined };\n    for (const body of defers) await runBlock(cleanup, body, scope.child());\n  }\n}\n\nfunction isDefer(stmt: Statement): stmt is LifecycleDecl {\n  return isLifecycleDecl(stmt) && stmt.hook === \"defer\";\n}\n\nexport type { BlockPlan };\n","import { buildProblem, CODES, type LifecycleDecl, type Problem } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { nodeSpan } from \"./node-span.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { ExitSignal, isControlSignal } from \"./signals.js\";\n\n/**\n * Run a set of lifecycle blocks (setup/teardown/beforeEach/afterEach) in order.\n *\n * The caller passes the scope the hooks belong to (the suite root for\n * setup/teardown, the flow's own scope for beforeEach/afterEach) and each body\n * runs in a child of it, the way the `on` handlers below do. In a parentless\n * scope `env`, the prelude, the top-level bindings and the open resources would\n * all read as undefined and the hook would run anyway: a teardown written as\n * `db.exec \"DELETE FROM orders WHERE run = '${env.RUN_ID}'\"` deletes the table\n * it was meant to tidy.\n */\nexport async function runHooks(args: {\n  engine: Engine;\n  hooks: readonly LifecycleDecl[];\n  scope: Scope;\n}): Promise<void> {\n  for (const hook of args.hooks) await runHook(args.engine, hook, args.scope);\n}\n\n/**\n * Run the `on <event>` handlers whose event matches (e.g. \"failure\"/\"success\").\n *\n * Through the same boundary as the hooks above: a handler that reacts to a\n * failure by failing itself is a second failure, not the end of the run.\n */\nexport async function runOnHandlers(args: {\n  engine: Engine;\n  handlers: readonly LifecycleDecl[];\n  event: string;\n  scope: Scope;\n}): Promise<void> {\n  for (const handler of args.handlers) {\n    if (handler.event === args.event) await runHook(args.engine, handler, args.scope);\n  }\n}\n\n/**\n * A hook that throws fails the suite instead of ending the run: it is counted\n * and reported, and the walk carries on to `run.finished`, so the reporters\n * still close their files and the files after this one still run.\n */\nasync function runHook(engine: Engine, hook: LifecycleDecl, scope: Scope): Promise<void> {\n  try {\n    await runBlock(engine, hook.body, scope.child());\n  } catch (error) {\n    // Read as a flow body reads it: `break`/`return` unwind, they do not fail.\n    // `exit` is not the hook's to absorb: it ends the run, and the code it\n    // carries is the whole verdict, so it keeps unwinding to whoever ends it.\n    if (error instanceof ExitSignal) throw error;\n    if (!isControlSignal(error)) recordFailure({ engine, hook, error });\n  }\n}\n\n/**\n * Counted where a failing flow is counted, and carried on the event that already\n * puts a Problem in front of every reporter. A hook failure the reporters never\n * hear about ends as a green artifact over a broken run.\n */\nfunction recordFailure(args: { engine: Engine; hook: LifecycleDecl; error: unknown }): void {\n  args.engine.result.failed += 1;\n  args.engine.emitter.emit({ kind: \"expect.failed\", data: { problem: hookProblem(args) } });\n}\n\nfunction hookProblem(args: { engine: Engine; hook: LifecycleDecl; error: unknown }): Problem {\n  return buildProblem({\n    spec: CODES.VN7004_HOOK_FAILED,\n    span: nodeSpan(args.hook, args.engine.uri),\n    title: `${hookLabel(args.hook)} failed: ${messageOf(args.error)}`,\n  });\n}\n\n/** The block named the way the user wrote it: `setup`, or `on failure`. */\nfunction hookLabel(hook: LifecycleDecl): string {\n  return hook.hook ?? (hook.event ? `on ${hook.event}` : \"lifecycle\");\n}\n\nfunction messageOf(error: unknown): string {\n  return (error as { message?: string })?.message ?? String(error);\n}\n","import { type FlowDecl, isLifecycleDecl, type LifecycleDecl, ProblemError } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { hasAnnotation, readLock } from \"./annotations.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { recordFlaky } from \"./flaky.js\";\nimport { runAround } from \"./run-around.js\";\nimport { runWithAnnotations, withLock } from \"./run-attempts.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { runOnHandlers } from \"./run-lifecycle.js\";\nimport { ExitSignal, isControlSignal } from \"./signals.js\";\n\n/** Run a flow: body, then its `on failure`/`on success` handlers, then finish. */\nexport async function runFlow(engine: Engine, flow: FlowDecl, scope: Scope): Promise<void> {\n  engine.emitter.emit({ kind: \"flow.started\", data: { title: flow.title } });\n  const before = engine.result.failed;\n  const handlers = flow.body.stmts.filter(isOnHandler);\n  await runFlowBody(engine, flow, scope);\n  recordFlaky(engine, flow, before);\n  const status = engine.result.failed > before ? \"failed\" : \"passed\";\n  const event = status === \"failed\" ? \"failure\" : \"success\";\n  await runOnHandlers({ engine, handlers, event, scope });\n  engine.emitter.emit({ kind: \"flow.finished\", data: { title: flow.title, status } });\n}\n\nasync function runFlowBody(engine: Engine, flow: FlowDecl, scope: Scope): Promise<void> {\n  try {\n    await withLock(engine, flowLock(flow), () =>\n      runWithAnnotations({\n        engine,\n        node: flow,\n        scope,\n        title: flow.title,\n        // The caller wants a promise; a block that never suspended returns none.\n        run: () => runAround(flow, () => runBlock(engine, flow.body, scope)),\n      }),\n    );\n  } catch (error) {\n    // `break`/`return` end the flow and no more than that. `exit` is not the\n    // flow's to absorb: it ends the run, so it keeps unwinding.\n    if (error instanceof ExitSignal) throw error;\n    if (!isControlSignal(error)) recordError(engine, error);\n  }\n}\n\n/** `@lock(\"x\")` uses a named mutex; `@serial` serialises runs of the same flow. */\nfunction flowLock(flow: FlowDecl): string | undefined {\n  return readLock(flow) ?? (hasAnnotation(flow, \"serial\") ? `serial:${flow.title}` : undefined);\n}\n\nfunction isOnHandler(stmt: unknown): stmt is LifecycleDecl {\n  return isLifecycleDecl(stmt) && Boolean((stmt as LifecycleDecl).event);\n}\n\n/**\n * A failure the flow itself could not handle.\n *\n * One that already knows what it is (a Problem, with its code, its span and its\n * help) travels on the event every reporter reads for failures. Flattening it to\n * a log line would strip the code and the location the raiser worked out.\n */\nfunction recordError(engine: Engine, error: unknown): void {\n  engine.result.failed += 1;\n  if (error instanceof ProblemError) {\n    engine.emitter.emit({ kind: \"expect.failed\", data: { problem: error.problem } });\n    return;\n  }\n  const message = (error as { message?: string })?.message ?? String(error);\n  engine.emitter.emit({ kind: \"log\", data: { level: \"error\", message } });\n}\n","import {\n  type Block,\n  type Declaration,\n  type Document,\n  isLifecycleDecl,\n  isRunnable,\n  type LifecycleDecl,\n} from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runBlock } from \"./run-block.js\";\nimport { runStatement } from \"./run-statements.js\";\n\n/** A cleanup a program deferred, to be run on the way out. */\nexport type Teardown = () => Promise<void>;\n\n/**\n * A document's top-level statements, run once, in the order they are written.\n *\n * The same lines mean the same thing in both modes: a script *is* its prologue,\n * and a test file runs one before its flows. So a `const` calling a verb at the\n * top of a file opens the thing either way, and the flows never find `null`.\n *\n * @param args.into Where deferred cleanups accumulate, in written order. A\n * program's ending is registered before its statements run, so it has to see\n * what they defer as they reach it rather than afterwards.\n * @returns The teardowns collected, which is `into` when one was supplied.\n */\nexport async function runPrologue(args: {\n  engine: Engine;\n  doc: Document;\n  scope: Scope;\n  into?: Teardown[];\n}): Promise<Teardown[]> {\n  const teardowns = args.into ?? [];\n  for (const node of args.doc.decls) {\n    if (isDefer(node)) teardowns.push(deferred({ ...args, body: node.body }));\n    else if (isRunnable(node)) await runStatement(args.engine, node, args.scope);\n  }\n  return teardowns;\n}\n\n/** `defer { … }` written at the top of a file: registered here, run on the way out. */\nfunction isDefer(node: Declaration): node is Declaration & LifecycleDecl {\n  return isLifecycleDecl(node) && node.hook === \"defer\";\n}\n\nfunction deferred(args: { engine: Engine; body: Block; scope: Scope }): Teardown {\n  // Cleanup must complete even when what it tidies was cancelled mid-flight.\n  const engine: Engine = { ...args.engine, signal: undefined };\n  return async () => {\n    await runBlock(engine, args.body, args.scope.child());\n  };\n}\n\n/** Undo in reverse: what opened last is given back first. */\nexport async function runTeardowns(teardowns: readonly Teardown[]): Promise<void> {\n  for (const teardown of [...teardowns].reverse()) await teardown();\n}\n","import {\n  type Document,\n  evaluate,\n  type FlowDecl,\n  isFlowDecl,\n  isMatrixDecl,\n  isStepDecl,\n  type PlannedStep,\n  type RunPlan,\n} from \"@venn-lang/core\";\nimport { createScope, type Scope } from \"../scope/index.js\";\nimport { absorbExit } from \"./absorb-exit.js\";\nimport { hasAnnotation, readTags } from \"./annotations.js\";\nimport { createBaseScope } from \"./base-scope.js\";\nimport { bindGlobals } from \"./bind-globals.js\";\nimport { bindImports } from \"./bind-imports.js\";\nimport { collectHooks, type SuiteHooks } from \"./collect.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { matchesTitle } from \"./filter.js\";\nimport { settleFlaky } from \"./flaky.js\";\nimport { runFlow } from \"./run-flow.js\";\nimport { runHooks } from \"./run-lifecycle.js\";\nimport { runPrologue, runTeardowns } from \"./run-prologue.js\";\n\n/**\n * Walk a document: setup once, then for each `matrix` variant bind `env`/`matrix`\n * globals, open resources, run flows (with before/afterEach), close resources.\n */\nexport async function runDocument(engine: Engine, doc: Document): Promise<void> {\n  const flows = selectFlows(engine, doc.decls.filter(isFlowDecl));\n  const hooks = collectHooks(doc);\n  engine.emitter.emit({ kind: \"run.started\", data: { plan: planOf(flows) } });\n  const start = engine.clock.now();\n  await runSuite({ engine, doc, flows, hooks });\n  settleFlaky(engine);\n  const durationMs = engine.clock.now() - start;\n  engine.emitter.emit({ kind: \"run.finished\", data: { ...engine.result, durationMs } });\n}\n\n/**\n * Suite hooks run once, on either side of every variant, so they get a root of\n * their own: the document's bindings without any one variant's `matrix`.\n *\n * An `exit` in `setup` ends the run where it stands, so the variants never\n * start, and `teardown` still runs, because what `setup` opened is still open.\n * Both sides absorb their own, so the code reaches the host and `run.finished`\n * is still emitted above.\n */\nasync function runSuite(args: {\n  engine: Engine;\n  doc: Document;\n  flows: readonly FlowDecl[];\n  hooks: SuiteHooks;\n}): Promise<void> {\n  const { engine, hooks } = args;\n  const suite = rootScope({ engine, doc: args.doc, variant: {} });\n  await absorbExit(engine, async () => {\n    await runHooks({ engine, hooks: hooks.setup, scope: suite });\n    await runVariants(args);\n  });\n  await absorbExit(engine, () => runHooks({ engine, hooks: hooks.teardown, scope: suite }));\n}\n\n/** Every `matrix` variant is a full pass over the flows, one after the other. */\nasync function runVariants(args: {\n  engine: Engine;\n  doc: Document;\n  flows: readonly FlowDecl[];\n  hooks: SuiteHooks;\n}): Promise<void> {\n  for (const variant of matrixVariants(args.engine, args.doc)) {\n    await runVariant({ ...args, variant });\n  }\n}\n\nasync function runVariant(args: {\n  engine: Engine;\n  doc: Document;\n  flows: readonly FlowDecl[];\n  hooks: SuiteHooks;\n  variant: Record<string, unknown>;\n}): Promise<void> {\n  const root = rootScope({ engine: args.engine, doc: args.doc, variant: args.variant });\n  const teardowns = await runPrologue({ engine: args.engine, doc: args.doc, scope: root });\n  try {\n    await runFlows({ ...args, root });\n  } finally {\n    // Whatever ends the pass, a failure or an `exit` on its way out of the run,\n    // the suite still gives back what it opened.\n    await runTeardowns(teardowns);\n  }\n}\n\nasync function runFlows(args: {\n  engine: Engine;\n  flows: readonly FlowDecl[];\n  hooks: SuiteHooks;\n  root: Scope;\n}): Promise<void> {\n  for (const flow of args.flows) {\n    await runFlowWithHooks({ engine: args.engine, flow, hooks: args.hooks, root: args.root });\n    if (args.engine.bail && args.engine.result.failed > 0) break;\n  }\n}\n\nasync function runFlowWithHooks(args: {\n  engine: Engine;\n  flow: FlowDecl;\n  hooks: SuiteHooks;\n  root: Scope;\n}): Promise<void> {\n  // A scope of its own, so what `beforeEach` opens dies with the flow that\n  // needed it rather than lingering into the next one.\n  const scope = args.root.child();\n  const each = { engine: args.engine, scope };\n  await runHooks({ ...each, hooks: args.hooks.beforeEach });\n  await runFlow(args.engine, args.flow, scope);\n  await runHooks({ ...each, hooks: args.hooks.afterEach });\n}\n\n/**\n * The scope a run reads from: the prelude, the plugin namespaces, `env`, the\n * matrix variant and the document's own globals. One per variant, so what one\n * variant binds is never visible to the next.\n */\nfunction rootScope(args: {\n  engine: Engine;\n  doc: Document;\n  variant: Record<string, unknown>;\n}): Scope {\n  const base = (): Scope => createBaseScope({ engine: args.engine, variant: args.variant });\n  const root = base();\n  const graph = args.engine.imports;\n  // Before the document's own globals, so a local name of the same spelling\n  // wins. That is the rule fragments already follow.\n  if (graph) {\n    bindImports({ document: args.doc, uri: args.engine.uri, scope: root, graph, base });\n  }\n  bindGlobals(args.doc, root);\n  return root;\n}\n\n/** The cartesian product of the `matrix { … }` dimensions, else one empty variant. */\nfunction matrixVariants(engine: Engine, doc: Document): Record<string, unknown>[] {\n  const matrix = doc.decls.find(isMatrixDecl);\n  if (!matrix) return [{}];\n  const scope = createScope();\n  scope.set(\"env\", engine.env);\n  return product(evaluate(matrix.body, scope) as Record<string, unknown>);\n}\n\nfunction product(dims: Record<string, unknown>): Record<string, unknown>[] {\n  let combos: Record<string, unknown>[] = [{}];\n  for (const [key, values] of Object.entries(dims)) {\n    const list = Array.isArray(values) ? values : [values];\n    combos = combos.flatMap((combo) => list.map((value) => ({ ...combo, [key]: value })));\n  }\n  return combos;\n}\n\n/** `@only` focuses, `@skip` drops, then the runner's own `--flow` / `--tags` filters. */\nfunction selectFlows(engine: Engine, flows: readonly FlowDecl[]): FlowDecl[] {\n  const only = flows.filter((flow) => hasAnnotation(flow, \"only\"));\n  const pool = only.length > 0 ? only : flows;\n  const kept = pool.filter((flow) => !hasAnnotation(flow, \"skip\"));\n  const named = kept.filter((flow) => matchesTitle(flow.title, engine.filter.flow));\n  return byTags(named, engine.filter.tags);\n}\n\nfunction byTags(flows: FlowDecl[], tags: readonly string[] | undefined): FlowDecl[] {\n  if (!tags || tags.length === 0) return flows;\n  return flows.filter((flow) => readTags(flow).some((tag) => tags.includes(tag)));\n}\n\nfunction planOf(flows: readonly FlowDecl[]): RunPlan {\n  return { flows: flows.map((flow) => ({ title: flow.title, steps: stepTitles(flow) })) };\n}\n\nfunction stepTitles(flow: FlowDecl): PlannedStep[] {\n  return flow.body.stmts.filter(isStepDecl).map((step) => ({ title: step.title }));\n}\n","import type { Document } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { collectHooks } from \"./collect.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runHooks } from \"./run-lifecycle.js\";\nimport type { Teardown } from \"./run-prologue.js\";\nimport { runTeardowns } from \"./run-prologue.js\";\n\n/**\n * The program's `setup`, run before its first statement.\n *\n * It reads what the file declared, its functions, rather than what its\n * statements bind, because none of them has run yet. A `setup` that wants a\n * connection opens one.\n */\nexport async function runSetup(args: {\n  engine: Engine;\n  doc: Document;\n  scope: Scope;\n}): Promise<void> {\n  await runHooks({ engine: args.engine, hooks: collectHooks(args.doc).setup, scope: args.scope });\n}\n\n/** What the program will do on the way out, filled in as the program runs. */\nexport interface Ending {\n  /** Cleanups the statements deferred, in the order they were written. */\n  readonly deferred: Teardown[];\n}\n\n/**\n * Say how the program ends, before it starts.\n *\n * Registered up front because the ending has to be in place for an interrupt\n * that arrives mid-statement, while what it runs is decided later, as the\n * statements defer things. One entry rather than one per `defer`, so the order\n * is stated here instead of falling out of a stack: `teardown` first, while the\n * connections it needs are still open, then the deferred work in reverse.\n */\nexport function registerEnding(args: { engine: Engine; doc: Document; scope: Scope }): Ending {\n  const ending: Ending = { deferred: [] };\n  const teardown = collectHooks(args.doc).teardown;\n  args.engine.cleanup.add(async () => {\n    await runHooks({ engine: args.engine, hooks: teardown, scope: args.scope });\n    await runTeardowns(ending.deferred);\n  });\n  return ending;\n}\n","import type { Document } from \"@venn-lang/core\";\nimport type { Scope } from \"../scope/index.js\";\nimport { absorbExit } from \"./absorb-exit.js\";\nimport { createBaseScope } from \"./base-scope.js\";\nimport { bindFunctions } from \"./bind-globals.js\";\nimport { bindImports } from \"./bind-imports.js\";\nimport type { Engine } from \"./engine.types.js\";\nimport { runPrologue } from \"./run-prologue.js\";\nimport { registerEnding, runSetup } from \"./script-lifecycle.js\";\n\n/**\n * Run a document as a program: its top-level statements, in order, top to\n * bottom, because the file itself is the entry point. Declarations (`flow`,\n * `fn`, `type`, …) are definitions and run only when something calls them.\n *\n * `setup`, `teardown` and `defer` are the program's own lifetime: `setup` runs\n * before the first statement and the rest are handed to the host to run on the\n * way out, because a program that serves outlives its last line.\n */\nexport async function runScript(engine: Engine, doc: Document): Promise<void> {\n  const base = (): Scope => createBaseScope({ engine });\n  const root = base();\n  const graph = engine.imports;\n  if (graph) bindImports({ document: doc, uri: engine.uri, scope: root, graph, base });\n  bindFunctions(doc, root);\n  engine.emitter.emit({ kind: \"run.started\", data: { plan: { flows: [] } } });\n  const start = engine.clock.now();\n  await absorbExit(engine, () => runProgram(engine, doc, root));\n  const durationMs = engine.clock.now() - start;\n  engine.emitter.emit({ kind: \"run.finished\", data: { ...engine.result, durationMs } });\n}\n\n/**\n * The program's lifetime: its `setup`, the ending it declared, then its\n * statements, all inside the one absorb, because `setup` is as much the program\n * as its first line. Outside it, an `exit` in `setup` would escape past\n * `run.finished` and leave the stream open.\n *\n * The ending is registered whatever happens to `setup`: a setup that exited or\n * failed still opened what it opened, and `teardown` is how it gives it back.\n */\nasync function runProgram(engine: Engine, doc: Document, scope: Scope): Promise<void> {\n  const ending = registerEnding({ engine, doc, scope });\n  await runSetup({ engine, doc, scope });\n  // Collected into the ending as they are reached, so a program interrupted\n  // halfway gives back exactly what it had managed to take.\n  await runPrologue({ engine, doc, scope, into: ending.deferred });\n}\n","import type { MapLit, Problem } from \"@venn-lang/core\";\nimport { unknownOptions } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\n\n/**\n * Check the keys of an options map against the action's own schema.\n *\n * The runtime refuses an unknown key too, but only when the flow reaches that\n * line. Both read the same list and say the same sentence, so the editor can\n * mark the word before anything runs.\n */\nexport function checkOptions(args: {\n  opts: MapLit | undefined;\n  params: unknown;\n  ctx: CheckContext;\n}): Problem[] {\n  return unknownOptions({ opts: args.opts, params: args.params, uri: args.ctx.uri });\n}\n","import {\n  type ActionCall,\n  type AstNode,\n  buildProblem,\n  type CaptureStmt,\n  CODES,\n  type LetStmt,\n  type MapLit,\n  type Problem,\n} from \"@venn-lang/core\";\nimport { actionTarget, nodeSpan, PRELUDE, resolveTarget, splitTarget } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\nimport { checkOptions } from \"./check-options.js\";\n\n/** `http.get \"…\"` written as a statement. */\nexport function checkAction(call: ActionCall, ctx: CheckContext): Problem[] {\n  return checkTarget({ node: call, target: call.target, opts: call.opts, ctx });\n}\n\n/**\n * `let auth = http.post url { … }`. Only the unmistakable call is checked: with\n * no arguments the path could be a field of a variable this pass cannot see, and\n * a false \"unknown action\" is worse than a missed one.\n */\nexport function checkLet(stmt: LetStmt, ctx: CheckContext): Problem[] {\n  if (stmt.args.length === 0 && !stmt.opts) return [];\n  const target = actionTarget(stmt.value);\n  if (target === undefined) {\n    return [problem(stmt, ctx, CODES.VN2003_UNKNOWN_ACTION, \"This is not an action to call.\")];\n  }\n  return checkTarget({ node: stmt, target, opts: stmt.opts, ctx });\n}\n\n/** `capture` is folded into `let`; say so where it is written. */\nexport function checkCapture(stmt: CaptureStmt, ctx: CheckContext): Problem {\n  const title =\n    \"`capture` was removed — use `let` for a value that changes, `const` for one that does not.\";\n  return problem(stmt, ctx, CODES.VN5001_REMOVED_KEYWORD, title);\n}\n\n/**\n * A namespace is only usable when this file brought it in with `use` (or it is\n * a resource). Loading the whole stdlib must not make `use` optional.\n */\nfunction checkTarget(args: {\n  node: AstNode;\n  target: string;\n  opts: MapLit | undefined;\n  ctx: CheckContext;\n}): Problem[] {\n  const { node, target, ctx } = args;\n  if (PRELUDE.has(target)) return [];\n  const written = splitTarget(target).namespace;\n  if (ctx.bound.has(written)) return [];\n  if (!ctx.imported.has(written)) return [missingImport(args, written)];\n  const resolved = ctx.registry.action(resolveTarget(target, ctx.aliases));\n  if (!resolved) {\n    return [problem(node, ctx, CODES.VN2003_UNKNOWN_ACTION, `Unknown action \"${target}\".`)];\n  }\n  return checkOptions({ opts: args.opts, params: resolved.action.params, ctx });\n}\n\nfunction missingImport(\n  args: { node: AstNode; target: string; ctx: CheckContext },\n  namespace: string,\n): Problem {\n  if (!args.ctx.registry.hasNamespace(namespace)) {\n    const title = `Unknown action \"${args.target}\" — no loaded plugin provides it.`;\n    return problem(args.node, args.ctx, CODES.VN2003_UNKNOWN_ACTION, title);\n  }\n  const title = `\"${namespace}\" is not imported in this file — add a \\`use\\` for its package.`;\n  return problem(args.node, args.ctx, CODES.VN2007_NAMESPACE_NOT_IMPORTED, title);\n}\n\nfunction problem(\n  node: AstNode,\n  ctx: CheckContext,\n  spec: (typeof CODES)[keyof typeof CODES],\n  title: string,\n): Problem {\n  return buildProblem({ spec, span: nodeSpan(node, ctx.uri), title });\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  type DecoDecl,\n  decoCannotCall,\n  isActionCall,\n  isDecoDecl,\n  isLetStmt,\n  type Problem,\n} from \"@venn-lang/core\";\nimport { actionTarget, nodeSpan, PRELUDE, splitTarget } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\n\n/**\n * Check a node written inside a `deco` body, which is not the program and so is\n * not resolved against the registry: `target.wrap(f)` is a verb on the handle\n * the body was handed, and expansion settles what the rest means. The one\n * refusal this pass can make is a verb from a plugin, which cannot work in a\n * `deco` because a decorator runs before the program exists.\n *\n * @returns The node's problems, or `undefined` when the node is not inside a\n * `deco`, which tells the caller to apply the ordinary document checks instead.\n */\nexport function checkInsideDeco(node: AstNode, ctx: CheckContext): Problem[] | undefined {\n  const deco = enclosingDeco(node);\n  if (!deco) return undefined;\n  const target = calledTarget(node);\n  const refused = target === undefined ? undefined : pluginVerb({ deco, target, ctx });\n  return refused ? [problem(node, ctx, refused)] : [];\n}\n\n/** The `deco` this node is written inside, if any. */\nfunction enclosingDeco(node: AstNode): DecoDecl | undefined {\n  for (let at: AstNode | undefined = node; at; at = at.$container) {\n    if (isDecoDecl(at)) return at;\n  }\n  return undefined;\n}\n\n/** The dotted name this statement calls, if calling is what it does. */\nfunction calledTarget(node: AstNode): string | undefined {\n  if (isActionCall(node)) return node.target;\n  if (!isLetStmt(node) || (node.args.length === 0 && !node.opts)) return undefined;\n  return actionTarget(node.value);\n}\n\n/**\n * Why this call cannot be made from here, if it cannot. Only a head the file can\n * already account for is refused: an imported namespace, a resource, a namespace\n * some loaded plugin owns. Anything else is a name only expansion resolves, and\n * guessing at it would put an error on every well-written decorator.\n */\nfunction pluginVerb(args: {\n  deco: DecoDecl;\n  target: string;\n  ctx: CheckContext;\n}): string | undefined {\n  const { namespace } = splitTarget(args.target);\n  if (PRELUDE.has(args.target) || paramNames(args.deco).has(namespace)) return undefined;\n  if (!reachesTheWorld(namespace, args.ctx)) return undefined;\n  return decoCannotCall(args.target);\n}\n\nfunction reachesTheWorld(namespace: string, ctx: CheckContext): boolean {\n  return (\n    ctx.imported.has(namespace) || ctx.bound.has(namespace) || ctx.registry.hasNamespace(namespace)\n  );\n}\n\nfunction paramNames(deco: DecoDecl): Set<string> {\n  return new Set((deco.params?.params ?? []).map((param) => param.name));\n}\n\nfunction problem(node: AstNode, ctx: CheckContext, title: string): Problem {\n  return buildProblem({ spec: CODES.VN2016_DECO_IMPURE, span: nodeSpan(node, ctx.uri), title });\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  isMember,\n  type Problem,\n  type Span,\n} from \"@venn-lang/core\";\nimport { actionTarget, nodeSpan } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\n\n/** `env.NAME` as it appears inside a `${…}` placeholder. */\nconst ENV_READ = /\\benv\\.([A-Za-z_]\\w*)/g;\n\n/** Always present: the runner sets it to the `--env` that was selected. */\nconst BUILT_IN = new Set([\"name\"]);\n\n/**\n * Match every `env.*` read against what `venn.toml` declares, so a typo is an\n * error rather than an empty string and a puzzling 404.\n *\n * Nothing is reported when the manifest could not be read: a wrong error about a\n * variable that does exist is worse than no error at all.\n */\nexport function checkEnv(node: AstNode, ctx: CheckContext): Problem[] {\n  if (!isMember(node) || isMember(node.$container)) return [];\n  const path = actionTarget(node);\n  const name = path?.startsWith(\"env.\") ? path.slice(4) : undefined;\n  if (name === undefined || name.includes(\".\")) return [];\n  const span = nodeSpan(node, ctx.uri);\n  if (!ctx.imported.has(\"env\")) return [notImported(span)];\n  if (!ctx.env || declared(name, ctx.env)) return [];\n  return [envProblem(name, span, ctx)];\n}\n\n/**\n * Configuration is brought in like anything else. Reading `env.*` without saying\n * where it comes from is the same hole `use` closes for actions and matchers:\n * the reader should not have to know which names are magic.\n */\nfunction notImported(span: Span): Problem {\n  return buildProblem({\n    spec: CODES.VN2007_NAMESPACE_NOT_IMPORTED,\n    span,\n    title: '\"env\" is not imported in this file — add `use \"venn/env\"`.',\n  });\n}\n\n/** The same checks for text the parser never turned into nodes: `\"${env.X}\"`. */\nexport function envProblemsIn(source: string, span: Span, ctx: CheckContext): Problem[] {\n  const names = [...source.matchAll(ENV_READ)].map((match) => match[1] ?? \"\").filter(Boolean);\n  if (names.length === 0) return [];\n  if (!ctx.imported.has(\"env\")) return [notImported(span)];\n  const env = ctx.env;\n  if (!env) return [];\n  return names.filter((name) => !declared(name, env)).map((name) => envProblem(name, span, ctx));\n}\n\nfunction declared(name: string, env: ReadonlySet<string>): boolean {\n  return env.has(name) || BUILT_IN.has(name);\n}\n\n/** The undeclared-variable problem, with the nearest declared name as a hint. */\nexport function envProblem(name: string, span: Span, ctx: CheckContext): Problem {\n  const hint = nearest(name, [...(ctx.env ?? [])]);\n  const title = hint\n    ? `\"env.${name}\" is not declared in venn.toml — did you mean \"env.${hint}\"?`\n    : `\"env.${name}\" is not declared in venn.toml.`;\n  return buildProblem({ spec: CODES.VN2006_UNKNOWN_ENV, span, title });\n}\n\nfunction nearest(name: string, known: readonly string[]): string | undefined {\n  const best = known\n    .map((candidate) => ({ candidate, distance: distance(name, candidate) }))\n    .sort((left, right) => left.distance - right.distance)[0];\n  const tolerance = Math.max(2, Math.floor(name.length / 3));\n  return best && best.distance <= tolerance ? best.candidate : undefined;\n}\n\n/** Levenshtein edit distance, kept to two rows because only the score is needed. */\nfunction distance(left: string, right: string): number {\n  let previous = Array.from({ length: right.length + 1 }, (_value, index) => index);\n  for (let i = 1; i <= left.length; i += 1) {\n    const current = [i];\n    for (let j = 1; j <= right.length; j += 1) {\n      const cost = left[i - 1] === right[j - 1] ? 0 : 1;\n      current[j] = Math.min(\n        (current[j - 1] ?? 0) + 1,\n        (previous[j] ?? 0) + 1,\n        (previous[j - 1] ?? 0) + cost,\n      );\n    }\n    previous = current;\n  }\n  return previous[right.length] ?? 0;\n}\n","import { buildProblem, type Call, CODES, isRef, type Problem } from \"@venn-lang/core\";\nimport { nodeSpan } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\n\n/**\n * Refuse a fragment called as though it were a function.\n *\n * The two look alike where they are written but are different kinds of thing: a\n * `fn` gives back a value, a `fragment` gives back steps, and steps are recorded\n * in the report, can fail and belong to a flow. So a fragment is invoked with\n * `run`. `run entrar(…)` never reaches here: its target is a name, not an\n * expression.\n *\n * @param call The call expression to inspect.\n * @param ctx The document's resolved check context.\n * @returns A `VN3013` problem, or `undefined` when the callee is not a fragment.\n */\nexport function checkFragmentCall(call: Call, ctx: CheckContext): Problem | undefined {\n  const callee = call.callee;\n  if (!isRef(callee) || !ctx.fragments.has(callee.name)) return undefined;\n  return buildProblem({\n    spec: CODES.VN3013_NOT_CALLABLE,\n    span: nodeSpan(call, ctx.uri),\n    title: `${callee.name} is a fragment, so it cannot be called for a value.`,\n    note: `Invoke it with \\`run ${callee.name}(…)\\`, which records its steps in the report.`,\n  });\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  type InterpolationSlot,\n  isStringLit,\n  type Problem,\n  parseExpression,\n  type Span,\n  scanInterpolations,\n} from \"@venn-lang/core\";\nimport type { CheckContext } from \"./check.types.js\";\nimport { envProblemsIn } from \"./check-env.js\";\n\n/**\n * Check each `${…}` placeholder in a string literal and point at the placeholder\n * itself, not at the whole string. A slot that does not parse would otherwise\n * evaluate to an empty string, so a typo inside a URL fails as a puzzling 404.\n */\nexport function checkInterpolation(node: AstNode, ctx: CheckContext): Problem[] {\n  const cst = node.$cstNode;\n  if (!isStringLit(node) || !cst) return [];\n  return scanInterpolations(cst.text).flatMap((slot) =>\n    inSlot(slot, spanOf(slot, { cst, uri: ctx.uri }), ctx),\n  );\n}\n\n/** A URL is where `env` reads live, so they are checked here as well as in the AST. */\nfunction inSlot(slot: InterpolationSlot, span: Span, ctx: CheckContext): Problem[] {\n  if (!parseExpression(slot.source)) return [unreadable(slot, span)];\n  return envProblemsIn(slot.source, span, ctx);\n}\n\nfunction unreadable(slot: InterpolationSlot, span: Span): Problem {\n  return buildProblem({\n    spec: CODES.VN1002_PARSE,\n    span,\n    title: `Cannot read \\`\\${${slot.source}}\\` — that is not an expression.`,\n  });\n}\n\n/** The span of the placeholder itself: line and column follow the string's own start. */\nfunction spanOf(\n  slot: InterpolationSlot,\n  target: {\n    cst: { offset: number; range?: { start: { line: number; character: number } } };\n    uri: string;\n  },\n): Span {\n  const start = target.cst.range?.start;\n  return {\n    uri: target.uri,\n    offset: target.cst.offset + slot.start,\n    length: slot.end - slot.start,\n    line: (start?.line ?? 0) + 1,\n    column: (start?.character ?? 0) + 1 + slot.start,\n  };\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  isCall,\n  isLetStmt,\n  isMember,\n  type Member,\n  type Problem,\n} from \"@venn-lang/core\";\nimport { actionTarget, nodeSpan, resolveTarget } from \"../scheduler/index.js\";\nimport type { CheckContext } from \"./check.types.js\";\n\n/**\n * A plugin verb named but never called.\n *\n * `let id = data.faker.uuid` runs the verb, because the runtime recognises a\n * bare path that names an action. The same words inside an expression evaluate\n * to the verb itself, so a program meaning to read a value gets a function.\n * Rather than guess which was meant, this asks for the parentheses.\n */\nexport function checkUncalledAction(node: AstNode, ctx: CheckContext): Problem | undefined {\n  if (!isMember(node) || !readsAsValue(node)) return undefined;\n  const target = actionTarget(node);\n  if (target === undefined) return undefined;\n  if (!ctx.registry.action(resolveTarget(target, ctx.aliases))) return undefined;\n  return buildProblem({\n    spec: CODES.VN2008_UNCALLED_ACTION,\n    span: nodeSpan(node, ctx.uri),\n    title: `\\`${target}\\` is a verb, not a value — write \\`${target}()\\` to call it.`,\n  });\n}\n\n/**\n * Where naming the verb produces the verb. Skipped when it is the head of a\n * longer path or the thing being called, and when it stands as a statement's\n * value, which the runtime calls anyway.\n */\nfunction readsAsValue(node: Member): boolean {\n  const parent = node.$container;\n  return !isMember(parent) && !isCall(parent) && !isLetStmt(parent);\n}\n","import {\n  type AstNode,\n  buildProblem,\n  CODES,\n  isActionCall,\n  isCall,\n  isCaptureStmt,\n  isLetStmt,\n  isMatcherClause,\n  isRunStmt,\n  type MatcherClause,\n  type Problem,\n  type RunStmt,\n  walkAst,\n} from \"@venn-lang/core\";\nimport {\n  collectAliases,\n  collectBoundNames,\n  collectNamespaces,\n  nodeSpan,\n} from \"../scheduler/index.js\";\nimport type { CheckArgs, CheckContext } from \"./check.types.js\";\nimport { checkAction, checkCapture, checkLet } from \"./check-calls.js\";\nimport { checkInsideDeco } from \"./check-deco-body.js\";\nimport { checkEnv } from \"./check-env.js\";\nimport { checkFragmentCall } from \"./check-fragment-call.js\";\nimport { checkInterpolation } from \"./check-interpolation.js\";\nimport { checkUncalledAction } from \"./check-uncalled.js\";\n\n/**\n * Statically resolve every action, matcher and fragment reference in a parsed\n * document. The errors the runner would otherwise raise mid-run are surfaced all\n * at once, each with its source span.\n *\n * @param args Document, registry, known fragments and the declared `env` names.\n * @returns One `Problem` per unresolved reference; empty when the document is clean.\n */\nexport function checkDocument(args: CheckArgs): Problem[] {\n  const ctx: CheckContext = {\n    registry: args.registry,\n    fragments: args.fragments,\n    aliases: collectAliases(args.document, args.registry),\n    imported: collectNamespaces(args.document, args.registry),\n    bound: collectBoundNames(args.document),\n    env: args.env ? new Set(args.env) : undefined,\n    uri: args.uri ?? \"memory://inline.vn\",\n  };\n  const problems: Problem[] = [];\n  for (const node of walkAst(args.document)) {\n    const inDeco = checkInsideDeco(node, ctx);\n    if (inDeco) problems.push(...inDeco);\n    else problems.push(...everyCheck(node, ctx));\n  }\n  return problems;\n}\n\nfunction everyCheck(node: AstNode, ctx: CheckContext): Problem[] {\n  return [\n    ...checkNode(node, ctx),\n    ...checkEnv(node, ctx),\n    ...checkInterpolation(node, ctx),\n    ...one(checkUncalledAction(node, ctx)),\n  ];\n}\n\nfunction checkNode(node: AstNode, ctx: CheckContext): Problem[] {\n  if (isActionCall(node)) return checkAction(node, ctx);\n  if (isLetStmt(node)) return checkLet(node, ctx);\n  if (isCaptureStmt(node)) return [checkCapture(node, ctx)];\n  if (isMatcherClause(node)) return one(checkMatcher(node, ctx));\n  if (isRunStmt(node)) return one(checkFragment(node, ctx));\n  if (isCall(node)) return one(checkFragmentCall(node, ctx));\n  return [];\n}\n\nfunction one(problem: Problem | undefined): Problem[] {\n  return problem ? [problem] : [];\n}\n\n/**\n * A matcher comes from a plugin like any action, so the file has to bring that\n * plugin in. Resolving against the whole loaded stdlib would make `use` decorative.\n */\nfunction checkMatcher(clause: MatcherClause, ctx: CheckContext): Problem | undefined {\n  const owner = ctx.registry.matcher(clause.name);\n  if (!owner) {\n    return problem(clause, ctx, CODES.VN2004_UNKNOWN_MATCHER, `Unknown matcher \"${clause.name}\".`);\n  }\n  if (ctx.imported.has(owner.plugin.namespace)) return undefined;\n  const title = `\"${clause.name}\" comes from \"${owner.plugin.namespace}\", which is not imported in this file.`;\n  return problem(clause, ctx, CODES.VN2007_NAMESPACE_NOT_IMPORTED, title);\n}\n\nfunction checkFragment(stmt: RunStmt, ctx: CheckContext): Problem | undefined {\n  if (ctx.fragments.has(stmt.target)) return undefined;\n  return problem(stmt, ctx, CODES.VN2005_UNKNOWN_FRAGMENT, `Unknown fragment \"${stmt.target}\".`);\n}\n\nfunction problem(\n  node: AstNode,\n  ctx: CheckContext,\n  spec: (typeof CODES)[keyof typeof CODES],\n  title: string,\n): Problem {\n  return buildProblem({ spec, span: nodeSpan(node, ctx.uri), title });\n}\n","import {\n  buildProblem,\n  CODES,\n  type Document,\n  isDecoDecl,\n  isFnDecl,\n  isFragmentDecl,\n  isValueImport,\n  type Problem,\n  type ValueImport,\n} from \"@venn-lang/core\";\nimport type { ImportGraph } from \"../scheduler/index.js\";\nimport { nodeSpan } from \"../scheduler/index.js\";\n\n/**\n * Check every name a file imports against what the file it names publishes.\n * Otherwise a misspelt import stays quietly `undefined` until something calls\n * it, and the run blames the call site rather than the import.\n *\n * @param args The importing document, its URI, and the resolved import graph.\n * @returns One `VN2009` problem per name the target does not publish.\n */\nexport function checkImports(args: {\n  document: Document;\n  uri: string;\n  graph: ImportGraph;\n}): Problem[] {\n  const problems: Problem[] = [];\n  for (const decl of args.document.imports) {\n    if (!isValueImport(decl)) continue;\n    const target = args.graph.resolve(args.uri, decl.path);\n    const module = args.graph.modules.get(target);\n    // A path that reads nothing is already reported by whoever tried to read it.\n    if (module) problems.push(...missing({ decl, module, uri: args.uri, path: decl.path }));\n  }\n  return problems;\n}\n\nfunction missing(args: {\n  decl: ValueImport;\n  module: Document;\n  uri: string;\n  path: string;\n}): Problem[] {\n  const published = exported(args.module);\n  return args.decl.names\n    .filter((name) => !published.has(name))\n    .map((name) =>\n      buildProblem({\n        spec: CODES.VN2009_NOT_EXPORTED,\n        span: nodeSpan(args.decl, args.uri),\n        title: `\"${args.path}\" does not publish ${name}.`,\n        note: hint(name, args.module),\n      }),\n    );\n}\n\n/**\n * Why it is not there: written but kept private, or not written at all. The two\n * are different mistakes with different fixes, and a reader told only \"not\n * published\" goes looking for a typo they did not make.\n */\nfunction hint(name: string, module: Document): string {\n  const declared = module.decls.some(\n    (decl) =>\n      (isFnDecl(decl) || isFragmentDecl(decl) || isDecoDecl(decl)) &&\n      (decl as { name?: string }).name === name,\n  );\n  return declared\n    ? `It is declared there, but not marked \\`pub\\`.`\n    : `Nothing of that name is declared there.`;\n}\n\n/** Everything a file marked `pub`: functions, fragments and decorators alike. */\nfunction exported(document: Document): Set<string> {\n  const names = new Set<string>();\n  for (const decl of document.decls) {\n    if (!isFnDecl(decl) && !isFragmentDecl(decl) && !isDecoDecl(decl)) continue;\n    if (decl.export) names.add(decl.name);\n  }\n  return names;\n}\n","import type { DecoratorDefinition, ExpandContext } from \"@venn-lang/core\";\nimport type { RetrySpec } from \"../scheduler/annotations.js\";\n\n/** Where each of these may sit. Named once, so a wrong target is caught, not ignored. */\nconst RUNNABLE = [\"FlowDecl\", \"StepDecl\", \"GroupDecl\"] as const;\n\n/**\n * The decorators the language ships with, written the same way anyone else's\n * are. They go through the same expansion as a plugin decorator and leave\n * metadata on the node, because `@retry(2)` says something the grammar has no\n * other word for. Keeping them here rather than as special cases in the\n * scheduler is what makes the built-ins a stdlib instead of reserved words.\n */\nexport const builtinDecorators: readonly DecoratorDefinition[] = [\n  flag(\"skip\", \"Do not run this.\"),\n  flag(\"only\", \"Run this and nothing beside it.\"),\n  flag(\"serial\", \"Never run this alongside another flow.\"),\n  {\n    name: \"tags\",\n    doc: \"Label this for `--tags`.\",\n    targets: [...RUNNABLE],\n    expand: (ctx) =>\n      ctx.meta(\n        \"tags\",\n        ctx.args.map(String).filter((tag) => tag !== \"\"),\n      ),\n  },\n  {\n    name: \"timeout\",\n    doc: \"Give up after this long.\",\n    targets: [...RUNNABLE],\n    expand: (ctx) => ctx.meta(\"timeout\", durationMs(ctx.args[0])),\n  },\n  {\n    name: \"retry\",\n    doc: \"Run again on failure, up to n times.\",\n    targets: [...RUNNABLE],\n    expand: (ctx) => ctx.meta(\"retry\", retryOf(ctx)),\n  },\n  {\n    name: \"lock\",\n    doc: \"Hold this name for the duration; nothing else holding it runs.\",\n    targets: [...RUNNABLE],\n    expand: (ctx) => ctx.meta(\"lock\", ctx.args[0] === undefined ? undefined : String(ctx.args[0])),\n  },\n  {\n    name: \"flaky\",\n    doc: \"Tolerate failures up to this ratio.\",\n    targets: [...RUNNABLE],\n    expand: (ctx) => ctx.meta(\"flaky\", ratioOf(ctx.args[0])),\n  },\n];\n\n/** A decorator with nothing to say beyond having been written. */\nfunction flag(name: string, doc: string): DecoratorDefinition {\n  return {\n    name,\n    doc,\n    targets: [...RUNNABLE],\n    expand: (ctx) => ctx.meta(name, true),\n  };\n}\n\nfunction retryOf(ctx: ExpandContext): RetrySpec {\n  const opts = asRecord(ctx.args[1]);\n  return {\n    attempts: Math.max(0, Math.floor(Number(ctx.args[0]) || 0)),\n    backoffMs: durationMs(opts.backoff) ?? 0,\n    factor: Number(opts.factor ?? 1) || 1,\n  };\n}\n\n/** A bare `@flaky` tolerates everything; a number is the ratio it tolerates. */\nfunction ratioOf(value: unknown): number {\n  if (value === undefined) return 1;\n  return typeof value === \"number\" ? value : 0;\n}\n\nfunction durationMs(value: unknown): number | undefined {\n  if (typeof value === \"number\") return value;\n  const duration = value as { kind?: string; ms?: number };\n  return duration?.kind === \"duration\" ? duration.ms : undefined;\n}\n\nfunction asRecord(value: unknown): Record<string, unknown> {\n  return typeof value === \"object\" && value !== null ? (value as Record<string, unknown>) : {};\n}\n","import type { DecoratorDefinition, DecoratorSource } from \"@venn-lang/core\";\nimport type { PluginDefinition } from \"@venn-lang/sdk\";\nimport { builtinDecorators } from \"./builtin-decorators.js\";\n\n/**\n * Every decorator this run understands: the ones the language ships with, plus\n * whatever the loaded plugins contribute.\n *\n * A plugin's decorator overrides a built-in of the same name on purpose. The\n * built-ins are a stdlib, not a reserved word list, and a project that wants its\n * own `@retry` is entitled to it.\n *\n * @param plugins The plugins loaded for this run, in load order.\n * @returns A source that looks a decorator up by name.\n */\nexport function createDecoratorSource(plugins: readonly PluginDefinition[]): DecoratorSource {\n  const byName = new Map<string, DecoratorDefinition>();\n  for (const decorator of builtinDecorators) byName.set(decorator.name, decorator);\n  for (const plugin of plugins) {\n    for (const decorator of plugin.decorators ?? []) {\n      byName.set(decorator.name, decorator as DecoratorDefinition);\n    }\n  }\n  return { get: (name) => byName.get(name) };\n}\n","import type { Clock } from \"@venn-lang/contracts\";\nimport type { Envelope, RunId } from \"@venn-lang/core\";\nimport type { EventSink } from \"../eventsink/index.js\";\nimport type { Emitter } from \"./emitter.types.js\";\n\n/** Build the sole emitter: it owns `seq` and stamps `ts` from the runner's clock. */\nexport function createEmitter(args: { sink: EventSink; run: RunId; clock: Clock }): Emitter {\n  let seq = 0;\n  return {\n    emit: ({ kind, data, node }) => {\n      seq += 1;\n      const ts = new Date(args.clock.now()).toISOString();\n      args.sink.emit({ seq, ts, run: args.run, kind, node, data } as Envelope);\n    },\n  };\n}\n","import type { Clock, Random } from \"@venn-lang/contracts\";\nimport type { RunId } from \"@venn-lang/core\";\n\n/**\n * Mint a run id from the host clock and random source, so a seeded run is\n * reproducible. Real ULID minting comes later.\n */\nexport function newRunId(args: { clock: Clock; random: Random }): RunId {\n  const rand = Math.floor(args.random.next() * 1e9).toString(36);\n  return `run-${args.clock.now().toString(36)}-${rand}` as RunId;\n}\n","import type { Port } from \"@venn-lang/contracts\";\nimport type { EventSink } from \"./event-sink.types.js\";\n\n/**\n * The port every run event is written to. Bound at startup by whoever assembles\n * the host: the CLI binds NDJSON on stdout, tests bind the memory double.\n */\nexport const EventSinkPort: Port<EventSink> = {\n  id: \"venn.port.event-sink\",\n  version: 1,\n  requires: [],\n  methods: [\"emit\"],\n};\n","import type { Envelope } from \"@venn-lang/core\";\nimport type { MemorySink } from \"./event-sink.types.js\";\n\n/**\n * In-memory sink (the test double): keeps every envelope for assertions.\n *\n * @returns A sink whose `envelopes` array grows in emission order.\n */\nexport function createMemorySink(): MemorySink {\n  const envelopes: Envelope[] = [];\n  return {\n    envelopes,\n    emit: (envelope) => {\n      envelopes.push(envelope);\n    },\n  };\n}\n","import type { EventSink } from \"./event-sink.types.js\";\n\n/**\n * NDJSON sink: one JSON envelope per line. The `write` sink is injected (the CLI\n * passes stdout) so this file stays neutral and needs no `node:*`.\n *\n * @param args.write Receives each line, newline included.\n * @returns A sink that serialises every envelope it is given.\n */\nexport function createNdjsonSink(args: { write: (line: string) => void }): EventSink {\n  return {\n    emit: (envelope) => args.write(`${JSON.stringify(envelope)}\\n`),\n  };\n}\n","import { bindPort, type HostCapability, type Port, VennError } from \"@venn-lang/contracts\";\nimport type { PortBinding, PortResolver } from \"./port-resolver.types.js\";\n\n/**\n * Resolve ports from a set of bindings, running capability and shape negotiation\n * at the moment of resolution.\n *\n * @param args.bindings Every port the host chose to bind, with its implementation.\n * @param args.caps What this host offers, checked against each port's `requires`.\n * @returns A resolver whose `resolve` throws `VN7002` when the port is unbound,\n * and whatever `bindPort` raises when the capability or shape check fails.\n */\nexport function createPortResolver(args: {\n  bindings: readonly PortBinding[];\n  caps: readonly HostCapability[];\n}): PortResolver {\n  const byId = new Map(args.bindings.map((binding) => [binding.port.id, binding] as const));\n  return {\n    resolve: <T>(port: Port<T>): T =>\n      resolveOne({ port, binding: byId.get(port.id), caps: args.caps }),\n  };\n}\n\nfunction resolveOne<T>(args: {\n  port: Port<T>;\n  binding: PortBinding | undefined;\n  caps: readonly HostCapability[];\n}): T {\n  if (!args.binding) throw unbound(args.port.id);\n  return bindPort({ port: args.port, impl: args.binding.impl, caps: args.caps });\n}\n\nfunction unbound(id: string): VennError {\n  return new VennError({\n    code: \"VN7002\",\n    message: `No implementation bound for port \"${id}\".`,\n    detail: { port: id },\n  });\n}\n","import { type HostCapability, missingCapabilities, VennError } from \"@venn-lang/contracts\";\nimport type { ActionDefinition, PluginDefinition } from \"@venn-lang/sdk\";\nimport type { Registry, ResolvedAction, ResolvedMatcher } from \"./registry.types.js\";\n\n/**\n * Ingest plugins after negotiating each plugin's capabilities against the host.\n *\n * @param args.plugins The plugins to index, in load order; later ones win a clash.\n * @param args.caps The capabilities this host offers.\n * @returns A registry resolving actions, matchers and namespaces.\n * @throws VennError `VN2010` when a plugin requires a capability the host lacks.\n */\nexport function buildRegistry(args: {\n  plugins: readonly PluginDefinition[];\n  caps: readonly HostCapability[];\n}): Registry {\n  for (const plugin of args.plugins) assertPluginCaps({ plugin, caps: args.caps });\n  return indexPlugins(args.plugins);\n}\n\nfunction assertPluginCaps(args: {\n  plugin: PluginDefinition;\n  caps: readonly HostCapability[];\n}): void {\n  const missing = missingCapabilities({ requires: args.plugin.requires ?? [], caps: args.caps });\n  if (missing.length === 0) return;\n  const list = missing.map((cap) => `\"${cap}\"`).join(\", \");\n  throw new VennError({\n    code: \"VN2010\",\n    message: `Plugin \"${args.plugin.name}\" requires capability ${list}, absent from this host.`,\n    detail: { plugin: args.plugin.name, missing },\n  });\n}\n\nfunction indexPlugins(plugins: readonly PluginDefinition[]): Registry {\n  const actions = new Map<string, ResolvedAction>();\n  const matchers = new Map<string, ResolvedMatcher>();\n  const namespaces = new Set<string>();\n  const packages = new Map<string, string>();\n  for (const plugin of plugins) addPlugin({ plugin, actions, matchers, namespaces, packages });\n  return {\n    action: ({ namespace, name }) => actions.get(`${namespace}.${name}`),\n    matcher: (name) => matchers.get(name),\n    hasNamespace: (namespace) => namespaces.has(namespace),\n    namespaceOf: (pkg) => packages.get(pkg),\n    actions: () => listActions(actions),\n  };\n}\n\nfunction listActions(\n  actions: Map<string, ResolvedAction>,\n): { namespace: string; name: string; action: ActionDefinition }[] {\n  return [...actions].map(([key, resolved]) => ({\n    namespace: key.slice(0, key.indexOf(\".\")),\n    name: key.slice(key.indexOf(\".\") + 1),\n    action: resolved.action,\n  }));\n}\n\nfunction addPlugin(args: {\n  plugin: PluginDefinition;\n  actions: Map<string, ResolvedAction>;\n  matchers: Map<string, ResolvedMatcher>;\n  namespaces: Set<string>;\n  packages: Map<string, string>;\n}): void {\n  const { plugin, actions, matchers, namespaces, packages } = args;\n  namespaces.add(plugin.namespace);\n  packages.set(plugin.name, plugin.namespace);\n  for (const action of plugin.actions ?? []) {\n    actions.set(`${plugin.namespace}.${action.name}`, { plugin, action });\n  }\n  for (const matcher of plugin.matchers ?? []) {\n    matchers.set(matcher.name, { plugin, matcher });\n  }\n}\n","import type { Host, Port } from \"@venn-lang/contracts\";\nimport { invoke } from \"@venn-lang/core\";\nimport type { ActionContext } from \"@venn-lang/sdk\";\nimport type { PortResolver } from \"../ports/index.js\";\n\n/** Build the context an action's `run` receives from the host and port resolver. */\nexport function createActionContext(args: {\n  host: Host;\n  ports: PortResolver;\n  config?: Record<string, unknown>;\n}): ActionContext {\n  return {\n    port: <T>(port: Port<T>): T => args.ports.resolve(port),\n    secrets: args.host.secrets,\n    config: args.config ?? {},\n    log: (message) => args.host.log.log({ level: \"info\", message }),\n    redact: () => {},\n    invoke: (fn, values) => invoke(fn, values),\n  };\n}\n","import {\n  type Document,\n  expand,\n  type FragmentDecl,\n  type Problem,\n  type RunId,\n} from \"@venn-lang/core\";\nimport { createActionContext } from \"../context/index.js\";\nimport { createDecoratorSource } from \"../decorators/index.js\";\nimport { createEmitter, newRunId } from \"../emit/index.js\";\nimport { createPortResolver } from \"../ports/index.js\";\nimport { buildRegistry } from \"../registry/index.js\";\nimport {\n  absorbExit,\n  collectAliases,\n  collectConfig,\n  collectFragments,\n  createCleanupList,\n  type Engine,\n  runDocument,\n  runScript,\n} from \"../scheduler/index.js\";\nimport type { Runner, RunnerArgs, RunOnceInput, RunResult } from \"./runner.types.js\";\n\n/**\n * Build a runner: negotiate plugins and wire ports once, then reuse them for\n * every run.\n *\n * @param args The host, the plugins, the event sink and the per-run options.\n * @returns A runner exposing test mode (`run`) and script mode (`script`).\n * @throws VennError `VN2010` when a plugin requires a capability the host lacks.\n */\nexport function createRunner(args: RunnerArgs): Runner {\n  const registry = buildRegistry({ plugins: args.plugins, caps: args.host.caps });\n  const resolver = createPortResolver({ bindings: args.ports ?? [], caps: args.host.caps });\n  const decorators = createDecoratorSource(args.plugins);\n  const drive = (walk: Walk) => (document: Document) => {\n    // Decorators run first, on every path: what the scheduler walks is the tree\n    // they left, not the one the parser produced.\n    const expansion = expand({ document, decorators, uri: args.uri, imported: args.moduleDecos });\n    return runOnce({ args, registry, resolver, document }, walk, expansion.problems);\n  };\n  return { run: drive(runDocument), script: drive(runScript) };\n}\n\ntype Walk = (engine: Engine, document: Document) => Promise<void>;\n\nasync function runOnce(input: RunOnceInput, walk: Walk, problems: Problem[]): Promise<RunResult> {\n  const run = newRunId({ clock: input.args.host.clock, random: input.args.host.random });\n  const engine = buildEngine(input, run);\n  // The walk absorbs an `exit` of its own so the run still ends tidily; this is\n  // the backstop for one thrown where no walk was left to absorb it.\n  await absorbExit(engine, () => walk(engine, input.document));\n  return {\n    run,\n    problems,\n    passed: engine.result.passed,\n    failed: engine.result.failed,\n    exitCode: engine.exit,\n  };\n}\n\nfunction buildEngine(input: RunOnceInput, run: RunId): Engine {\n  const { args, registry } = input;\n  return {\n    registry,\n    emitter: createEmitter({ sink: args.sink, run, clock: args.host.clock }),\n    clock: args.host.clock,\n    lock: args.host.lock,\n    uri: args.uri ?? \"memory://inline.vn\",\n    result: { passed: 0, failed: 0 },\n    flaky: new Map(),\n    filter: args.filter ?? {},\n    bail: args.bail,\n    cleanup: args.cleanup ?? createCleanupList(),\n    ...documentParts(input),\n  };\n}\n\n/** Everything derived from the document being run: config, fragments, aliases. */\nfunction documentParts(input: RunOnceInput) {\n  const { args, registry, resolver, document } = input;\n  const env = args.env ?? {};\n  const config = collectConfig(document, env);\n  return {\n    ctx: createActionContext({ host: args.host, ports: resolver, config }),\n    fragments: mergeFragments(collectFragments(document), args.moduleFragments),\n    imports: args.modules,\n    aliases: collectAliases(document, registry),\n    env,\n  };\n}\n\n/** Local fragments take precedence over imported ones of the same name. */\nfunction mergeFragments(\n  local: Map<string, FragmentDecl>,\n  imported: Map<string, FragmentDecl> | undefined,\n): Map<string, FragmentDecl> {\n  if (!imported) return local;\n  const merged = new Map(imported);\n  for (const [name, fragment] of local) merged.set(name, fragment);\n  return merged;\n}\n","import {\n  type Document,\n  type FragmentDecl,\n  type ImportedDeco,\n  isDecoDecl,\n  isFragmentDecl,\n  isPackageSpecifier,\n  isUseDecl,\n  isValueImport,\n  parse,\n} from \"@venn-lang/core\";\n\n/** Read source by URI and resolve a specifier relative to a base URI. */\nexport interface ModuleIo {\n  read: (uri: string) => Promise<string>;\n  resolve: (base: string, spec: string) => string;\n}\n\n/**\n * Loading a package that was installed rather than written here.\n *\n * Kept apart from {@link ModuleIo} because the two answer different questions:\n * one reads `.vn` source to be parsed, the other hands back a module that is\n * already a value. A host without one simply has no packages, which is the state\n * of every run in a Web Worker and not an error.\n */\nexport interface NpmModules {\n  load(spec: string): Promise<Record<string, unknown> | undefined>;\n}\n\n/** What a run needs from the files it reaches: their fragments, decos and plugins. */\nexport interface ResolvedImports {\n  fragments: Map<string, FragmentDecl>;\n  /** The `pub deco`s reachable through the import graph, with the file each came from. */\n  decos: Map<string, ImportedDeco>;\n  /** Every package `use`d anywhere in the graph, so only those need loading. */\n  packages: Set<string>;\n  /**\n   * What each npm specifier loaded to, by the name that was written.\n   *\n   * Loaded here, before anything runs, because binding a scope cannot wait: by\n   * the time a name is looked up the module has to already be a value.\n   */\n  npm: Map<string, Record<string, unknown>>;\n  /**\n   * Every module reached, parsed, keyed by its resolved URI.\n   *\n   * Carried whole rather than reduced to a list of exported names, because a\n   * `pub fn` is a closure over the file it was written in: it calls that file's\n   * private helpers and reads that file's globals. Handing over the function\n   * without the place it came from produces something that resolves and then\n   * fails on its first line.\n   */\n  modules: Map<string, Document>;\n}\n\n/**\n * Walk the import graph from one document, parsing every `.vn` file it reaches\n * and loading every package it names. A file already seen is skipped, so a cycle\n * ends rather than loops. A file that cannot be read is skipped in silence:\n * whoever tried to read it reports the failure.\n *\n * @param args The entry document, its URI, the source reader and the optional\n * package loader.\n * @returns The exported fragments and decos, the packages, the loaded npm\n * modules and every parsed document, keyed by resolved URI.\n */\nexport async function resolveImports(args: {\n  document: Document;\n  uri: string;\n  io: ModuleIo;\n  /** Absent when the host has no way to load one: a Worker, most tests. */\n  npm?: NpmModules;\n}): Promise<ResolvedImports> {\n  const found: Exports = { fragments: new Map(), decos: new Map() };\n  const packages = new Set<string>();\n  const modules = new Map<string, Document>();\n  const npm = new Map<string, Record<string, unknown>>();\n  collectUses(args.document, packages);\n  await loadInto({\n    document: args.document,\n    uri: args.uri,\n    io: args.io,\n    npmLoader: args.npm,\n    found,\n    packages,\n    modules,\n    npm,\n    seen: new Set([args.uri]),\n  });\n  return { ...found, packages, modules, npm };\n}\n\n/**\n * Add the packages a file declares with `use` to `into`. Collected across the\n * whole graph: a fragment imported from elsewhere calls the verbs *its* file\n * asked for.\n *\n * @param document The file to read `use` declarations from.\n * @param into The accumulating set of package specifiers, mutated in place.\n */\nexport function collectUses(document: Document, into: Set<string>): void {\n  for (const decl of document.imports) {\n    if (isUseDecl(decl)) into.add(decl.pkg);\n  }\n}\n\n/** What `pub` has handed over so far, filled as the graph is walked. */\ninterface Exports {\n  fragments: Map<string, FragmentDecl>;\n  decos: Map<string, ImportedDeco>;\n}\n\ninterface LoadState {\n  document: Document;\n  uri: string;\n  io: ModuleIo;\n  npmLoader?: NpmModules;\n  found: Exports;\n  packages: Set<string>;\n  modules: Map<string, Document>;\n  npm: Map<string, Record<string, unknown>>;\n  seen: Set<string>;\n}\n\nasync function loadInto(state: LoadState): Promise<void> {\n  for (const decl of state.document.imports) {\n    if (!isValueImport(decl)) continue;\n    if (isPackageSpecifier(decl.path)) await loadPackage(state, decl.path);\n    else await loadModule(state, decl.path);\n  }\n}\n\n/**\n * A package that was installed, loaded once however many files name it.\n *\n * A host with no loader has no packages, which is the state of every run in a\n * Web Worker. The import is left unbound and the name reports itself as unknown,\n * rather than the load failing somewhere nobody can see.\n */\nasync function loadPackage(state: LoadState, spec: string): Promise<void> {\n  if (state.npm.has(spec) || !state.npmLoader) return;\n  const found = await state.npmLoader.load(spec).catch(() => undefined);\n  if (found) state.npm.set(spec, found);\n}\n\nasync function loadModule(state: LoadState, spec: string): Promise<void> {\n  const target = state.io.resolve(state.uri, spec);\n  if (state.seen.has(target)) return;\n  state.seen.add(target);\n  const source = await state.io.read(target).catch(() => undefined);\n  if (source === undefined) return;\n  const { ast } = parse(source, { uri: target });\n  state.modules.set(target, ast);\n  collectExports({ document: ast, uri: target, found: state.found });\n  collectUses(ast, state.packages);\n  await loadInto({ ...state, document: ast, uri: target });\n}\n\n/** Everything a file marked `pub`. A `deco` keeps its file: its faults are its own. */\nfunction collectExports(args: { document: Document; uri: string; found: Exports }): void {\n  for (const decl of args.document.decls) {\n    if (isFragmentDecl(decl) && decl.export) args.found.fragments.set(decl.name, decl);\n    if (isDecoDecl(decl) && decl.export) args.found.decos.set(decl.name, { decl, uri: args.uri });\n  }\n}\n","import { type FnType, prune, specToType, type Type, type TypeCatalog } from \"@venn-lang/core\";\nimport type { PluginDefinition } from \"@venn-lang/sdk\";\nimport type { TypeSpec } from \"@venn-lang/types\";\n\n/** The published specs, indexed by the name a flow would write. */\ninterface Published {\n  types: Map<string, TypeSpec>;\n  signatures: Map<string, TypeSpec>;\n}\n\n/**\n * Turn what the loaded plugins publish into what the checker can ask.\n *\n * This is the seam the core deliberately does not cross: `@venn-lang/core` knows\n * nothing about plugins and gets told. Names are qualified here, once: a plugin\n * says `Request` and a flow writes `http.Request`.\n *\n * @param plugins The plugins loaded for this run.\n * @returns A catalog answering a type name or an action's signature.\n */\nexport function createTypeCatalog(plugins: readonly PluginDefinition[]): TypeCatalog {\n  const published: Published = { types: new Map(), signatures: new Map() };\n  for (const plugin of plugins) collect(plugin, published);\n  const reader = createReader(published);\n  return {\n    typeOf: (name) => reader.read(published.types, name),\n    signatureOf: (target) => asFn(reader.read(published.signatures, target)),\n  };\n}\n\nfunction collect(plugin: PluginDefinition, into: Published): void {\n  for (const [name, spec] of Object.entries(plugin.typeDefs ?? {})) {\n    into.types.set(`${plugin.namespace}.${name}`, spec);\n  }\n  for (const action of plugin.actions ?? []) {\n    const key = `${plugin.namespace}.${action.name}`;\n    if (action.signature) into.signatures.set(key, action.signature);\n  }\n}\n\n/**\n * Read a published spec once and keep the result.\n *\n * The same `http.Request` has to be the same object every time it is asked for:\n * inference writes into what it is handed, and two copies would drift apart in\n * the middle of a file. `open` guards a type that refers to itself, so the\n * second visit answers \"unknown\" rather than recurring forever.\n */\nfunction createReader(published: Published) {\n  const cache = new Map<string, Type>();\n  const open = new Set<string>();\n  const read = (from: Map<string, TypeSpec>, name: string): Type | undefined => {\n    const cached = cache.get(name);\n    if (cached) return cached;\n    const spec = from.get(name);\n    if (!spec || open.has(name)) return undefined;\n    open.add(name);\n    const type = specToType(spec, (ref) => read(published.types, ref));\n    open.delete(name);\n    cache.set(name, type);\n    return type;\n  };\n  return { read };\n}\n\nfunction asFn(type: Type | undefined): FnType | undefined {\n  if (!type) return undefined;\n  const pruned = prune(type);\n  return pruned.kind === \"fn\" ? pruned : undefined;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@venn-lang/runtime",
+  "version": "0.1.0",
+  "description": "Executes a parsed Venn document: the scheduler, the plugin registry, the event stream.",
+  "keywords": [
+    "venn",
+    "testing",
+    "e2e",
+    "runtime",
+    "interpreter"
+  ],
+  "homepage": "https://github.com/venn-lang/venn/tree/main/packages/runtime#readme",
+  "bugs": "https://github.com/venn-lang/venn/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venn-lang/venn.git",
+    "directory": "packages/runtime"
+  },
+  "license": "MIT",
+  "author": "Vinicius Borges",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.suite.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@venn-lang/contracts": "0.1.0",
+    "@venn-lang/core": "0.1.0",
+    "@venn-lang/sdk": "0.1.0",
+    "@venn-lang/types": "0.1.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}