spp-lang 0.0.0-stage → 0.1.0

package/dist/src/backends/playwright/runner/playwright.config.js

@@ -0,0 +1,16 @@
+// The config `npx spp-lang test` runs with when the project has no Playwright
+// config of its own: every .spp file under where it was run. Everything it
+// writes goes in that directory, not in here.
+import path from 'node:path';
+import { defineConfig } from '@playwright/test';
+import { defineSppConfig } from '../generate.js';
+const root = process.env.SPP_CWD ?? process.cwd();
+export default defineConfig({
+    ...defineSppConfig({ root }),
+    outputDir: path.join(root, 'test-results'),
+    reporter: [['list'], ['html', { outputFolder: path.join(root, 'playwright-report'), open: 'never' }]],
+    use: {
+        baseURL: process.env.SPP_BASE_URL || undefined,
+        trace: 'retain-on-failure',
+    },
+});

package/dist/src/backends/playwright/runtime.d.ts

@@ -0,0 +1,14 @@
+import { type PlaywrightTestArgs } from '@playwright/test';
+import type { Project } from '../../config.ts';
+import type { Scenario, Vocabulary } from '../../language/load.ts';
+import type { BrowserContext } from './words.ts';
+type Body = (args: PlaywrightTestArgs) => Promise<void>;
+export declare function project(p: Project): {
+    test: import("@playwright/test").TestType<PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+    scenario(file: string, line: number): Body;
+    mistake(file: string, line: number): Body;
+    define(file: string, line: number): Body;
+    broken(file: string): Body;
+};
+export declare function runScenario(scenario: Scenario, vocabulary: Vocabulary[], ctx: BrowserContext): Promise<void>;
+export {};

package/dist/src/backends/playwright/runtime.js

