@bramas/simulant-lang 0.0.0-stage → 0.1.0

package/dist/elab/elaborate.js

@@ -0,0 +1,1094 @@
+/**
+ * Elaboration of `.sim` declarations to IR (plan, Section 3).
+ *
+ * Two levels:
+ * - definitions whose type is a model piece (`Component`, `Model`, `Sensor`,
+ *   `Topology`, `FrameModel`, `Round`, `Memory`, or lists of them) are
+ *   evaluated at compile time, with their arguments: model families are
+ *   functions;
+ * - expressions inside hooks, sensors, tasks, algorithms, initial values and
+ *   parameter domains are translated to IR expressions. A component's
+ *   parameters stay symbolic in its expressions.
+ *
+ * Constructors, `none` and `[]` become literals of type `infer`, resolved by
+ * the checker once the experiment is assembled (`resolve.ts`).
+ */
+import { BUILTINS } from "../builtins.js";
+import { check } from "../check.js";
+import { IR_VERSION } from "../ir.js";
+import { Parser } from "../parse/parser.js";
+import { fillActionDefaults, lower } from "./lower.js";
+import { resolveTypes } from "../resolve.js";
+import { T } from "../types.js";
+import { Program } from "./program.js";
+export class ElabError extends Error {
+    span;
+    constructor(message, span) {
+        super(message);
+        this.span = span;
+    }
+}
+const fail = (msg, span) => { throw new ElabError(msg, span); };
+const ROUND = T.enum('Round', ['fsync', 'ssync']);
+const MEMORY = T.enum('Memory', ['persistent', 'oblivious']);
+const SYMMETRIES = T.enum('Symmetries', ['derived', 'none']);
+const META_TYPES = new Set(['Component', 'Model', 'Sensor', 'Topology', 'FrameModel', 'Round', 'Memory', 'Symmetries']);
+function isMetaType(t) {
+    if (!t || t.t !== 'name')
+        return false;
+    return META_TYPES.has(t.name) || (t.name === 'List' && isMetaType(t.args[0]));
+}
+/** A function on values (`def f (x : T) : R := e`), as opposed to a model-level definition. */
+function isObjectDef(d) {
+    return !!d && d.d === 'def' && !!d.body && !!d.type && !isMetaType(d.type);
+}
+const COLLECTION_METHODS_WITH_FN = new Set(['filter', 'map', 'any', 'all', 'count']);
+const BUILTIN_FUNCTIONS = new Set([
+    'present', 'correct', 'decisionOf', 'target', 'advance', 'edgePresent', 'offset', 'toGlobal', 'node', 'range', 'subsets',
+    'subsetsUpTo', 'ofFn', 'show', 'min', 'max', 'some', 'opposite', 'toInt',
+]);
+/** Builtins whose arguments at these positions are functions. */
+const FUNCTION_ARGS = { filter: [1], map: [1], any: [1], all: [1], count: [1], ofFn: [1] };
+const BINOPS = {
+    '=': 'eq', '≠': 'ne', '<': 'lt', '>': 'gt', '≤': 'le', '≥': 'ge', '+': 'add', '-': 'sub', '*': 'mul', '/': 'div', '%': 'mod',
+};
+/** What a declaration is, in `Experiment.source` (model-level definitions by their type). */
+function declKind(d) {
+    switch (d.d) {
+        case 'experiment':
+        case 'algorithm':
+        case 'task':
+        case 'sensor': return d.d;
+        case 'def': {
+            const t = d.type?.t === 'name' ? d.type.name : undefined;
+            return t === 'Component' ? 'component' : t === 'Model' ? 'model' : t === 'Sensor' ? 'sensor' : 'definition';
+        }
+    }
+    return undefined;
+}
+export class Elaborator {
+    program;
+    /** Source spans of IR expressions, for diagnostics. */
+    spans = new WeakMap();
+    diagnostics = [];
+    globals = new Map();
+    enums = new Map();
+    structures = new Map();
+    goals = new Map();
+    /** Object-level definitions, elaborated once, in dependency order, with the definitions they call. */
+    objectDefs = new Map();
+    /** The definitions called by what is being elaborated (they go with it into the IR). */
+    calledDefs;
+    /** The declarations the experiment being built uses, for `Experiment.source` (display only). */
+    uses;
+    constructor(program) {
+        this.program = program;
+        this.diagnostics.push(...program.diagnostics);
+        for (const d of program.decls()) {
+            if (d.d === 'import')
+                continue;
+            if (d.d === 'goal') {
+                this.goals.set(d.name, { goal: d.goal, span: d.span });
+                continue;
+            }
+            if (this.globals.has(d.name)) {
+                this.diagnostics.push({ message: `${d.name} is declared twice`, span: d.span });
+                continue;
+            }
+            this.globals.set(d.name, d);
+            if (d.d === 'inductive')
+                this.enums.set(d.name, T.enum(d.name, d.ctors));
+            if (d.d === 'structure')
+                this.structures.set(d.name, d);
+        }
+    }
+    /** Evaluates a model-level expression, such as `Hazards.BlackHole .mayEmerge`. */
+    evaluate(text) {
+        const v = this.meval(new Parser(text, '<expression>').expr(), new Map());
+        if (v.m === 'component' || v.m === 'model' || v.m === 'sensor')
+            return v.ir;
+        return fail(`${text} is not a component, a model or a sensor`);
+    }
+    /** The experiments declared in the entry module. */
+    experiments() {
+        const entry = this.program.modules.get(this.program.entry);
+        return (entry?.decls ?? []).filter(d => d.d === 'experiment').map(d => d.name);
+    }
+    // -------------------------------------------------------------------------
+    // Types
+    type(t) {
+        if (t.t === 'record')
+            return T.record(t.fields.map(f => ({ name: f.name, type: this.type(f.type) })));
+        const arg = (i = 0) => t.args[i] ? this.type(t.args[i]) : fail(`${t.name} needs a type argument`, t.span);
+        switch (t.name) {
+            case 'Nat': return T.nat;
+            case 'Int': return T.int;
+            case 'Bool': return T.bool;
+            case 'String': return T.string;
+            case 'Unit': return T.unit;
+            case 'Node': return T.node;
+            case 'Agent': return T.agent;
+            case 'Move': return T.move;
+            case 'Frame': return T.frame;
+            case 'Config': return T.config;
+            case 'Verdict': return T.verdict;
+            case 'Pub': return T.pub;
+            case 'Option': return T.option(arg());
+            case 'List': return T.list(arg());
+            case 'Multiset': return T.multiset(arg());
+        }
+        const e = this.enums.get(t.name);
+        if (e)
+            return e;
+        const s = this.structures.get(t.name);
+        if (s)
+            return T.record(s.fields.map(f => ({ name: f.name, type: this.type(f.type) })));
+        return fail(`unknown type ${t.name}`, t.span);
+    }
+    enumType(t) {
+        if (!t || t.t !== 'name')
+            return undefined;
+        if (t.name === 'Round')
+            return ROUND;
+        if (t.name === 'Memory')
+            return MEMORY;
+        if (t.name === 'Symmetries')
+            return SYMMETRIES;
+        return this.enums.get(t.name);
+    }
+    // -------------------------------------------------------------------------
+    // Meta level
+    meval(e, env, expected) {
+        switch (e.t) {
+            case 'num': return { m: 'nat', v: e.value };
+            case 'bool': return { m: 'bool', v: e.value };
+            case 'str': return { m: 'str', v: e.value };
+            case 'ctor': {
+                const t = this.enumType(expected) ?? this.uniqueEnum(e.name, e.span);
+                if (!t.ctors.includes(e.name))
+                    fail(`.${e.name} is not a constructor of ${t.name}`, e.span);
+                return { m: 'enum', type: t, ctor: e.name };
+            }
+            case 'list': {
+                const elem = expected?.t === 'name' && expected.name === 'List' ? expected.args[0] : undefined;
+                return { m: 'list', items: e.items.map(i => this.meval(i, env, elem)) };
+            }
+            case 'binop': {
+                if (e.op === '++') {
+                    const [a, b] = [this.meval(e.l, env, expected), this.meval(e.r, env, expected)];
+                    if (a.m !== 'list' || b.m !== 'list')
+                        fail('++ joins lists', e.span);
+                    return { m: 'list', items: [...a.items, ...b.items] };
+                }
+                if (e.op === '=' || e.op === '≠') {
+                    const a = this.meval(e.l, env);
+                    const b = this.meval(e.r, env, a.m === 'enum' ? { t: 'name', name: a.type.name, args: [], span: e.span } : undefined);
+                    const same = JSON.stringify(stripType(a)) === JSON.stringify(stripType(b));
+                    return { m: 'bool', v: e.op === '=' ? same : !same };
+                }
+                if (e.op === '∧' || e.op === '∨') {
+                    const a = this.bool(this.meval(e.l, env), e.l.span), b = this.bool(this.meval(e.r, env), e.r.span);
+                    return { m: 'bool', v: e.op === '∧' ? a && b : a || b };
+                }
+                return fail(`${e.op} cannot be evaluated when building a model`, e.span);
+            }
+            case 'if':
+                return this.bool(this.meval(e.cond, env), e.cond.span) ? this.meval(e.then, env, expected) : this.meval(e.else, env, expected);
+            case 'ascribe':
+                return this.meval(e.e, env, e.type);
+            case 'name':
+                return env.get(e.name) ?? this.metaCall(e.name, [], e.span, env);
+            case 'app': {
+                if (e.fn.t !== 'name')
+                    fail('expected the name of a definition', e.fn.span);
+                return this.metaCall(e.fn.name, e.args, e.span, env);
+            }
+            default:
+                return fail('this expression cannot be evaluated when building a model', e.span);
+        }
+    }
+    bool(v, span) {
+        return v.m === 'bool' ? v.v : fail('expected a Bool', span);
+    }
+    uniqueEnum(ctor, span) {
+        const all = [...this.enums.values(), ROUND, MEMORY, SYMMETRIES].filter(t => t.ctors.includes(ctor));
+        if (all.length === 1)
+            return all[0];
+        return fail(all.length ? `ambiguous constructor .${ctor}: ${all.map(t => t.name).join(' or ')}` : `unknown constructor .${ctor}`, span);
+    }
+    /** Calls a definition, a sensor, or a builtin of the model level. */
+    metaCall(name, args, span, env) {
+        switch (name) {
+            case 'Ring': return { m: 'topology', ir: { kind: 'ring', size: { e: 'param', name: 'N' } } };
+            case 'DynamicRing': {
+                const k = args.length ? this.meval(args[0].value, env) : { m: 'nat', v: 1 };
+                if (k.m !== 'nat')
+                    fail('DynamicRing takes a number of edges', span);
+                return { m: 'topology', ir: { kind: 'dynamicRing', size: { e: 'param', name: 'N' }, k: k.v } };
+            }
+            case 'Frames.common': return { m: 'frame', ir: { kind: 'common' } };
+            case 'Frames.dynamicReflection': return { m: 'frame', ir: { kind: 'dynamicReflection' } };
+            case 'Frames.persistent': {
+                const f = args[0]?.value;
+                if (!f || f.t !== 'name')
+                    fail('Frames.persistent takes the name of an agent field of type Frame', span);
+                return { m: 'frame', ir: { kind: 'persistent', field: f.name } };
+            }
+        }
+        const decl = this.globals.get(name) ?? fail(`unknown name ${name}`, span);
+        this.use(decl);
+        if (decl.d === 'sensor')
+            return { m: 'sensor', ir: this.sensor(decl, this.bindArgs(decl.params.filter(p => !runtimeBinder(p.type)), args, env, span)) };
+        if (decl.d !== 'def' || !isMetaType(decl.type))
+            return fail(`${name} cannot be used when building a model`, span);
+        const bound = this.bindArgs(decl.params, args, env, span);
+        const t = decl.type;
+        if (decl.body)
+            return this.meval(decl.body, bound, decl.type);
+        if (t.name === 'Component')
+            return { m: 'component', ir: this.component(decl, bound) };
+        if (t.name === 'Model')
+            return { m: 'model', ir: this.model(decl, bound) };
+        return fail(`a ${t.name} is defined by a value (:=), not a where block`, decl.span);
+    }
+    bindArgs(params, args, env, span) {
+        const bound = new Map();
+        const positional = args.filter(a => !a.name);
+        let next = 0;
+        for (const p of params) {
+            const named = args.find(a => a.name === p.name);
+            const arg = named?.value ?? positional[next++]?.value;
+            if (arg)
+                bound.set(p.name, this.meval(arg, env, p.type));
+            else if (p.default)
+                bound.set(p.name, this.meval(p.default, bound, p.type));
+            else
+                fail(`missing argument ${p.name}`, span);
+        }
+        if (next < positional.length)
+            fail('too many arguments', span);
+        for (const a of args)
+            if (a.name && !params.some(p => p.name === a.name))
+                fail(`no parameter named ${a.name}`, a.value.span);
+        return bound;
+    }
+    /** A meta value as an IR literal (component arguments, sensor parameters). */
+    json(v, span) {
+        switch (v.m) {
+            case 'nat':
+            case 'bool':
+            case 'str': return v.v;
+            case 'enum': return v.ctor;
+            case 'list': return v.items.map(i => this.json(i, span));
+            default: return fail('expected a value', span);
+        }
+    }
+    equivariance(d) {
+        const a = d.attrs.find(a => a.name === 'equivariant');
+        return a && { rotations: a.args.includes('rotations'), reflections: a.args.includes('reflections') };
+    }
+    // -------------------------------------------------------------------------
+    // Components, sensors, models
+    component(decl, args) {
+        const name = decl.name.split('.').pop();
+        const items = new Map(decl.items.map(i => [i.name + (i.args.length ? '/' + i.args.length : ''), i]));
+        const typeItem = (n) => {
+            const i = items.get(n);
+            if (!i)
+                return undefined;
+            if (i.value.t !== 'typeValue' || i.value.type.t !== 'record')
+                fail(`${n} is a record type: { f : T, ... }`, i.span);
+            return i.value.type.fields.map(f => ({ name: f.name, type: this.type(f.type) }));
+        };
+        const params = decl.params.map(p => ({ name: p.name, type: this.type(p.type) }));
+        const scope = new Map(params.map(p => [p.name, p.name]));
+        const ctx = (extra = []) => ({ scope: new Map([...scope, ...extra]), params: new Set(), owner: name });
+        const listItem = (n, f) => {
+            const i = items.get(n);
+            if (!i)
+                return [];
+            if (i.value.t !== 'list')
+                fail(`${n} is a list`, i.value.span);
+            return i.value.items.map(f);
+        };
+        const flags = listItem('flags', e => e.t === 'flag'
+            ? { name: e.name, visibility: e.visibility, acts: e.acts }
+            : fail('expected `flag name visible|hidden, acts never|adversary`', e.span));
+        const actions = listItem('actions', e => {
+            if (e.t !== 'action')
+                return fail('expected `action name : Type := default`', e.span);
+            const type = this.type(e.type);
+            const d = this.meval(e.default, new Map(), e.type);
+            return { name: e.name, type, default: this.json(d, e.default.span) };
+        });
+        const sensors = listItem('sensors', e => {
+            if (e.t !== 'name')
+                return fail('expected the name of a sensor', e.span);
+            const full = this.globals.has(`${decl.name}.${e.name}`) ? `${decl.name}.${e.name}` : e.name;
+            const s = this.globals.get(full);
+            if (!s || s.d !== 'sensor')
+                return fail(`unknown sensor ${e.name}`, e.span);
+            this.use(s);
+            return this.sensor(s, new Map(), { owner: name, scope });
+        });
+        const initRecord = (item, extra) => {
+            if (!item)
+                return undefined;
+            if (item.value.t !== 'record' || item.value.base)
+                fail('init is a record of initial values: { f := e, ... }', item.value.span);
+            const out = {};
+            for (const it of item.value.items) {
+                if (it.t !== 'field')
+                    fail('unexpected raise in init', it.span);
+                const f = it;
+                out[f.name] = this.tr(f.value ?? { t: 'name', name: f.name, span: f.span }, { ...ctx(extra), letName: f.name });
+            }
+            return out;
+        };
+        const agentInit = items.get('init/1');
+        const hook = (n) => {
+            const i = [...items.values()].find(i => i.name === n);
+            if (!i)
+                return undefined;
+            if (i.args.length !== 1)
+                fail(`${n} takes the configuration: ${n} C := ...`, i.span);
+            return this.tr(i.value, { ...ctx([[i.args[0], 'C']]), effects: true });
+        };
+        const c = {
+            name,
+            params: params.length ? params : undefined,
+            args: params.length ? Object.fromEntries(params.map(p => [p.name, this.json(args.get(p.name), decl.span)])) : undefined,
+            world: typeItem('World'),
+            agent: typeItem('Agent'),
+            flags: flags.length ? flags : undefined,
+            sensors: sensors.length ? sensors : undefined,
+            actions: actions.length ? actions : undefined,
+            init: dropUndefined({
+                world: initRecord(items.get('init'), []),
+                agent: agentInit && initRecord(agentInit, [[agentInit.args[0], 'i']]),
+            }),
+            beforeLook: hook('beforeLook'),
+            beforeMove: hook('beforeMove'),
+            afterMove: hook('afterMove'),
+            equivariance: this.equivariance(decl),
+        };
+        for (const i of decl.items) {
+            const known = ['World', 'Agent', 'flags', 'actions', 'sensors', 'init', 'beforeLook', 'beforeMove', 'afterMove'];
+            if (!known.includes(i.name))
+                fail(`unknown component field ${i.name} (expected one of ${known.join(', ')})`, i.span);
+        }
+        if (c.init && !c.init.world && !c.init.agent)
+            delete c.init;
+        return dropUndefined(c);
+    }
+    /**
+     * A sensor: binders of type `Config`, `Agent` and `Frame` are the observed
+     * configuration, the observer and its frame; the others are parameters of
+     * the family, fixed by `args`.
+     */
+    sensor(decl, args, component) {
+        const scope = new Map(component?.scope ?? []);
+        const constants = new Map();
+        for (const p of decl.params) {
+            const runtime = runtimeBinder(p.type);
+            if (runtime)
+                scope.set(p.name, runtime);
+            else {
+                const v = args.get(p.name) ?? fail(`missing argument ${p.name} of sensor ${decl.name}`, decl.span);
+                constants.set(p.name, { e: 'lit', type: this.type(p.type), value: this.json(v, decl.span) });
+            }
+        }
+        const implemented = decl.attrs.find(a => a.name === 'implements')?.args[0];
+        const name = implemented ?? decl.name.split('.').pop();
+        const owner = component?.owner ?? decl.name.split('.').pop();
+        const body = this.tr(decl.body, { scope, params: new Set(), owner, constants });
+        return dropUndefined({ name, type: this.type(decl.type), body, equivariance: this.equivariance(decl) });
+    }
+    model(decl, env) {
+        const v = (n) => {
+            const i = decl.items.find(i => i.name === n);
+            return i && this.meval(i.value, env, {
+                topology: { t: 'name', name: 'Topology', args: [], span: i.span },
+                memory: { t: 'name', name: 'Memory', args: [], span: i.span },
+                round: { t: 'name', name: 'Round', args: [], span: i.span },
+                symmetries: { t: 'name', name: 'Symmetries', args: [], span: i.span },
+            }[n]);
+        };
+        for (const i of decl.items) {
+            const known = ['topology', 'sensors', 'memory', 'frame', 'round', 'components', 'symmetries'];
+            if (!known.includes(i.name))
+                fail(`unknown model field ${i.name} (expected one of ${known.join(', ')})`, i.span);
+        }
+        const list = (x, m, span) => !x ? [] : x.m === 'list'
+            ? x.items.map(i => i.m === m ? i.ir : fail(`expected a list of ${m}s`, span))
+            : fail(`expected a list of ${m}s`, span);
+        const topology = v('topology');
+        const args = [...env.values()].filter(x => x.m === 'enum' || x.m === 'nat').map(x => x.m === 'enum' ? x.ctor : x.v);
+        return dropUndefined({
+            name: `${decl.name}${args.length ? `(${args.join(', ')})` : ''}`,
+            topology: topology ? (topology.m === 'topology' ? topology.ir : fail('expected a topology', decl.span)) : { kind: 'ring', size: { e: 'param', name: 'N' } },
+            sensors: list(v('sensors'), 'sensor', decl.span),
+            memory: v('memory')?.ctor ?? 'persistent',
+            frame: v('frame')?.ir ?? { kind: 'common' },
+            round: v('round')?.ctor ?? 'fsync',
+            movement: 'rigid',
+            components: list(v('components'), 'component', decl.span),
+            symmetries: v('symmetries')?.ctor ?? 'derived',
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Algorithms, tasks, experiments
+    algorithm(decl, memory = 'persistent') {
+        if (decl.items.some(i => i.proc))
+            return this.structured(decl, memory);
+        const item = (n) => decl.items.find(i => i.name === n);
+        const typeOf = (n) => {
+            const i = item(n);
+            if (!i)
+                return T.unit;
+            if (i.value.t !== 'typeValue')
+                fail(`${n} is a type`, i.span);
+            return this.type(i.value.type);
+        };
+        const owner = decl.name;
+        const init = item('init') ?? fail('an algorithm needs `init i := { pub := ..., mem := ... }`', decl.span);
+        const iName = init.args[0] ?? 'i';
+        const fields = init.value.t === 'record' ? init.value.items : fail('init is a record { pub := ..., mem := ... }', init.value.span);
+        const initOf = (n) => {
+            const f = fields.find(f => f.t === 'field' && f.name === n);
+            return f?.value ? this.tr(f.value, { scope: new Map([[iName, 'i']]), params: new Set(), owner }) : this.hole(null, init.span);
+        };
+        const step = item('step') ?? fail('an algorithm needs `step mem pub view := ...`', decl.span);
+        const [m, p, v] = [step.args[0] ?? 'mem', step.args[1] ?? 'pub', step.args[2] ?? 'view'];
+        const line = item('line');
+        for (const i of decl.items) {
+            const known = ['Pub', 'Mem', 'init', 'step', 'line'];
+            if (!known.includes(i.name) && !i.name.startsWith('output.'))
+                fail(`unknown algorithm field ${i.name} (expected one of ${known.join(', ')}, or output)`, i.span);
+        }
+        const mem = typeOf('Mem');
+        return dropUndefined({
+            name: decl.name,
+            uses: decl.uses,
+            pub: typeOf('Pub'),
+            mem,
+            init: { pub: initOf('pub'), mem: mem.k === 'unit' && !fields.some(f => f.t === 'field' && f.name === 'mem') ? this.lit(T.unit, null, init.span) : initOf('mem') },
+            step: this.tr(step.value, { scope: new Map([[m, 'mem'], [p, 'pub'], [v, 'view']]), params: new Set(), owner, decision: { pub: 'pub', mem: 'mem' } }),
+            line: line && this.tr(line.value, { scope: new Map([[line.args[0] ?? 'mem', 'mem']]), params: new Set(), owner }),
+            source: { file: decl.span.file, line: decl.span.start.line, endLine: decl.span.end.line },
+        });
+    }
+    /** A structured algorithm (procedures, `main`), lowered to a state machine (`lower.ts`). */
+    structured(decl, memory) {
+        const owner = decl.name;
+        const procs = new Map();
+        let main;
+        for (const i of decl.items) {
+            if (!i.proc)
+                continue;
+            if (i.name === 'main')
+                main = i.proc;
+            else
+                procs.set(i.name, i.proc);
+        }
+        if (!main)
+            return fail(`${decl.name}: a structured algorithm needs \`main := ...\``, decl.span);
+        for (const i of decl.items) {
+            if (!i.proc && !['Pub', 'init'].includes(i.name) && !i.name.startsWith('output.')) {
+                fail(`unknown field ${i.name} of a structured algorithm (expected Pub, init, output, def, main; memory is derived)`, i.span);
+            }
+        }
+        const pubItem = decl.items.find(i => i.name === 'Pub');
+        const pub = pubItem ? (pubItem.value.t === 'typeValue' ? this.type(pubItem.value.type) : fail('Pub is a type', pubItem.span)) : T.unit;
+        const init = decl.items.find(i => i.name === 'init');
+        let initPub = this.lit(T.unit, null, decl.span);
+        if (init) {
+            if (init.value.t !== 'record')
+                fail('init is a record { pub := ... }', init.value.span);
+            const f = init.value.items.find(x => x.t === 'field' && x.name === 'pub');
+            if (f?.value)
+                initPub = this.tr(f.value, { scope: new Map([[init.args[0] ?? 'i', 'i']]), params: new Set(), owner });
+        }
+        const lowered = lower(decl.name, procs, main.body, decl.uses, memory === 'oblivious', {
+            tr: (e, scope, constants) => this.tr(e, { scope, params: new Set(), owner, constants }),
+            type: t => this.type(t),
+            fail: (msg, span) => fail(msg, span),
+        });
+        return dropUndefined({
+            name: decl.name, uses: decl.uses, pub, mem: lowered.mem,
+            init: { pub: initPub, mem: lowered.initMem },
+            step: lowered.step, line: lowered.line,
+            source: {
+                file: decl.span.file, line: decl.span.start.line, endLine: decl.span.end.line,
+                ...(Object.keys(lowered.calls).length ? { calls: lowered.calls } : {}),
+            },
+        });
+    }
+    /** The outputs an algorithm declares (`output claim := pub.bh`). */
+    outputs(decl) {
+        return new Map(decl.items.filter(i => i.name.startsWith('output.')).map(i => [i.name.slice('output.'.length), i.value]));
+    }
+    task(decl, outputs = new Map()) {
+        const C = decl.params.find(p => runtimeBinder(p.type) === 'C')?.name ?? 'C';
+        return dropUndefined({
+            name: decl.name,
+            goal: this.goals.get(decl.name)?.goal ?? 'eventually',
+            verdict: this.tr(decl.body, { scope: new Map([[C, 'C']]), params: new Set(), owner: decl.name, outputs }),
+            equivariance: this.equivariance(decl),
+        });
+    }
+    /** Elaborates, resolves and checks an experiment of the entry module. */
+    experiment(name) {
+        try {
+            const decl = this.globals.get(name);
+            if (!decl || decl.d !== 'experiment')
+                fail(`no experiment ${name}`);
+            const exp = this.buildExperiment(decl);
+            const first = check(exp);
+            const diagnostics = first.diagnostics.map(d => this.locate(d, decl.span));
+            if (diagnostics.length)
+                return { diagnostics: [...this.diagnostics, ...diagnostics] };
+            const types = resolveTypes(exp, first.resolutions, (from, to) => {
+                const s = this.spans.get(from);
+                if (s)
+                    this.spans.set(to, s);
+            });
+            // After resolution, which replaces literals (and carries their spans over).
+            const resolved = { ...types, algorithm: this.located(types.algorithm) };
+            const second = check(resolved);
+            return second.errors.length
+                ? { diagnostics: [...this.diagnostics, ...second.diagnostics.map(d => this.locate(d, decl.span))] }
+                : { experiment: resolved, diagnostics: this.diagnostics };
+        }
+        catch (e) {
+            if (!(e instanceof ElabError))
+                throw e;
+            return { diagnostics: [...this.diagnostics, { message: e.message, span: e.span }] };
+        }
+    }
+    locate(d, fallback) {
+        return { message: d.message, span: (d.node && this.spans.get(d.node)) ?? fallback };
+    }
+    buildExperiment(decl) {
+        const uses = this.uses = new Map();
+        try {
+            this.use(decl);
+            return this.experimentOf(decl, uses);
+        }
+        finally {
+            this.uses = undefined;
+        }
+    }
+    /** Records that the experiment being built uses `decl` (display only). */
+    use(decl) {
+        const kind = declKind(decl);
+        const name = 'name' in decl ? decl.name : undefined;
+        if (!this.uses || !kind || !name || this.uses.has(`${kind} ${name}`))
+            return;
+        this.uses.set(`${kind} ${name}`, { kind, name, file: decl.span.file, line: decl.span.start.line, endLine: decl.span.end.line });
+    }
+    experimentOf(decl, uses) {
+        const item = (n) => decl.items.find(i => i.name === n && !i.param);
+        const required = (n) => item(n) ?? fail(`an experiment needs \`${n} := ...\``, decl.span);
+        const modelValue = this.meval(required('model').value, new Map(), { t: 'name', name: 'Model', args: [], span: decl.span });
+        const ref = (n, kind) => {
+            const v = required(n).value;
+            const d = v.t === 'name' ? this.globals.get(v.name) : undefined;
+            if (!d || d.d !== kind)
+                fail(`expected the name of ${kind === 'algorithm' ? 'an algorithm' : 'a task'}`, v.span);
+            return d;
+        };
+        const algDecl = ref('algorithm', 'algorithm');
+        const algorithm = this.withDefs(() => this.algorithm(algDecl, modelValue.ir.memory));
+        const task = this.withDefs(() => this.task(ref('task', 'task'), this.outputs(algDecl)));
+        const paramNames = new Set();
+        // Definitions called by parameter domains and initial positions belong to the model (plan 3.9).
+        const used = new Set();
+        const outer = this.calledDefs;
+        this.calledDefs = used;
+        const params = decl.items.filter(i => i.param).map(i => {
+            const p = { name: i.name, type: this.type(i.param.type) };
+            if (i.value.t !== 'nothing')
+                p.domain = this.tr(i.value, { scope: new Map(), params: new Set(paramNames), owner: decl.name });
+            paramNames.add(i.name);
+            return p;
+        });
+        const ictx = (extra = []) => ({ scope: new Map(extra), params: paramNames, owner: decl.name });
+        const pos = item('position');
+        const limits = item('limits');
+        for (const i of decl.items) {
+            const known = ['model', 'algorithm', 'task', 'agents', 'position', 'limits'];
+            if (!i.param && !known.includes(i.name))
+                fail(`unknown experiment field ${i.name} (expected one of ${known.join(', ')}, or param)`, i.span);
+        }
+        const model0 = modelValue.m === 'model' ? modelValue.ir : fail('expected a model', required('model').span);
+        const actions = model0.components.flatMap(c => c.actions ?? []);
+        let agents;
+        try {
+            agents = {
+                count: this.tr(required('agents').value, ictx()),
+                pos: pos ? this.tr(pos.value, ictx([[pos.args[0] ?? 'i', 'i']])) : fail('an experiment needs `position i := ...`', decl.span),
+            };
+        }
+        finally {
+            this.calledDefs = outer;
+        }
+        const model = used.size ? { ...model0, defs: [...(model0.defs ?? []), ...this.defsIn(used)] } : model0;
+        this.use(algDecl);
+        const taskDecl = ref('task', 'task');
+        this.use(taskDecl);
+        const goal = this.goals.get(taskDecl.name);
+        if (goal)
+            uses.set(`goal ${taskDecl.name}`, { kind: 'goal', name: taskDecl.name, file: goal.span.file, line: goal.span.start.line, endLine: goal.span.end.line });
+        for (const d of [...model.defs ?? [], ...algorithm.defs ?? [], ...task.defs ?? []]) {
+            const span = this.objectDefs.get(d.name)?.span;
+            if (span)
+                uses.set(`definition ${d.name}`, { kind: 'definition', name: d.name, file: span.file, line: span.start.line, endLine: span.end.line });
+        }
+        return dropUndefined({
+            irVersion: IR_VERSION,
+            name: decl.name,
+            model,
+            algorithm: algorithm.native ? algorithm : { ...algorithm, step: fillActionDefaults(algorithm.step, actions) },
+            task,
+            params,
+            agents,
+            limits: limits && this.limits(limits),
+            source: { file: decl.span.file, line: decl.span.start.line, endLine: decl.span.end.line, uses: [...uses.values()] },
+        });
+    }
+    limits(i) {
+        if (i.value.t !== 'record')
+            return fail('limits is a record { depth := n, states := n }', i.span);
+        const out = {};
+        for (const it of i.value.items) {
+            if (it.t !== 'field' || !it.value || it.value.t !== 'num')
+                fail('expected `depth := n` or `states := n`', it.span);
+            out[it.name] = (it.value).value;
+        }
+        return out;
+    }
+    // -------------------------------------------------------------------------
+    // Object-level definitions
+    /** Elaborates an algorithm or a task, with the definitions it calls. */
+    withDefs(f) {
+        const outer = this.calledDefs;
+        const used = this.calledDefs = new Set();
+        try {
+            const x = f();
+            return used.size ? { ...x, defs: this.defsIn(used) } : x;
+        }
+        finally {
+            this.calledDefs = outer;
+        }
+    }
+    /**
+     * For the explanation of a step (display only): the source lines of the algorithm's step and
+     * of its definitions (`at`), and where the definitions are written (`source.defs`).
+     */
+    located(a) {
+        const mark = (x) => {
+            if (!x || typeof x !== 'object')
+                return;
+            if (Array.isArray(x)) {
+                x.forEach(mark);
+                return;
+            }
+            const o = x;
+            if (typeof o.e === 'string' && o.at === undefined) {
+                const span = this.spans.get(o);
+                if (span)
+                    o.at = span.start.line;
+            }
+            for (const [k, v] of Object.entries(o))
+                if (k !== 'type')
+                    mark(v);
+        };
+        mark(a.step);
+        for (const d of a.defs ?? [])
+            mark(d.body);
+        const defs = (a.defs ?? []).flatMap(d => {
+            const span = this.objectDefs.get(d.name)?.span;
+            return span ? [{ name: d.name, file: span.file, line: span.start.line, endLine: span.end.line }] : [];
+        });
+        return defs.length && a.source ? { ...a, source: { ...a.source, defs } } : a;
+    }
+    /** The definitions named in `used`, callees first. */
+    defsIn(used) {
+        return [...this.objectDefs].filter(([n]) => used.has(n)).map(([, d]) => d.def);
+    }
+    /** Records a call to an object-level definition (elaborating it the first time). */
+    useDef(decl, span) {
+        let entry = this.objectDefs.get(decl.name);
+        if (!entry) {
+            if (BUILTINS[decl.name])
+                fail(`${decl.name} is a builtin: give the definition another name`, decl.span);
+            entry = { deps: new Set(), span: decl.span };
+            this.objectDefs.set(decl.name, entry);
+            const outer = this.calledDefs;
+            this.calledDefs = entry.deps;
+            try {
+                const params = decl.params.map(p => ({ name: p.name, type: this.type(p.type) }));
+                const scope = new Map(params.map(p => [p.name, p.name]));
+                const body = this.tr(decl.body, { scope, params: new Set(), owner: decl.name });
+                // Callees first: the map keeps insertion order, so re-insert after the dependencies.
+                this.objectDefs.delete(decl.name);
+                this.objectDefs.set(decl.name, entry);
+                entry.def = { name: decl.name, params, ret: this.type(decl.type), body };
+            }
+            catch (e) {
+                this.objectDefs.delete(decl.name);
+                throw e;
+            }
+            finally {
+                this.calledDefs = outer;
+            }
+        }
+        else if (!entry.def) {
+            fail(`definitions cannot be recursive: ${decl.name}`, span);
+        }
+        if (this.calledDefs) {
+            this.calledDefs.add(decl.name);
+            for (const d of entry.deps)
+                this.calledDefs.add(d);
+        }
+        return entry.def;
+    }
+    // -------------------------------------------------------------------------
+    // Object level
+    mark(e, span) {
+        this.spans.set(e, span);
+        return e;
+    }
+    lit(type, value, span) {
+        return this.mark({ e: 'lit', type, value }, span);
+    }
+    hole(value, span) {
+        return this.lit(T.infer, value, span);
+    }
+    call(fn, args, span) {
+        return this.mark({ e: 'call', fn, args }, span);
+    }
+    /** A lambda from a surface expression: `fun x => e`, a section, or the name of a function (eta-expanded). */
+    lambda(e, ctx) {
+        if (e.t === 'fun')
+            return this.tr(e, ctx);
+        const depth = ctx.depth ?? 0;
+        const x = `x${depth}`;
+        const inner = { ...ctx, scope: new Map(ctx.scope).set(x, x), depth: depth + 1 };
+        const call = this.tr({ t: 'app', fn: e, args: [{ value: { t: 'name', name: x, span: e.span } }], span: e.span }, inner);
+        return this.mark({ e: 'fn', params: [{ name: x }], body: call }, e.span);
+    }
+    tr(e, ctx) {
+        const span = e.span;
+        const tail = { effects: ctx.effects, decision: ctx.decision };
+        const inner = { ...ctx, effects: undefined, decision: undefined };
+        switch (e.t) {
+            case 'num': return this.lit(T.nat, e.value, span);
+            case 'str': return this.lit(T.string, e.value, span);
+            case 'bool': return this.lit(T.bool, e.value, span);
+            case 'ctor': return this.hole(e.name, span);
+            case 'unit': return this.lit(T.unit, null, span);
+            case 'nothing':
+                if (!ctx.effects)
+                    fail('`nothing` is an effect, returned by hooks', span);
+                return this.mark({ e: 'effect' }, span);
+            case 'param': return this.mark({ e: 'param', name: e.name }, span);
+            case 'name': return this.name(e.name, span, ctx);
+            case 'proj': return this.projection(this.tr(e.on, inner), e.field, [], span, inner);
+            case 'app': return this.app(e, inner);
+            case 'binop': {
+                if (e.op === '∧' || e.op === '∨') {
+                    const parts = flatten(e, e.op).map(x => this.tr(x, inner));
+                    return this.call(e.op === '∧' ? 'and' : 'or', parts, span);
+                }
+                const [l, r] = [this.tr(e.l, inner), this.tr(e.r, inner)];
+                if (e.op === '++')
+                    return this.call(isStringy(e.l) || isStringy(e.r) ? 'concat' : 'append', [l, r], span);
+                return this.call(BINOPS[e.op] ?? fail(`unknown operator ${e.op}`, span), [l, r], span);
+            }
+            case 'unop': {
+                if (e.op === '-' && e.e.t === 'num')
+                    return this.lit(T.int, -e.e.value, span);
+                if (e.op === '-')
+                    return fail('negation applies to number literals', span);
+                return this.call('not', [this.tr(e.e, inner)], span);
+            }
+            case 'if':
+                return this.mark({ e: 'if', cond: this.tr(e.cond, inner), then: this.tr(e.then, ctx), else: this.tr(e.else, ctx) }, span);
+            case 'let': {
+                const value = this.tr(e.value, { ...inner, letName: e.name });
+                const body = this.tr(e.body, { ...ctx, scope: new Map(ctx.scope).set(e.name, e.name) });
+                return this.mark({ e: 'let', name: e.name, value, body }, span);
+            }
+            case 'match': {
+                const cases = {};
+                let otherwise;
+                for (const c of e.cases) {
+                    const body = this.tr(c.body, ctx);
+                    if (c.pat.t === 'wild')
+                        otherwise = body;
+                    else if (c.pat.t === 'ctor')
+                        cases[c.pat.name.split('.').pop()] = body;
+                    else
+                        fail('only constructors and _ can be matched for now', c.pat.span);
+                }
+                return this.mark({ e: 'match', on: this.tr(e.on, inner), cases, ...(otherwise ? { else: otherwise } : {}) }, span);
+            }
+            case 'fun': {
+                const scope = new Map(ctx.scope);
+                const depth = ctx.depth ?? 0;
+                const params = e.params.map(p => {
+                    const n = p.name === '·' ? `x${depth}` : p.name;
+                    scope.set(p.name, n);
+                    return p.type ? { name: n, type: this.type(p.type) } : { name: n };
+                });
+                return this.mark({ e: 'fn', params, body: this.tr(e.body, { ...inner, scope, depth: depth + 1 }) }, span);
+            }
+            case 'list':
+                return e.items.length ? this.call('list', e.items.map(i => this.tr(i, inner)), span) : this.hole([], span);
+            case 'record':
+                return this.record(e, ctx, tail);
+            case 'choose': {
+                const from = this.tr(e.from, inner);
+                const site = `${ctx.owner}.${ctx.letName ?? 'choice'}`;
+                const such = e.such && this.lambda(e.such, inner);
+                let label;
+                if (e.labels?.t === 'list') {
+                    if (e.from.t !== 'list')
+                        fail('a list of labels needs a list of options: give a function instead', e.labels.span);
+                    const x = `x${inner.depth ?? 0}`;
+                    const lctx = { ...inner, scope: new Map(inner.scope).set(x, x), depth: (inner.depth ?? 0) + 1 };
+                    const options = e.from.items;
+                    const labels = e.labels.items;
+                    let body = this.lit(T.string, '', e.labels.span);
+                    for (let k = options.length - 1; k >= 0; k--) {
+                        const cond = this.call('eq', [this.mark({ e: 'var', name: x }, span), this.tr(options[k], lctx)], span);
+                        body = this.mark({ e: 'if', cond, then: this.tr(labels[k], lctx), else: body }, span);
+                    }
+                    label = this.mark({ e: 'fn', params: [{ name: x }], body }, e.labels.span);
+                }
+                else if (e.labels) {
+                    label = this.lambda(e.labels, inner);
+                }
+                return this.mark({ e: 'choose', site, from, ...(such ? { such } : {}), ...(label ? { label } : {}) }, span);
+            }
+            case 'ascribe': {
+                const x = this.tr(e.e, inner);
+                if (x.e === 'lit' && x.type.k === 'infer')
+                    return this.lit(this.type(e.type), x.value, span);
+                return x;
+            }
+            case 'hole': return fail('· is only allowed inside parentheses', span);
+            case 'typeValue': return fail('a type is not a value', span);
+            case 'flag':
+            case 'action': return fail(`${e.t} declarations belong to components`, span);
+        }
+    }
+    record(e, ctx, tail) {
+        const span = e.span;
+        const inner = { ...ctx, effects: undefined, decision: undefined };
+        const fieldsOf = (items, c) => {
+            const out = {};
+            for (const it of items) {
+                if (it.t !== 'field')
+                    fail('`raise` only appears in an effect', it.span);
+                const f = it;
+                out[f.name] = this.tr(f.value ?? { t: 'name', name: f.name, span: f.span }, { ...c, letName: f.name });
+            }
+            return out;
+        };
+        if (tail.effects && !e.base) {
+            // An effect: `{ world := { C.world with f := v }, raise flag := agents or predicate }`.
+            const world = {};
+            const raise = {};
+            for (const it of e.items) {
+                if (it.t === 'raise') {
+                    const v = it.value;
+                    raise[it.flag] = this.tr(v, inner);
+                }
+                else if (it.name === 'world') {
+                    const w = it.value;
+                    if (!w || w.t !== 'record' || !w.base)
+                        fail('world := { C.world with f := v, ... }', it.span);
+                    Object.assign(world, fieldsOf(w.items, inner));
+                }
+                else {
+                    fail(`an effect has \`world :=\` and \`raise flag :=\`, not ${it.name}`, it.span);
+                }
+            }
+            return this.mark({ e: 'effect', ...(Object.keys(world).length ? { world } : {}), ...(Object.keys(raise).length ? { raise } : {}) }, span);
+        }
+        if (e.base)
+            return this.mark({ e: 'with', on: this.tr(e.base, inner), fields: fieldsOf(e.items, inner) }, span);
+        const fields = fieldsOf(e.items, inner);
+        if (tail.decision) {
+            // A decision keeps the public state and the memory unless it sets them.
+            fields.pub ??= this.mark({ e: 'var', name: tail.decision.pub }, span);
+            fields.mem ??= this.mark({ e: 'var', name: tail.decision.mem }, span);
+            if (!fields.move)
+                fail('a decision needs a move', span);
+        }
+        return this.mark({ e: 'record', fields }, span);
+    }
+    /** A possibly dotted name: a local with projections, a parameter, a constructor, or a definition. */
+    name(full, span, ctx) {
+        const parts = full.split('.');
+        for (let n = parts.length; n >= 1; n--) {
+            const head = parts.slice(0, n).join('.');
+            const local = ctx.scope.get(head);
+            const constant = ctx.constants?.get(head);
+            const param = n === 1 && local === undefined && ctx.params.has(head);
+            if (local !== undefined || constant || param) {
+                let e = constant ? this.mark({ ...constant }, span)
+                    : param ? this.mark({ e: 'param', name: head }, span)
+                        : this.mark({ e: 'var', name: local }, span);
+                for (const f of parts.slice(n))
+                    e = this.projection(e, f, [], span, ctx);
+                return e;
+            }
+        }
+        if (full === 'none')
+            return this.hole(null, span);
+        if (full === 'frames')
+            return this.call('frames', [], span);
+        if (parts.length >= 2) {
+            const enumName = parts.slice(0, -1).join('.');
+            const t = enumName === 'Move' ? T.move : enumName === 'Verdict' ? T.verdict : this.enums.get(enumName);
+            if (t) {
+                const ctor = parts[parts.length - 1];
+                const ctors = t.k === 'enum' ? t.ctors : t.k === 'move' ? ['stay', 'cw', 'ccw'] : ['success', 'failure', 'inProgress'];
+                if (!ctors.includes(ctor))
+                    fail(`${ctor} is not a constructor of ${enumName}`, span);
+                return this.lit(t, ctor, span);
+            }
+        }
+        if (BUILTIN_FUNCTIONS.has(full))
+            return fail(`${full} needs arguments`, span);
+        const g = this.globals.get(full);
+        if (isObjectDef(g)) {
+            if (g.params.length)
+                fail(`${full} needs ${g.params.length} argument(s)`, span);
+            this.useDef(g, span);
+            return this.call(full, [], span);
+        }
+        return fail(`unknown name ${full}`, span);
+    }
+    /** `e.f`, with methods of collections, options, configurations and moves. */
+    projection(on, field, args, span, ctx) {
+        const rest = args.map((a, i) => COLLECTION_METHODS_WITH_FN.has(field) && i === 0 ? this.lambda(a.value, ctx) : this.tr(a.value, ctx));
+        const noArgs = () => { if (args.length)
+            fail(`${field} takes no arguments`, span); };
+        switch (field) {
+            case 'length':
+            case 'card':
+                noArgs();
+                return this.call('length', [on], span);
+            case 'isEmpty':
+            case 'sum':
+            case 'isSome':
+            case 'isNone':
+            case 'toMultiset':
+            case 'toList':
+            case 'dedup':
+                noArgs();
+                return this.call(field, [on], span);
+            case 'opposite':
+                noArgs();
+                return this.call('opposite', [on], span);
+            case 'size':
+            case 'nodes':
+            case 'agents':
+                // On the configuration (always `C` in IR): builtins.
+                if (on.e === 'var' && on.name === 'C') {
+                    noArgs();
+                    return this.call(field, [on], span);
+                }
+                break;
+            case 'filter':
+            case 'map':
+            case 'any':
+            case 'all':
+            case 'count':
+            case 'getD':
+            case 'diff':
+            case 'at':
+                if (rest.length !== 1)
+                    fail(`${field} takes one argument`, span);
+                return this.call(field, [on, ...rest], span);
+            case 'contains':
+                if (rest.length !== 1)
+                    fail('contains takes one argument', span);
+                return this.call('mem', [rest[0], on], span);
+        }
+        if (args.length)
+            fail(`${field} is a field, not a function`, span);
+        const output = ctx.outputs?.get(field);
+        if (output) {
+            // An output of the algorithm, read on an agent: its definition, with the agent's state.
+            const constants = new Map([['pub', { e: 'get', on, field: 'pub' }], ['mem', { e: 'get', on, field: 'mem' }]]);
+            return this.tr(output, { scope: new Map(), params: new Set(), owner: ctx.owner, constants });
+        }
+        return this.mark({ e: 'get', on, field }, span);
+    }
+    app(e, ctx) {
+        const span = e.span;
+        if (e.args.some(a => a.name))
+            fail('named arguments are only for definitions of models and components', span);
+        // `x.method args`: the last part of a dotted name, or a projection.
+        if (e.fn.t === 'proj')
+            return this.projection(this.tr(e.fn.on, ctx), e.fn.field, e.args, span, ctx);
+        if (e.fn.t === 'name') {
+            const name = e.fn.name;
+            const parts = name.split('.');
+            if (parts.length > 1 && !this.globals.has(name)) {
+                const recv = this.name(parts.slice(0, -1).join('.'), e.fn.span, ctx);
+                return this.projection(recv, parts[parts.length - 1], e.args, span, ctx);
+            }
+            if (BUILTIN_FUNCTIONS.has(name)) {
+                const fnArgs = FUNCTION_ARGS[name] ?? [];
+                const args = e.args.map((a, i) => fnArgs.includes(i) ? this.lambda(a.value, ctx) : this.tr(a.value, ctx));
+                // `subsetsUpTo k xs`, as in the syntax document; the IR takes the collection first.
+                if (name === 'subsetsUpTo' && args.length === 2)
+                    args.reverse();
+                return this.call(name, args, span);
+            }
+            const local = ctx.scope.get(name);
+            if (local !== undefined)
+                fail(`${name} is not a function`, span);
+            const g = this.globals.get(name);
+            if (isObjectDef(g)) {
+                if (e.args.length !== g.params.length)
+                    fail(`${name} takes ${g.params.length} argument(s)`, span);
+                this.useDef(g, span);
+                return this.call(name, e.args.map(a => this.tr(a.value, ctx)), span);
+            }
+        }
+        return fail('unknown function', e.fn.span);
+    }
+}
+function runtimeBinder(t) {
+    if (t.t !== 'name')
+        return undefined;
+    return { Config: 'C', Agent: 'me', Frame: 'frame' }[t.name];
+}
+function flatten(e, op) {
+    return e.t === 'binop' && e.op === op ? [...flatten(e.l, op), ...flatten(e.r, op)] : [e];
+}
+function isStringy(e) {
+    return e.t === 'str' || (e.t === 'app' && e.fn.t === 'name' && e.fn.name === 'show') || (e.t === 'binop' && e.op === '++' && (isStringy(e.l) || isStringy(e.r)));
+}
+function stripType(v) {
+    return v.m === 'enum' ? { m: 'enum', ctor: v.ctor, type: v.type.name } : v;
+}
+function dropUndefined(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, x]) => x !== undefined));
+}
+/** Compiles the experiments of an entry module. */
+export function compile(program) {
+    const elab = new Elaborator(program);
+    const experiments = {};
+    for (const name of elab.experiments())
+        experiments[name] = elab.experiment(name);
+    return { experiments, diagnostics: elab.diagnostics };
+}