willfire 0.1.12 → 0.1.14

package/dist/cli/parseArgs.js

@@ -27,8 +27,9 @@ export function parseArgs(argv) {
     // execution the caller thought they asked for.
     const execute = [];
     for (let i = 0; i < argv.length; i++) {
-        if (argv[i] !== "--execute")
+        if (argv[i] !== "--execute") {
             continue;
+        }
         const spec = argv[i + 1];
         const grant = spec == null ? null : parseGrant(spec);
         if (grant == null) {

package/dist/cli.js

@@ -25,8 +25,9 @@ if (isMain) {
         }
         else {
             for (const e of entries) {
-                if (isWorkflowEntry(e))
+                if (isWorkflowEntry(e)) {
                     console.log(`# ${e.workflow} :: ${e.status} (${e.reason})`);
+                }
                 else {
                     const name = e.checkName ?? `${e.job} (name unresolved)`;
                     console.log(`${e.workflow} :: ${name} :: ${e.status}`);
@@ -35,7 +36,8 @@ if (isMain) {
         }
         // Last, and on the skip path too, so a red gate's first question — which
         // commits was this read from? — is answered wherever the reader lands.
-        for (const s of sources)
+        for (const s of sources) {
             console.log(`# read ${s.owner}/${s.repo}@${s.ref} -> ${s.sha}`);
+        }
     }
 }

package/dist/execute.d.ts

@@ -29,7 +29,7 @@
  * already satisfied by materializing the tree. A bare checkout is therefore
  * recorded as done; a checkout *with inputs* is not modelled and stops.
  */
-import { type Scope } from "./expr.js";
+import { type Scope } from "./expr/val.js";
 import type { ResolveRef, WorkflowSource } from "./types.js";
 /**
  * Permission to execute named jobs from one repo's workflows.

package/dist/execute.js

@@ -34,7 +34,9 @@ import { mkdir, mkdtemp, readdir, readFile, stat, writeFile } from "node:fs/prom
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { evaluate, evaluateValue, UNKNOWN } from "./expr.js";
+import { evaluate } from "./expr/evaluate.js";
+import { evaluateValue } from "./expr/evaluateValue.js";
+import { UNKNOWN } from "./expr/val.js";
 /** `owner/repo:job1,job2` as the CLI spells a grant. */
 export function parseGrant(spec) {
     const colon = spec.indexOf(":");

package/dist/expr/applyFunction.d.ts

@@ -0,0 +1,11 @@
+import { type Val } from "./val.js";
+/**
+ * The functions worth modelling.
+ *
+ * `always()` is true by definition. `contains` on two known strings is the one
+ * that unlocks the fleet's `gates` pattern. `fromJSON` is what a dynamic matrix
+ * axis is built out of. `success()`, `failure()` and `cancelled()` depend on
+ * jobs that have not run, and everything else is simply not modelled — all
+ * unknown.
+ */
+export declare function applyFunction(name: string, args: Val[]): Val;

package/dist/expr/applyFunction.js

@@ -0,0 +1,41 @@
+import { asBool } from "./asBool.js";
+import { fromJson } from "./fromJson.js";
+import { UNKNOWN } from "./val.js";
+/**
+ * The functions worth modelling.
+ *
+ * `always()` is true by definition. `contains` on two known strings is the one
+ * that unlocks the fleet's `gates` pattern. `fromJSON` is what a dynamic matrix
+ * axis is built out of. `success()`, `failure()` and `cancelled()` depend on
+ * jobs that have not run, and everything else is simply not modelled — all
+ * unknown.
+ */
+export function applyFunction(name, args) {
+    if (name === "always") {
+        return { kind: "value", v: true };
+    }
+    if (name === "fromjson" && args.length === 1) {
+        return fromJson(args[0]);
+    }
+    if (name === "contains" && args.length === 2) {
+        const [hay, needle] = args;
+        if (hay.kind !== "value" || needle.kind !== "value") {
+            return UNKNOWN;
+        }
+        if (typeof hay.v !== "string" || typeof needle.v !== "string") {
+            return UNKNOWN;
+        }
+        return asBool(hay.v.includes(needle.v));
+    }
+    if ((name === "startswith" || name === "endswith") && args.length === 2) {
+        const [s, part] = args;
+        if (s.kind !== "value" || part.kind !== "value") {
+            return UNKNOWN;
+        }
+        if (typeof s.v !== "string" || typeof part.v !== "string") {
+            return UNKNOWN;
+        }
+        return asBool(name === "startswith" ? s.v.startsWith(part.v) : s.v.endsWith(part.v));
+    }
+    return UNKNOWN;
+}

package/dist/expr/asBool.d.ts

@@ -0,0 +1,10 @@
+import { type Val } from "./val.js";
+/**
+ * Wrap a decided answer as a concrete boolean value.
+ *
+ * Comparison, negation and the string functions all yield a real boolean, so
+ * they produce a `value` — which keeps `!x == true` comparable. Only
+ * short-circuiting produces the bare `truthy`/`falsy` points, because that is
+ * the one case where truthiness is known and the value is not.
+ */
+export declare function asBool(b: boolean | null): Val;

package/dist/expr/asBool.js

@@ -0,0 +1,12 @@
+import { UNKNOWN } from "./val.js";
+/**
+ * Wrap a decided answer as a concrete boolean value.
+ *
+ * Comparison, negation and the string functions all yield a real boolean, so
+ * they produce a `value` — which keeps `!x == true` comparable. Only
+ * short-circuiting produces the bare `truthy`/`falsy` points, because that is
+ * the one case where truthiness is known and the value is not.
+ */
+export function asBool(b) {
+    return b === null ? UNKNOWN : { kind: "value", v: b };
+}

package/dist/expr/coalesceAnd.d.ts

@@ -0,0 +1,7 @@
+import { type Val } from "./val.js";
+/**
+ * `A && B`. Short-circuits from either side: a falsy left decides it, and so
+ * does a falsy right, because a truthy left would then yield the falsy right.
+ * Only "left unknown, right not falsy" is genuinely undecided.
+ */
+export declare function coalesceAnd(left: Val, right: Val): Val;

package/dist/expr/coalesceAnd.js

@@ -0,0 +1,17 @@
+import { truthy } from "./truthy.js";
+import { UNKNOWN } from "./val.js";
+/**
+ * `A && B`. Short-circuits from either side: a falsy left decides it, and so
+ * does a falsy right, because a truthy left would then yield the falsy right.
+ * Only "left unknown, right not falsy" is genuinely undecided.
+ */
+export function coalesceAnd(left, right) {
+    const l = truthy(left);
+    if (l === false) {
+        return left;
+    }
+    if (l === true) {
+        return right;
+    }
+    return truthy(right) === false ? { kind: "falsy" } : UNKNOWN;
+}

package/dist/expr/coalesceOr.d.ts

@@ -0,0 +1,6 @@
+import { type Val } from "./val.js";
+/**
+ * `A || B`. The mirror image: a truthy left decides it, and so does a truthy
+ * right, since a falsy left would then yield the truthy right.
+ */
+export declare function coalesceOr(left: Val, right: Val): Val;

package/dist/expr/coalesceOr.js

@@ -0,0 +1,16 @@
+import { truthy } from "./truthy.js";
+import { UNKNOWN } from "./val.js";
+/**
+ * `A || B`. The mirror image: a truthy left decides it, and so does a truthy
+ * right, since a falsy left would then yield the truthy right.
+ */
+export function coalesceOr(left, right) {
+    const l = truthy(left);
+    if (l === true) {
+        return left;
+    }
+    if (l === false) {
+        return right;
+    }
+    return truthy(right) === true ? { kind: "truthy" } : UNKNOWN;
+}

package/dist/expr/compare.d.ts

@@ -0,0 +1,12 @@
+import { type Val } from "./val.js";
+/**
+ * Comparison, deliberately narrow: both sides must be concrete and of the same
+ * primitive type.
+ *
+ * GitHub coerces across types when it compares, and the corner cases are
+ * genuinely surprising (`'' == 0` is true). Every comparison that matters in
+ * practice is string-to-string — `inputs.gates == ''`,
+ * `github.event_name == 'pull_request'` — so modelling the coercion table
+ * would add risk without adding reach. Mixed types return unknown.
+ */
+export declare function compare(op: string, left: Val, right: Val): Val;

package/dist/expr/compare.js

@@ -0,0 +1,54 @@
+import { asBool } from "./asBool.js";
+import { UNKNOWN } from "./val.js";
+/**
+ * Comparison, deliberately narrow: both sides must be concrete and of the same
+ * primitive type.
+ *
+ * GitHub coerces across types when it compares, and the corner cases are
+ * genuinely surprising (`'' == 0` is true). Every comparison that matters in
+ * practice is string-to-string — `inputs.gates == ''`,
+ * `github.event_name == 'pull_request'` — so modelling the coercion table
+ * would add risk without adding reach. Mixed types return unknown.
+ */
+export function compare(op, left, right) {
+    // GitHub compares arrays and objects by instance, and two written sides are
+    // never the same instance: `==` is false, `!=` is true, ordering unknowable.
+    if (left.kind === "json" || right.kind === "json") {
+        if (op === "==") {
+            return asBool(false);
+        }
+        if (op === "!=") {
+            return asBool(true);
+        }
+        return UNKNOWN;
+    }
+    if (left.kind !== "value" || right.kind !== "value") {
+        return UNKNOWN;
+    }
+    const a = left.v;
+    const b = right.v;
+    if (typeof a !== typeof b) {
+        return UNKNOWN;
+    }
+    if (op === "==") {
+        return asBool(a === b);
+    }
+    if (op === "!=") {
+        return asBool(a !== b);
+    }
+    // Ordering on booleans is not modelled. GitHub coerces them to numbers, and
+    // the answer is never one a workflow author meant to ask for.
+    if (typeof a === "boolean" || typeof b === "boolean") {
+        return UNKNOWN;
+    }
+    if (op === "<") {
+        return asBool(a < b);
+    }
+    if (op === "<=") {
+        return asBool(a <= b);
+    }
+    if (op === ">") {
+        return asBool(a > b);
+    }
+    return asBool(a >= b);
+}

package/dist/expr/cursor.d.ts

@@ -0,0 +1,11 @@
+import type { Tok } from "./tokenize.js";
+/** A read position over a token stream, shared by the parse functions. */
+export declare class Cursor {
+    private readonly toks;
+    private pos;
+    constructor(toks: Tok[]);
+    peek(): Tok | undefined;
+    advance(): void;
+    eatOp(v: string): boolean;
+    done(): boolean;
+}

package/dist/expr/cursor.js

@@ -0,0 +1,25 @@
+/** A read position over a token stream, shared by the parse functions. */
+export class Cursor {
+    toks;
+    pos = 0;
+    constructor(toks) {
+        this.toks = toks;
+    }
+    peek() {
+        return this.toks[this.pos];
+    }
+    advance() {
+        this.pos++;
+    }
+    eatOp(v) {
+        const t = this.peek();
+        if (t != null && t.t === "op" && t.v === v) {
+            this.pos++;
+            return true;
+        }
+        return false;
+    }
+    done() {
+        return this.pos >= this.toks.length;
+    }
+}

package/dist/expr/evaluate.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "./val.js";
+/** Evaluate a condition to a truthiness, or null when it cannot be settled. */
+export declare function evaluate(cond: string, scope?: Scope): boolean | null;

package/dist/expr/evaluate.js

@@ -0,0 +1,6 @@
+import { evaluateValue } from "./evaluateValue.js";
+import { truthy } from "./truthy.js";
+/** Evaluate a condition to a truthiness, or null when it cannot be settled. */
+export function evaluate(cond, scope = {}) {
+    return truthy(evaluateValue(cond, scope));
+}

package/dist/expr/evaluateValue.d.ts

@@ -0,0 +1,14 @@
+import { type Scope, type Val } from "./val.js";
+/**
+ * Evaluate an expression to a value, or UNKNOWN when it cannot be settled.
+ *
+ * The `${{ }}` wrapper is optional in `if:` and stripped when present. An
+ * expression that is only *partly* wrapped (`foo ${{ bar }} baz`) is a string
+ * interpolation rather than an expression, and is not modelled.
+ *
+ * A `if:` wants {@link evaluate}, which is this narrowed to truthiness. This
+ * one is for the places that need the value itself — a matrix axis written as
+ * `${{ fromJSON(...) }}` is an array, and its truthiness says nothing about
+ * how many jobs it schedules.
+ */
+export declare function evaluateValue(expr: string, scope?: Scope): Val;

package/dist/expr/evaluateValue.js

@@ -0,0 +1,37 @@
+import { Cursor } from "./cursor.js";
+import { parseOr } from "./parseOr.js";
+import { tokenize } from "./tokenize.js";
+import { UNKNOWN } from "./val.js";
+/**
+ * Evaluate an expression to a value, or UNKNOWN when it cannot be settled.
+ *
+ * The `${{ }}` wrapper is optional in `if:` and stripped when present. An
+ * expression that is only *partly* wrapped (`foo ${{ bar }} baz`) is a string
+ * interpolation rather than an expression, and is not modelled.
+ *
+ * A `if:` wants {@link evaluate}, which is this narrowed to truthiness. This
+ * one is for the places that need the value itself — a matrix axis written as
+ * `${{ fromJSON(...) }}` is an array, and its truthiness says nothing about
+ * how many jobs it schedules.
+ */
+export function evaluateValue(expr, scope = {}) {
+    const stripped = expr.trim().replace(/^\$\{\{(.*)\}\}$/s, "$1").trim();
+    if (stripped === "") {
+        return UNKNOWN;
+    }
+    if (stripped.includes("${{")) {
+        return UNKNOWN;
+    }
+    const toks = tokenize(stripped);
+    if (toks == null || toks.length === 0) {
+        return UNKNOWN;
+    }
+    const cur = new Cursor(toks);
+    const val = parseOr(cur, scope);
+    // Trailing tokens mean the grammar did not cover this expression; whatever
+    // was parsed describes only a prefix of it, so it decides nothing.
+    if (!cur.done()) {
+        return UNKNOWN;
+    }
+    return val;
+}

package/dist/expr/fromJson.d.ts

@@ -0,0 +1,11 @@
+import { type Val } from "./val.js";
+/**
+ * `fromJSON(s)` on a known string.
+ *
+ * The result is sorted into the lattice rather than dropped in whole: a scalar
+ * is an ordinary value and stays comparable, `null` has a known truthiness and
+ * no useful value, and only an array or an object needs the `json` point.
+ * Anything unparseable is unknown — a workflow that reaches this at runtime
+ * fails, and predicting a failure is not this function's job.
+ */
+export declare function fromJson(arg: Val): Val;

package/dist/expr/fromJson.js

@@ -0,0 +1,29 @@
+import { UNKNOWN } from "./val.js";
+/**
+ * `fromJSON(s)` on a known string.
+ *
+ * The result is sorted into the lattice rather than dropped in whole: a scalar
+ * is an ordinary value and stays comparable, `null` has a known truthiness and
+ * no useful value, and only an array or an object needs the `json` point.
+ * Anything unparseable is unknown — a workflow that reaches this at runtime
+ * fails, and predicting a failure is not this function's job.
+ */
+export function fromJson(arg) {
+    if (arg.kind !== "value" || typeof arg.v !== "string") {
+        return UNKNOWN;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(arg.v);
+    }
+    catch {
+        return UNKNOWN;
+    }
+    if (parsed === null) {
+        return { kind: "falsy" };
+    }
+    if (typeof parsed === "object") {
+        return { kind: "json", v: parsed };
+    }
+    return { kind: "value", v: parsed };
+}

package/dist/expr/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A tri-state evaluator for the slice of GitHub expressions that job `if:`
+ * conditions actually use.
+ *
+ * The point is not to reimplement the expression language. It is to stop
+ * returning `unknown` for conditions that are already decided. A reusable
+ * workflow's jobs commonly guard on the caller's own literals:
+ *
+ *     if: ${{ github.event_name == 'pull_request'
+ *             && (inputs.gates == '' || contains(inputs.gates, '"mutation"'))
+ *             && (needs.detect.outputs.mutation_languages || ...) != '[]' }}
+ *
+ * The last clause needs a job that has not run yet. The middle one does not:
+ * the caller passed `gates` as a literal string, and it does not contain
+ * `"mutation"`, so the clause is false, so the whole `&&` is false whatever
+ * `detect` reports. Deciding that is the difference between a predictable
+ * check name and a hole in the prediction.
+ *
+ * Two ideas carry the whole module:
+ *
+ * 1. **Truthiness can be known when the value is not.** `A && B` with an
+ *    unknown `A` and a false `B` is false either way. So the lattice has four
+ *    points, not three: a concrete value, known-truthy, known-falsy, and
+ *    nothing at all.
+ *
+ * 2. **Unrecognized is unknown, never a guess.** An unparseable condition, an
+ *    unsupported function, a comparison between types we do not model — all
+ *    collapse to `unknown` and leave the caller exactly where it was. This
+ *    adds no tolerance and no third outcome; it converts conditions that are
+ *    already decidable into the answer they already have.
+ */
+export { evaluate } from "./evaluate.js";
+export { evaluateValue } from "./evaluateValue.js";
+export { UNKNOWN } from "./val.js";
+export type { Scope, Val } from "./val.js";

package/dist/expr/index.js

@@ -0,0 +1,34 @@
+/**
+ * A tri-state evaluator for the slice of GitHub expressions that job `if:`
+ * conditions actually use.
+ *
+ * The point is not to reimplement the expression language. It is to stop
+ * returning `unknown` for conditions that are already decided. A reusable
+ * workflow's jobs commonly guard on the caller's own literals:
+ *
+ *     if: ${{ github.event_name == 'pull_request'
+ *             && (inputs.gates == '' || contains(inputs.gates, '"mutation"'))
+ *             && (needs.detect.outputs.mutation_languages || ...) != '[]' }}
+ *
+ * The last clause needs a job that has not run yet. The middle one does not:
+ * the caller passed `gates` as a literal string, and it does not contain
+ * `"mutation"`, so the clause is false, so the whole `&&` is false whatever
+ * `detect` reports. Deciding that is the difference between a predictable
+ * check name and a hole in the prediction.
+ *
+ * Two ideas carry the whole module:
+ *
+ * 1. **Truthiness can be known when the value is not.** `A && B` with an
+ *    unknown `A` and a false `B` is false either way. So the lattice has four
+ *    points, not three: a concrete value, known-truthy, known-falsy, and
+ *    nothing at all.
+ *
+ * 2. **Unrecognized is unknown, never a guess.** An unparseable condition, an
+ *    unsupported function, a comparison between types we do not model — all
+ *    collapse to `unknown` and leave the caller exactly where it was. This
+ *    adds no tolerance and no third outcome; it converts conditions that are
+ *    already decidable into the answer they already have.
+ */
+export { evaluate } from "./evaluate.js";
+export { evaluateValue } from "./evaluateValue.js";
+export { UNKNOWN } from "./val.js";

package/dist/expr/indexVal.d.ts

@@ -0,0 +1,7 @@
+import { type Val } from "./val.js";
+/**
+ * `a[i]` on what `fromJSON` produced. GitHub yields `null` for a missing
+ * index, which models as the empty string — the coercion GitHub applies.
+ * Anything off that path is unknown, never a guess.
+ */
+export declare function indexVal(base: Val, idx: Val): Val;

package/dist/expr/indexVal.js

@@ -0,0 +1,34 @@
+import { UNKNOWN } from "./val.js";
+/**
+ * `a[i]` on what `fromJSON` produced. GitHub yields `null` for a missing
+ * index, which models as the empty string — the coercion GitHub applies.
+ * Anything off that path is unknown, never a guess.
+ */
+export function indexVal(base, idx) {
+    if (base.kind !== "json") {
+        return UNKNOWN;
+    }
+    if (idx.kind !== "value") {
+        return UNKNOWN;
+    }
+    let el;
+    if (Array.isArray(base.v)) {
+        if (typeof idx.v !== "number") {
+            return UNKNOWN;
+        }
+        el = base.v[idx.v];
+    }
+    else {
+        if (typeof idx.v !== "string") {
+            return UNKNOWN;
+        }
+        el = base.v[idx.v];
+    }
+    if (el == null) {
+        return { kind: "value", v: "" };
+    }
+    if (typeof el === "object") {
+        return { kind: "json", v: el };
+    }
+    return { kind: "value", v: el };
+}

package/dist/expr/lookup.d.ts

@@ -0,0 +1,2 @@
+import { type Scope, type Val } from "./val.js";
+export declare function lookup(scope: Scope, path: string): Val;

package/dist/expr/lookup.js

@@ -0,0 +1,51 @@
+import { UNKNOWN } from "./val.js";
+export function lookup(scope, path) {
+    const dot = path.indexOf(".");
+    if (dot < 0) {
+        return UNKNOWN;
+    }
+    const head = path.slice(0, dot);
+    const rest = path.slice(dot + 1);
+    if (head === "inputs") {
+        return scope.inputs?.[rest] ?? UNKNOWN;
+    }
+    if (head === "github") {
+        const v = scope.github?.[rest];
+        return v === undefined ? UNKNOWN : { kind: "value", v };
+    }
+    if (head === "needs") {
+        // Only `needs.<job>.outputs.<name>` is modelled. `needs.<job>.result`
+        // is a verdict on a run that has not happened; anything else is not a
+        // shape the context has.
+        const parts = rest.split(".");
+        if (parts.length !== 3 || parts[1] !== "outputs") {
+            return UNKNOWN;
+        }
+        const job = scope.needs?.[parts[0]];
+        if (job == null) {
+            return UNKNOWN;
+        }
+        // A known job's missing output is the empty string, not a hole: the
+        // caller promised the set is complete, and that is what the runner
+        // substitutes for an output no step wrote.
+        return { kind: "value", v: job.outputs[parts[2]] ?? "" };
+    }
+    if (head === "steps") {
+        // The same shape as `needs`, for the same reason: only
+        // `steps.<id>.outputs.<name>` is modelled. `steps.<id>.outcome` and
+        // `.conclusion` are verdicts on how a step ran, which the executor does
+        // not track — a failed step fails the whole execution instead.
+        const parts = rest.split(".");
+        if (parts.length !== 3 || parts[1] !== "outputs") {
+            return UNKNOWN;
+        }
+        const step = scope.steps?.[parts[0]];
+        if (step == null) {
+            return UNKNOWN;
+        }
+        return { kind: "value", v: step.outputs[parts[2]] ?? "" };
+    }
+    // `matrix.*`, `env.*`, `vars.*`, `secrets.*`: all require something that
+    // has not happened yet at prediction time.
+    return UNKNOWN;
+}

package/dist/expr/negate.d.ts

@@ -0,0 +1 @@
+export declare function negate(b: boolean | null): boolean | null;

package/dist/expr/negate.js

@@ -0,0 +1,3 @@
+export function negate(b) {
+    return b === null ? null : !b;
+}

package/dist/expr/parseAnd.d.ts

@@ -0,0 +1,3 @@
+import type { Cursor } from "./cursor.js";
+import type { Scope, Val } from "./val.js";
+export declare function parseAnd(cur: Cursor, scope: Scope): Val;

package/dist/expr/parseAnd.js

@@ -0,0 +1,10 @@
+import { coalesceAnd } from "./coalesceAnd.js";
+import { parseCmp } from "./parseCmp.js";
+export function parseAnd(cur, scope) {
+    let left = parseCmp(cur, scope);
+    while (cur.eatOp("&&")) {
+        const right = parseCmp(cur, scope);
+        left = coalesceAnd(left, right);
+    }
+    return left;
+}

package/dist/expr/parseAtom.d.ts

@@ -0,0 +1,3 @@
+import type { Cursor } from "./cursor.js";
+import { type Scope, type Val } from "./val.js";
+export declare function parseAtom(cur: Cursor, scope: Scope): Val;

package/dist/expr/parseAtom.js

@@ -0,0 +1,43 @@
+import { lookup } from "./lookup.js";
+import { parseCall } from "./parseCall.js";
+import { parseOr } from "./parseOr.js";
+import { UNKNOWN } from "./val.js";
+export function parseAtom(cur, scope) {
+    const t = cur.peek();
+    if (t == null) {
+        return UNKNOWN;
+    }
+    if (t.t === "op" && t.v === "(") {
+        cur.advance();
+        const v = parseOr(cur, scope);
+        if (!cur.eatOp(")")) {
+            return UNKNOWN;
+        }
+        return v;
+    }
+    if (t.t === "str") {
+        cur.advance();
+        return { kind: "value", v: t.v };
+    }
+    if (t.t === "num") {
+        cur.advance();
+        return { kind: "value", v: t.v };
+    }
+    if (t.t === "bool") {
+        cur.advance();
+        return { kind: "value", v: t.v };
+    }
+    if (t.t === "null") {
+        cur.advance();
+        return { kind: "value", v: "" };
+    }
+    if (t.t === "path") {
+        cur.advance();
+        // A `(` right after a name makes it a call, not a path.
+        if (cur.eatOp("(")) {
+            return parseCall(cur, scope, t.v);
+        }
+        return lookup(scope, t.v);
+    }
+    return UNKNOWN;
+}