@@ -0,0 +1,158 @@
+// What the generated tests run (see generate.ts). Each generated file declares
+// its scenarios as Playwright tests and hands each one a body from here, so a
+// generated file says only which tests there are, and everything they do is
+// read from the .spp files when they run.
+//
+// The project is loaded and checked once per worker, the first time a test
+// needs it. A scenario with a mistake the checker can see fails straight away,
+// without starting a browser, and so does a broken Define, as a test of its own.
+//
+// Each Gherkin step becomes a test.step whose location is the step's line in
+// the .spp or Markdown file, so reports and failures point at the Gherkin, not
+// at Spec++'s own code.
+import { expect, test } from '@playwright/test';
+import { check } from '../../language/check.js';
+import { apply, Block, core, Env, run, SppError, Stack } from '../../language/cognate.js';
+import { discover, LoadError, load } from '../../language/load.js';
+import { keywordForms, keywords, StepBlock } from '../../language/steps.js';
+import { leftovers } from '../../words/shared.js';
+import { browser, settle } from './words.js';
+// Tags that mean something to Playwright itself, applied as the test starts.
+// @only is the generated file's, since it changes which tests are declared.
+const MODIFIERS = {
+    '@skip': () => test.skip(),
+    '@fixme': () => test.fixme(),
+    '@fail': () => test.fail(),
+    '@slow': () => test.slow(),
+};
+const projects = new Map();
+function loadProject(project) {
+    const key = JSON.stringify(project);
+    const cached = projects.get(key);
+    if (cached)
+        return cached;
+    const files = [];
+    const broken = new Map();
+    for (const file of discover(project.features, project.root, project.ignore)) {
+        try {
+            files.push(load(file));
+        }
+        catch (err) {
+            if (!(err instanceof LoadError))
+                throw err;
+            broken.set(file, err);
+        }
+    }
+    const scenarios = new Map();
+    for (const scenario of files.flatMap((f) => f.features).flatMap((f) => f.scenarios))
+        scenarios.set(where(scenario.file, scenario.line), scenario);
+    const loaded = {
+        files,
+        broken,
+        vocabulary: files.flatMap((f) => f.vocabulary),
+        report: check(files, { words: browser(core()), settle: leftovers, cwd: project.root }),
+        scenarios,
+    };
+    projects.set(key, loaded);
+    return loaded;
+}
+const where = (file, line) => `${file}:${line}`;
+// The tests a generated file can declare, for a project. Called as the file
+// loads, so a base URL from the command line applies to its tests.
+export function project(p) {
+    if (process.env.SPP_BASE_URL)
+        test.use({ baseURL: process.env.SPP_BASE_URL });
+    const stale = (what) => new Error(`${what} isn't where the generated tests say. They're out of date: run Playwright again.`);
+    return {
+        test,
+        // The scenario on this line of this file.
+        scenario(file, line) {
+            return async ({ page }) => {
+                const loaded = loadProject(p);
+                const scenario = loaded.scenarios.get(where(file, line));
+                if (!scenario)
+                    throw stale(`The scenario at ${where(file, line)}`);
+                for (const tag of scenario.tags)
+                    MODIFIERS[tag]?.();
+                const problem = loaded.report.scenarios.get(scenario);
+                if (problem)
+                    throw located(problem);
+                await runScenario(scenario, loaded.vocabulary, { page, expect });
+            };
+        },
+        // A scenario the checker found a mistake in, which fails with it, without
+        // asking for a page, so no browser starts.
+        mistake(file, line) {
+            return async () => {
+                const loaded = loadProject(p);
+                const scenario = loaded.scenarios.get(where(file, line));
+                const problem = scenario && loaded.report.scenarios.get(scenario);
+                if (!scenario || !problem)
+                    throw stale(`The mistake in the scenario at ${where(file, line)}`);
+                for (const tag of scenario.tags)
+                    MODIFIERS[tag]?.();
+                throw located(problem);
+            };
+        },
+        // The broken Define on this line, as a test that fails with its mistake.
+        define(file, line) {
+            return async () => {
+                const problem = loadProject(p).report.vocabulary.find((d) => d.file === file && d.line === line);
+                throw problem ? located(problem) : stale(`The broken Define at ${where(file, line)}`);
+            };
+        },
+        // A file that can't be read as Spec++, as a test that fails with why.
+        broken(file) {
+            return async () => {
+                const err = loadProject(p).broken.get(file);
+                if (!err)
+                    throw stale(`The mistake in ${file}`);
+                const [first] = err.problems;
+                const message = err.problems.map((problem) => problem.message).join('\n');
+                throw located({ file, line: first?.line ?? 1, column: first?.column ?? 1, message });
+            };
+        },
+    };
+}
+export async function runScenario(scenario, vocabulary, ctx) {
+    const words = new Env(browser(core()));
+    for (const { program } of vocabulary)
+        await run(program, words, new Stack(), ctx);
+    // The scenario's own stack, where each keyword leaves its mode for the next.
+    const steps = keywords(settle);
+    const modes = new Stack();
+    for (const step of scenario.steps) {
+        const location = { file: step.file, line: step.line, column: step.column };
+        await test.step(`${step.keyword}${step.text}`, async () => {
+            const block = new StepBlock(new Block(step.program ?? [], words), step.argument);
+            try {
+                if (step.error !== undefined)
+                    throw step.error;
+                modes.push(block);
+                await apply(step.keyword.trim(), keywordForms(steps, step.keywordType), modes, ctx);
+            }
+            catch (err) {
+                // A keyword that couldn't take what it needed is its own mistake.
+                if (!block.ran && err instanceof SppError && step.error === undefined)
+                    err.pos = -step.keyword.length;
+                throw pointAt(err, step);
+            }
+        }, { location });
+    }
+}
+// Makes the error's top frame the offending word in the .spp file, which
+// is where Playwright's reporters look for a code frame to show.
+function pointAt(err, step) {
+    if (!(err instanceof Error))
+        return err;
+    const column = step.column + (err.pos ?? 0);
+    const frame = `    at ${step.file}:${step.line}:${column}`;
+    const [head] = (err.stack ?? '').split(/\n\s+at /);
+    err.stack = `${head || `${err.name}: ${err.message}`}\n${frame}`;
+    return err;
+}
+function located(d) {
+    const err = new SppError(d.message);
+    err.stack = `SppError: ${d.message}\n    at ${d.file}:${d.line}:${d.column}`;
+    return err;
+}

package/dist/src/backends/playwright/words.d.ts

@@ -0,0 +1,11 @@
+import type { expect, Locator, Page } from '@playwright/test';
+import { Env } from '../../language/cognate.ts';
+import type { Context } from '../../language/types.ts';
+import type { Driver } from '../../words/driver.ts';
+export interface BrowserContext extends Context {
+    page: Page;
+    expect: typeof expect;
+}
+export declare const playwright: Driver<BrowserContext, Locator>;
+export declare const settle: (stack: import("../../language/cognate.ts").Stack, ctx: BrowserContext) => Promise<void>;
+export declare function browser(parent?: Env | null): Env;

package/dist/src/backends/playwright/words.js

@@ -0,0 +1,129 @@
+// The words that drive a browser: the shared words (words/shared.ts) on a
+// Playwright driver, and the words only a browser has, like Visit.
+//
+// Playwright's getBy* locators implement Testing Library's queries, and its
+// expect retries until a check passes, which is what the shared words ask of
+// a driver.
+import { Env } from '../../language/cognate.js';
+import { called, formsFor, TextType } from '../../language/types.js';
+import { actions, CheckType, checks, Expectation, escapeRegExp, NameType, nameOf, queries, say, settler, } from '../../words/shared.js';
+// Every ARIA role that makes sense to query by name, as a word.
+const ROLES = `alert alertdialog application article banner blockquote button caption cell checkbox
+  code columnheader combobox complementary contentinfo definition deletion dialog directory document
+  emphasis feed figure form generic grid gridcell group heading img insertion link list listbox
+  listitem log main marquee math meter menu menubar menuitem menuitemcheckbox menuitemradio navigation
+  none note option paragraph presentation progressbar radio radiogroup region row rowgroup rowheader
+  scrollbar search searchbox separator slider spinbutton status strong subscript superscript switch
+  tab table tablist tabpanel term textbox time timer toolbar tooltip tree treegrid treeitem`.split(/\s+/);
+// ---------------------------------------------------------------- the driver
+export const playwright = {
+    roles: ROLES,
+    queries: ['label', 'text', 'placeholder', 'alt', 'title', 'testId'],
+    actions: ['click', 'double-click', 'hover', 'focus', 'check', 'uncheck', 'clear', 'fill', 'type', 'select', 'press'],
+    states: ['visible', 'hidden', 'checked', 'enabled', 'disabled', 'focused', 'empty', 'value', 'text', 'containing'],
+    find({ page }, root, query) {
+        const r = root ?? page;
+        const { name } = query;
+        switch (query.by) {
+            case 'role':
+                return r.getByRole(query.role, { name, exact: true });
+            case 'label':
+                return r.getByLabel(name, { exact: true });
+            case 'text':
+                return query.loose ? r.getByText(name).first() : r.getByText(name, { exact: true });
+            case 'placeholder':
+                return r.getByPlaceholder(name, { exact: true });
+            case 'alt':
+                return r.getByAltText(name, { exact: true });
+            case 'title':
+                return r.getByTitle(name, { exact: true });
+            case 'testId':
+                return r.getByTestId(name);
+        }
+    },
+    async act(_, target, action) {
+        switch (action.do) {
+            case 'click':
+                return target.click();
+            case 'double-click':
+                return target.dblclick();
+            case 'hover':
+                return target.hover();
+            case 'focus':
+                return target.focus();
+            case 'check':
+                return target.check();
+            case 'uncheck':
+                return target.uncheck();
+            case 'clear':
+                return target.clear();
+            case 'fill':
+                return target.fill(action.text);
+            case 'type':
+                return target.pressSequentially(action.text);
+            case 'select':
+                await target.selectOption(action.text);
+                return;
+            case 'press':
+                return target.press(action.key);
+        }
+    },
+    press({ page }, key) {
+        return page.keyboard.press(key);
+    },
+    expect(ctx, target, state, not) {
+        const e = not ? ctx.expect(target).not : ctx.expect(target);
+        switch (state.is) {
+            case 'visible':
+                return e.toBeVisible();
+            case 'hidden':
+                return e.toBeHidden();
+            case 'checked':
+                return e.toBeChecked();
+            case 'enabled':
+                return e.toBeEnabled();
+            case 'disabled':
+                return e.toBeDisabled();
+            case 'focused':
+                return e.toBeFocused();
+            case 'empty':
+                return e.toBeEmpty();
+            case 'value':
+                return e.toHaveValue(state.text);
+            case 'text':
+                return e.toHaveText(state.text);
+            case 'containing':
+                return e.toContainText(state.text);
+        }
+    },
+};
+export const settle = settler(playwright);
+// ---------------------------------------------------------------- vocabulary
+const form = formsFor();
+const Path = called(TextType, 'a "/path" or URL');
+export function browser(parent = null) {
+    const env = queries(new Env(parent), playwright);
+    // navigation
+    env
+        .word('Visit', form([Path], (ctx, path) => ctx.page.goto(path)))
+        .word('Reload', form([], (ctx) => ctx.page.reload()))
+        .word('Back', form([], (ctx) => ctx.page.goBack()));
+    actions(env, playwright);
+    checks(env, playwright);
+    // checks on the page itself
+    return env
+        .word('At', form([Path], CheckType, (ctx, where) => new Expectation(`At ${JSON.stringify(where)}`, (not) => {
+        const e = ctx.expect(ctx.page);
+        return (not ? e.not : e).toHaveURL(urlPattern(where));
+    })))
+        .word('Titled', form([NameType], CheckType, (ctx, title) => new Expectation(`Titled ${say(title)}`, (not) => {
+        const e = ctx.expect(ctx.page);
+        return (not ? e.not : e).toHaveTitle(nameOf(title));
+    })));
+}
+// "/dashboard" means that path on whatever host the page is on.
+function urlPattern(where) {
+    if (!where.startsWith('/'))
+        return where;
+    return new RegExp(`^[a-z]+://[^/]+${escapeRegExp(where)}(?:[?#].*)?$`);
+}

package/dist/src/config.d.ts

@@ -0,0 +1,18 @@
+export interface Project {
+    root: string;
+    features: string[];
+    ignore: string[];
+    outputDir: string;
+}
+interface Registry {
+    collecting: boolean;
+    projects: Project[];
+}
+export declare const registry: Registry;
+export declare function findConfig(from: string): string | undefined;
+export declare const everything: (root: string) => Project;
+export declare function loadProjects(from?: string, { trusted }?: {
+    trusted?: boolean | undefined;
+}): Promise<Project[]>;
+export declare function contains(project: Project, file: string): boolean;
+export {};

package/dist/src/config.js

@@ -0,0 +1,63 @@
+// Which .spp files make up a project, for the tools that don't run Playwright:
+// the checker, the dictionary and the language server. Playwright's config
+// says, through its defineSppConfig calls (backends/playwright/generate.ts).
+//
+// The config is found by looking up from the current directory. Loading it
+// runs it, but only to collect what its defineSppConfig calls say: nothing is
+// generated. Without a config, or one with no defineSppConfig in it, the
+// project is every .spp file under the current directory.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const holder = globalThis;
+holder.sppRegistry ??= { collecting: false, projects: [] };
+export const registry = holder.sppRegistry;
+const NAMES = ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs'].map((ext) => `playwright.config.${ext}`);
+export function findConfig(from) {
+    for (let dir = path.resolve(from);; dir = path.dirname(dir)) {
+        const file = NAMES.map((name) => path.join(dir, name)).find((f) => fs.existsSync(f));
+        if (file)
+            return file;
+        if (dir === path.dirname(dir))
+            return undefined;
+    }
+}
+// Every .spp file under a directory, when nothing says otherwise.
+export const everything = (root) => ({
+    root: path.resolve(root),
+    features: [path.resolve(root)],
+    ignore: [],
+    outputDir: path.resolve(root, '.spp-tests'),
+});
+// The projects the config above a directory defines. Loading a config runs
+// it, so pass trusted: false where the project's code mustn't run, and get
+// the default instead.
+export async function loadProjects(from = process.cwd(), { trusted = true } = {}) {
+    const file = trusted ? findConfig(from) : undefined;
+    if (!file)
+        return [everything(from)];
+    registry.collecting = true;
+    registry.projects = [];
+    try {
+        // A new URL each time, so a config that's changed is read again.
+        await import(__rewriteRelativeImportExtension(`${pathToFileURL(file).href}?spp=${Date.now()}`));
+        return registry.projects.length ? [...registry.projects] : [everything(path.dirname(file))];
+    }
+    finally {
+        registry.collecting = false;
+        registry.projects = [];
+    }
+}
+// Whether a file is one of a project's: under its features, and not ignored.
+export function contains(project, file) {
+    const within = (dir) => file === dir || file.startsWith(dir + path.sep);
+    return project.features.some(within) && !project.ignore.some(within);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,22 @@
+export type { SppConfig, SppTests } from './backends/playwright/generate.ts';
+export { defineSppConfig, generate } from './backends/playwright/generate.ts';
+export { runScenario } from './backends/playwright/runtime.ts';
+export type { BrowserContext } from './backends/playwright/words.ts';
+export { browser, playwright, settle } from './backends/playwright/words.ts';
+export type { Project } from './config.ts';
+export { contains, everything, findConfig, loadProjects } from './config.ts';
+export type { CheckOptions, Diagnostic, Line, Place, Report, WordInfo } from './language/check.ts';
+export { Analysis, analyze, check, format } from './language/check.ts';
+export type { Node, Program, Statement, Token } from './language/cognate.ts';
+export { Block, call, core, Env, lex, parse, run, SppError, Stack, Sym } from './language/cognate.ts';
+export type { Feature, Scenario, SppFile, Step, Vocabulary } from './language/load.ts';
+export { discover, LoadError, load, loadSource, selects } from './language/load.ts';
+export type { Fence } from './language/markdown.ts';
+export { fences, sppFences, sppLines } from './language/markdown.ts';
+export type { CodeLine, Sections } from './language/sections.ts';
+export { codeLines, sections, split } from './language/sections.ts';
+export type { Context, Form, Type } from './language/types.ts';
+export { AnyType, called, formsFor, NumberType, oneOf, signature, TableType, TextType, type } from './language/types.ts';
+export { dictionary } from './tools/dictionary.ts';
+export type { Action, Capabilities, Driver, Name, Query, QueryKind, State } from './words/driver.ts';
+export { actions, CheckType, checks, ElementType, leftovers, MatcherType, NameType, PatternType, queries, ScopeType, settler, } from './words/shared.ts';

package/dist/src/index.js

@@ -0,0 +1,12 @@
+export { defineSppConfig, generate } from './backends/playwright/generate.js';
+export { runScenario } from './backends/playwright/runtime.js';
+export { browser, playwright, settle } from './backends/playwright/words.js';
+export { contains, everything, findConfig, loadProjects } from './config.js';
+export { Analysis, analyze, check, format } from './language/check.js';
+export { Block, call, core, Env, lex, parse, run, SppError, Stack, Sym } from './language/cognate.js';
+export { discover, LoadError, load, loadSource, selects } from './language/load.js';
+export { fences, sppFences, sppLines } from './language/markdown.js';
+export { codeLines, sections, split } from './language/sections.js';
+export { AnyType, called, formsFor, NumberType, oneOf, signature, TableType, TextType, type } from './language/types.js';
+export { dictionary } from './tools/dictionary.js';
+export { actions, CheckType, checks, ElementType, leftovers, MatcherType, NameType, PatternType, queries, ScopeType, settler, } from './words/shared.js';

package/dist/src/language/check.d.ts

@@ -0,0 +1,178 @@
+import type { Env, Node, Param, Program } from './cognate.ts';
+import type { Scenario, SppFile, Step } from './load.ts';
+import type { Form, Type } from './types.ts';
+export interface Diagnostic {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    define?: string;
+}
+export interface Report {
+    vocabulary: Diagnostic[];
+    scenarios: Map<Scenario, Diagnostic>;
+}
+export interface CheckOptions {
+    words: Env;
+    settle: (stack: {
+        name: string;
+        shown: string;
+    }[]) => string | null;
+    cwd?: string;
+}
+declare class Var {
+    members: readonly string[] | null;
+    phrase: string;
+}
+declare class BlockOf {
+    body: Program;
+    scope: Scope;
+    origin: Origin;
+    constructor(body: Program, scope: Scope, origin: Origin);
+}
+type Ty = Type<unknown> | Var | BlockOf;
+interface Val {
+    ty: Ty;
+    shown: string;
+}
+interface Want {
+    members: readonly string[] | null;
+    phrase: string;
+    key: unknown;
+}
+interface Way {
+    inputs: Want[];
+    outputs: (args: Val[]) => Val[];
+    def?: Def;
+}
+interface Origin {
+    file: string;
+    at(pos: number): {
+        line: number;
+        column: number;
+    };
+}
+declare class Mistake extends Error {
+    pos?: number;
+}
+export interface Place {
+    file: string;
+    line: number;
+    column: number;
+}
+interface Def {
+    name: string;
+    block: BlockOf;
+    at: Place;
+    header: Param[];
+    params: {
+        name: string;
+        type: Type<unknown>;
+    }[];
+    state: 'unchecked' | 'checking' | 'done';
+    outputs?: Val[];
+    noun?: Type<unknown>;
+    error?: Diagnostic;
+}
+type Known = {
+    name: string;
+} & ({
+    kind: 'forms';
+    forms: readonly Form[];
+} | {
+    kind: 'define';
+    defs: Def[];
+} | {
+    kind: 'value';
+    val: Val;
+});
+declare class Scope {
+    parent: Scope | null;
+    builtins: Env | null;
+    words: Map<string, Known>;
+    constructor(parent: Scope | null, builtins?: Env | null);
+    set(known: Known): void;
+    lookup(name: string): Known | undefined;
+    names(): Generator<string>;
+    all(): Known[];
+}
+declare class Sim {
+    open: boolean;
+    stack: Val[];
+    inputs: Var[];
+    constructor(open: boolean);
+    peek(i: number): Val | undefined;
+    fromCaller(want?: Want): Val;
+}
+export declare function check(files: SppFile[], options: CheckOptions): Report;
+export interface WordInfo {
+    name: string;
+    kind: 'builtin' | 'define' | 'value';
+    signatures: string[];
+    outputs: (readonly string[] | null)[];
+    at?: Place;
+    places?: Place[];
+}
+export interface Line {
+    file: string;
+    line: number;
+}
+export declare class Analysis {
+    report: Report;
+    private checker;
+    constructor(checker: Checker);
+    words(at?: Step | Line): WordInfo[];
+    word(name: string, at?: Step | Line): WordInfo | undefined;
+    expected(left: string, at?: Step | Line): {
+        members: readonly string[] | null;
+        phrase: string;
+    } | null;
+    chosen(file: string, line: number, column: number): Place | undefined;
+}
+export declare function analyze(files: SppFile[], options: CheckOptions): Analysis;
+declare class Checker {
+    options: CheckOptions;
+    cwd: string;
+    defs: Def[];
+    report: Report;
+    vocabulary: Scope;
+    stepScopes: Map<Step, Scope>;
+    lineScopes: Map<string, Scope>;
+    guessing: boolean;
+    chosen: Map<string, Def>;
+    constructor(options: CheckOptions);
+    check(files: SppFile[]): Report;
+    scenario(scenario: Scenario, vocabulary: Scope): Diagnostic | undefined;
+    settle(sim: Sim): void;
+    scopeFor(at?: Step | Line): Scope;
+    info(known: Known): WordInfo;
+    expected(left: string, scope: Scope): {
+        members: readonly string[] | null;
+        phrase: string;
+    } | null;
+    diagnose(err: unknown, origin: Origin, define?: string): Diagnostic;
+    run(program: Program, scope: Scope, sim: Sim, origin: Origin): void;
+    evaluate(node: Node, scope: Scope, sim: Sim, origin: Origin): void | Way;
+    params(def: Def): {
+        name: string;
+        type: Type<unknown>;
+    }[];
+    kindOf(name: string, scope: Scope): Type<unknown>;
+    nounOf(def: Def, outputs: Val[]): Type<unknown> | undefined;
+    overloads(vocabulary: Scope): void;
+    where(d: Place): string;
+    take(sim: Sim, word: string): Val;
+    formWay(name: string, form: Form): Way;
+    defineWays(defs: Def[]): Way[];
+    defineWay(def: Def): Way;
+    checkDefine(def: Def): void;
+    call(name: string, ways: Way[], sim: Sim): Way;
+    fit(way: Way, sim: Sim): {
+        binds: Map<Var, Want>;
+        fresh: number;
+        unsure: number;
+    } | null;
+    mismatch(name: string, ways: Way[], sim: Sim): Mistake;
+}
+export declare function format(d: Diagnostic, source: string, cwd?: string): string;
+export {};