diff --git a/lib/ww/syntax/ast_test.ww b/lib/ww/syntax/ast_test.ww
index 6462b4df..d2c9d4c6 100644
--- a/lib/ww/syntax/ast_test.ww
+++ b/lib/ww/syntax/ast_test.ww
@@ -8,95 +8,95 @@
 // `package main` + bare `import ast` mirrors wwdump (the external
 // astprint consumer).
 
-package main;
+package syntax_test;
 
 import syntax;
 
 
-fn checkname(k: nkind, want: str) void = {
+fn checknkname(k: nkind, want: str) void = {
 	assert(!(nkname(k) != want));
 };
 
 // One row per nkind value — same string the if-ladder returned. The
 // final row pins the unknown-kind fallback ("?").
 @test fn nkname_cases() void = {
-	checkname(nkind.N_NONE, "none");
-	checkname(nkind.N_INTLIT, "int");
-	checkname(nkind.N_FLOATLIT, "float");
-	checkname(nkind.N_STRLIT, "str");
-	checkname(nkind.N_RUNELIT, "rune");
-	checkname(nkind.N_TRUE, "true");
-	checkname(nkind.N_FALSE, "false");
-	checkname(nkind.N_NIL, "nil");
-	checkname(nkind.N_IDENT, "id");
+	checknkname(nkind.N_NONE, "none");
+	checknkname(nkind.N_INTLIT, "int");
+	checknkname(nkind.N_FLOATLIT, "float");
+	checknkname(nkind.N_STRLIT, "str");
+	checknkname(nkind.N_RUNELIT, "rune");
+	checknkname(nkind.N_TRUE, "true");
+	checknkname(nkind.N_FALSE, "false");
+	checknkname(nkind.N_NIL, "nil");
+	checknkname(nkind.N_IDENT, "id");
 
-	checkname(nkind.N_BIN, "bin");
-	checkname(nkind.N_UN, "un");
-	checkname(nkind.N_CALL, "call");
-	checkname(nkind.N_INDEX, "index");
-	checkname(nkind.N_DOT, "dot");
-	checkname(nkind.N_CAST, "cast");
-	checkname(nkind.N_STRUCTLIT, "structlit");
-	checkname(nkind.N_ARRLIT, "arrlit");
-	checkname(nkind.N_FIELD, "field");
-	checkname(nkind.N_ASSIGN, "assign");
-	checkname(nkind.N_ALLOC, "alloc");
-	checkname(nkind.N_FREE, "free");
-	checkname(nkind.N_RECV, "recv");
-	checkname(nkind.N_SLICE, "slice");
-	checkname(nkind.N_SPREAD, "spread");
+	checknkname(nkind.N_BIN, "bin");
+	checknkname(nkind.N_UN, "un");
+	checknkname(nkind.N_CALL, "call");
+	checknkname(nkind.N_INDEX, "index");
+	checknkname(nkind.N_DOT, "dot");
+	checknkname(nkind.N_CAST, "cast");
+	checknkname(nkind.N_STRUCTLIT, "structlit");
+	checknkname(nkind.N_ARRLIT, "arrlit");
+	checknkname(nkind.N_FIELD, "field");
+	checknkname(nkind.N_ASSIGN, "assign");
+	checknkname(nkind.N_ALLOC, "alloc");
+	checknkname(nkind.N_FREE, "free");
+	checknkname(nkind.N_RECV, "recv");
+	checknkname(nkind.N_SLICE, "slice");
+	checknkname(nkind.N_SPREAD, "spread");
 
-	checkname(nkind.N_BLOCK, "block");
-	checkname(nkind.N_EXPRSTMT, "exprstmt");
-	checkname(nkind.N_LET, "let");
-	checkname(nkind.N_RETURN, "return");
-	checkname(nkind.N_IF, "if");
-	checkname(nkind.N_FOR, "for");
-	checkname(nkind.N_FORRANGE, "forrange");
-	checkname(nkind.N_DEFER, "defer");
-	checkname(nkind.N_BREAK, "break");
-	checkname(nkind.N_CONTINUE, "continue");
-	checkname(nkind.N_SWITCH, "switch");
-	checkname(nkind.N_CASE, "case");
+	checknkname(nkind.N_BLOCK, "block");
+	checknkname(nkind.N_EXPRSTMT, "exprstmt");
+	checknkname(nkind.N_LET, "let");
+	checknkname(nkind.N_RETURN, "return");
+	checknkname(nkind.N_IF, "if");
+	checknkname(nkind.N_FOR, "for");
+	checknkname(nkind.N_FORRANGE, "forrange");
+	checknkname(nkind.N_DEFER, "defer");
+	checknkname(nkind.N_BREAK, "break");
+	checknkname(nkind.N_CONTINUE, "continue");
+	checknkname(nkind.N_SWITCH, "switch");
+	checknkname(nkind.N_CASE, "case");
 
-	checkname(nkind.N_FILE, "file");
-	checkname(nkind.N_USE, "use");
-	checkname(nkind.N_DEF, "def");
-	checkname(nkind.N_TYPEDECL, "typedecl");
-	checkname(nkind.N_FNDECL, "fn");
-	checkname(nkind.N_PARAM, "param");
+	checknkname(nkind.N_FILE, "file");
+	checknkname(nkind.N_USE, "use");
+	checknkname(nkind.N_DEF, "def");
+	checknkname(nkind.N_TYPEDECL, "typedecl");
+	checknkname(nkind.N_FNDECL, "fn");
+	checknkname(nkind.N_PARAM, "param");
 
-	checkname(nkind.N_TNAME, "tname");
-	checkname(nkind.N_TPTR, "tptr");
-	checkname(nkind.N_TSLICE, "tslice");
-	checkname(nkind.N_TARRAY, "tarray");
-	checkname(nkind.N_TFN, "tfn");
-	checkname(nkind.N_TSTRUCT, "tstruct");
-	checkname(nkind.N_TFIELD, "tfield");
-	checkname(nkind.N_TCHAN, "tchan");
+	checknkname(nkind.N_TNAME, "tname");
+	checknkname(nkind.N_TPTR, "tptr");
+	checknkname(nkind.N_TSLICE, "tslice");
+	checknkname(nkind.N_TARRAY, "tarray");
+	checknkname(nkind.N_TFN, "tfn");
+	checknkname(nkind.N_TSTRUCT, "tstruct");
+	checknkname(nkind.N_TFIELD, "tfield");
+	checknkname(nkind.N_TCHAN, "tchan");
 
-	checkname(nkind.N_ATTR, "attr");
-	checkname(nkind.N_TTUPLE, "ttuple");
-	checkname(nkind.N_TTAGGED, "ttagged");
-	checkname(nkind.N_TUPLE, "tuple");
-	checkname(nkind.N_MATCH, "match");
-	checkname(nkind.N_MCASE, "mcase");
-	checkname(nkind.N_TRYPROP, "tryprop");
-	checkname(nkind.N_TRYUNW, "tryunw");
-	checkname(nkind.N_MLET, "mlet");
-	checkname(nkind.N_MASSIGN, "massign");
+	checknkname(nkind.N_ATTR, "attr");
+	checknkname(nkind.N_TTUPLE, "ttuple");
+	checknkname(nkind.N_TTAGGED, "ttagged");
+	checknkname(nkind.N_TUPLE, "tuple");
+	checknkname(nkind.N_MATCH, "match");
+	checknkname(nkind.N_MCASE, "mcase");
+	checknkname(nkind.N_TRYPROP, "tryprop");
+	checknkname(nkind.N_TRYUNW, "tryunw");
+	checknkname(nkind.N_MLET, "mlet");
+	checknkname(nkind.N_MASSIGN, "massign");
 
-	checkname(nkind.N_TYPETEST, "typetest");
-	checkname(nkind.N_TYPEASSERT, "typeassert");
-	checkname(nkind.N_VOIDLIT, "voidlit");
-	checkname(nkind.N_TBANG, "tbang");
-	checkname(nkind.N_YIELD, "yield");
-	checkname(nkind.N_TENUM, "tenum");
-	checkname(nkind.N_TENUMMEMBER, "tenummember");
-	checkname(nkind.N_TPARAM, "tparam");
-	checkname(nkind.N_LAST, "last");
+	checknkname(nkind.N_TYPETEST, "typetest");
+	checknkname(nkind.N_TYPEASSERT, "typeassert");
+	checknkname(nkind.N_VOIDLIT, "voidlit");
+	checknkname(nkind.N_TBANG, "tbang");
+	checknkname(nkind.N_YIELD, "yield");
+	checknkname(nkind.N_TENUM, "tenum");
+	checknkname(nkind.N_TENUMMEMBER, "tenummember");
+	checknkname(nkind.N_TPARAM, "tparam");
+	checknkname(nkind.N_LAST, "last");
 
 	// Unknown kind → the post-switch fallback. N_LAST is the highest
 	// named value (68); 69 is out of band, exercising the "?" tail.
-	checkname(69: nkind, "?");
+	checknkname(69: nkind, "?");
 };
diff --git a/lib/ww/syntax/sym_test.ww b/lib/ww/syntax/sym_test.ww
index 769c98d0..87a9bc3b 100644
--- a/lib/ww/syntax/sym_test.ww
+++ b/lib/ww/syntax/sym_test.ww
@@ -9,7 +9,7 @@
 // survive, as in-language rows. `package main` + bare `import syntax`
 // mirrors toktest/asttest.
 
-package main;
+package syntax_test;
 
 import syntax;
 
diff --git a/lib/ww/syntax/tok_test.ww b/lib/ww/syntax/tok_test.ww
index f0986d16..c700796d 100644
--- a/lib/ww/syntax/tok_test.ww
+++ b/lib/ww/syntax/tok_test.ww
@@ -19,123 +19,123 @@
 // `package main` + bare `import tok/lex` mirrors wwdump (the only other
 // external lex consumer).
 
-package main;
+package syntax_test;
 
 import os;
 import syntax;
 import temp;
 
 
-fn checkname(k: tkind, want: str) void = {
+fn checktokname(k: tkind, want: str) void = {
 	assert(!(tokname(k) != want));
 };
 
 // One row per tkind value — same string the if-ladder returned. The
 // final row pins the unknown-kind fallback ("<?>").
 @test fn tokname_cases() void = {
-	checkname(tkind.TK_NONE, "<none>");
-	checkname(tkind.TK_EOF, "EOF");
-	checkname(tkind.TK_ERR, "ERR");
-	checkname(tkind.TK_IDENT, "IDENT");
-	checkname(tkind.TK_INT, "INT");
-	checkname(tkind.TK_FLOAT, "FLOAT");
-	checkname(tkind.TK_RUNE, "RUNE");
-	checkname(tkind.TK_STR, "STR");
+	checktokname(tkind.TK_NONE, "<none>");
+	checktokname(tkind.TK_EOF, "EOF");
+	checktokname(tkind.TK_ERR, "ERR");
+	checktokname(tkind.TK_IDENT, "IDENT");
+	checktokname(tkind.TK_INT, "INT");
+	checktokname(tkind.TK_FLOAT, "FLOAT");
+	checktokname(tkind.TK_RUNE, "RUNE");
+	checktokname(tkind.TK_STR, "STR");
 
-	checkname(tkind.TK_FN, "fn");
-	checkname(tkind.TK_LET, "let");
-	checkname(tkind.TK_DEF, "def");
-	checkname(tkind.TK_IF, "if");
-	checkname(tkind.TK_ELSE, "else");
-	checkname(tkind.TK_FOR, "for");
-	checkname(tkind.TK_SWITCH, "switch");
-	checkname(tkind.TK_CASE, "case");
-	checkname(tkind.TK_RETURN, "return");
-	checkname(tkind.TK_USE, "import");
-	checkname(tkind.TK_TYPE, "type");
-	checkname(tkind.TK_STRUCT, "struct");
-	checkname(tkind.TK_DEFER, "defer");
-	checkname(tkind.TK_BREAK, "break");
-	checkname(tkind.TK_CONTINUE, "continue");
-	checkname(tkind.TK_EXPORT, "export");
-	checkname(tkind.TK_PROC, "proc");
-	checkname(tkind.TK_CHAN, "chan");
-	checkname(tkind.TK_NIL, "nil");
-	checkname(tkind.TK_TRUE, "true");
-	checkname(tkind.TK_FALSE, "false");
-	checkname(tkind.TK_AS, "as");
-	checkname(tkind.TK_IS, "is");
-	checkname(tkind.TK_VOID, "void");
-	checkname(tkind.TK_YIELD, "yield");
-	checkname(tkind.TK_STATIC, "static");
-	checkname(tkind.TK_MATCH, "match");
-	checkname(tkind.TK_CONST, "const");
-	checkname(tkind.TK_UNDER, "_");
-	checkname(tkind.TK_ENUM, "enum");
-	checkname(tkind.TK_MODULE, "package");
+	checktokname(tkind.TK_FN, "fn");
+	checktokname(tkind.TK_LET, "let");
+	checktokname(tkind.TK_DEF, "def");
+	checktokname(tkind.TK_IF, "if");
+	checktokname(tkind.TK_ELSE, "else");
+	checktokname(tkind.TK_FOR, "for");
+	checktokname(tkind.TK_SWITCH, "switch");
+	checktokname(tkind.TK_CASE, "case");
+	checktokname(tkind.TK_RETURN, "return");
+	checktokname(tkind.TK_USE, "import");
+	checktokname(tkind.TK_TYPE, "type");
+	checktokname(tkind.TK_STRUCT, "struct");
+	checktokname(tkind.TK_DEFER, "defer");
+	checktokname(tkind.TK_BREAK, "break");
+	checktokname(tkind.TK_CONTINUE, "continue");
+	checktokname(tkind.TK_EXPORT, "export");
+	checktokname(tkind.TK_PROC, "proc");
+	checktokname(tkind.TK_CHAN, "chan");
+	checktokname(tkind.TK_NIL, "nil");
+	checktokname(tkind.TK_TRUE, "true");
+	checktokname(tkind.TK_FALSE, "false");
+	checktokname(tkind.TK_AS, "as");
+	checktokname(tkind.TK_IS, "is");
+	checktokname(tkind.TK_VOID, "void");
+	checktokname(tkind.TK_YIELD, "yield");
+	checktokname(tkind.TK_STATIC, "static");
+	checktokname(tkind.TK_MATCH, "match");
+	checktokname(tkind.TK_CONST, "const");
+	checktokname(tkind.TK_UNDER, "_");
+	checktokname(tkind.TK_ENUM, "enum");
+	checktokname(tkind.TK_MODULE, "package");
 
-	checkname(tkind.TK_LPAREN, "(");
-	checkname(tkind.TK_RPAREN, ")");
-	checkname(tkind.TK_LBRACE, "{");
-	checkname(tkind.TK_RBRACE, "}");
-	checkname(tkind.TK_LBRACK, "[");
-	checkname(tkind.TK_RBRACK, "]");
-	checkname(tkind.TK_COMMA, ",");
-	checkname(tkind.TK_SEMI, ";");
-	checkname(tkind.TK_COLON, ":");
-	checkname(tkind.TK_DOT, ".");
-	checkname(tkind.TK_ELLIPSIS, "...");
-	checkname(tkind.TK_DOTDOT, "..");
-	checkname(tkind.TK_AT, "@");
-	checkname(tkind.TK_QUESTION, "?");
+	checktokname(tkind.TK_LPAREN, "(");
+	checktokname(tkind.TK_RPAREN, ")");
+	checktokname(tkind.TK_LBRACE, "{");
+	checktokname(tkind.TK_RBRACE, "}");
+	checktokname(tkind.TK_LBRACK, "[");
+	checktokname(tkind.TK_RBRACK, "]");
+	checktokname(tkind.TK_COMMA, ",");
+	checktokname(tkind.TK_SEMI, ";");
+	checktokname(tkind.TK_COLON, ":");
+	checktokname(tkind.TK_DOT, ".");
+	checktokname(tkind.TK_ELLIPSIS, "...");
+	checktokname(tkind.TK_DOTDOT, "..");
+	checktokname(tkind.TK_AT, "@");
+	checktokname(tkind.TK_QUESTION, "?");
 
-	checkname(tkind.TK_ASSIGN, "=");
-	checkname(tkind.TK_PLUSEQ, "+=");
-	checkname(tkind.TK_MINUSEQ, "-=");
-	checkname(tkind.TK_STAREQ, "*=");
-	checkname(tkind.TK_SLASHEQ, "/=");
-	checkname(tkind.TK_PERCENTEQ, "%=");
-	checkname(tkind.TK_AMPEQ, "&=");
-	checkname(tkind.TK_PIPEEQ, "|=");
-	checkname(tkind.TK_CARETEQ, "^=");
-	checkname(tkind.TK_LSHIFTEQ, "<<=");
-	checkname(tkind.TK_RSHIFTEQ, ">>=");
+	checktokname(tkind.TK_ASSIGN, "=");
+	checktokname(tkind.TK_PLUSEQ, "+=");
+	checktokname(tkind.TK_MINUSEQ, "-=");
+	checktokname(tkind.TK_STAREQ, "*=");
+	checktokname(tkind.TK_SLASHEQ, "/=");
+	checktokname(tkind.TK_PERCENTEQ, "%=");
+	checktokname(tkind.TK_AMPEQ, "&=");
+	checktokname(tkind.TK_PIPEEQ, "|=");
+	checktokname(tkind.TK_CARETEQ, "^=");
+	checktokname(tkind.TK_LSHIFTEQ, "<<=");
+	checktokname(tkind.TK_RSHIFTEQ, ">>=");
 
-	checkname(tkind.TK_PLUS, "+");
-	checkname(tkind.TK_MINUS, "-");
-	checkname(tkind.TK_STAR, "*");
-	checkname(tkind.TK_SLASH, "/");
-	checkname(tkind.TK_PERCENT, "%");
-	checkname(tkind.TK_AMP, "&");
-	checkname(tkind.TK_PIPE, "|");
-	checkname(tkind.TK_CARET, "^");
-	checkname(tkind.TK_TILDE, "~");
-	checkname(tkind.TK_LSHIFT, "<<");
-	checkname(tkind.TK_RSHIFT, ">>");
+	checktokname(tkind.TK_PLUS, "+");
+	checktokname(tkind.TK_MINUS, "-");
+	checktokname(tkind.TK_STAR, "*");
+	checktokname(tkind.TK_SLASH, "/");
+	checktokname(tkind.TK_PERCENT, "%");
+	checktokname(tkind.TK_AMP, "&");
+	checktokname(tkind.TK_PIPE, "|");
+	checktokname(tkind.TK_CARET, "^");
+	checktokname(tkind.TK_TILDE, "~");
+	checktokname(tkind.TK_LSHIFT, "<<");
+	checktokname(tkind.TK_RSHIFT, ">>");
 
-	checkname(tkind.TK_EQ, "==");
-	checkname(tkind.TK_NEQ, "!=");
-	checkname(tkind.TK_LT, "<");
-	checkname(tkind.TK_LE, "<=");
-	checkname(tkind.TK_GT, ">");
-	checkname(tkind.TK_GE, ">=");
+	checktokname(tkind.TK_EQ, "==");
+	checktokname(tkind.TK_NEQ, "!=");
+	checktokname(tkind.TK_LT, "<");
+	checktokname(tkind.TK_LE, "<=");
+	checktokname(tkind.TK_GT, ">");
+	checktokname(tkind.TK_GE, ">=");
 
-	checkname(tkind.TK_AND, "&&");
-	checkname(tkind.TK_OR, "||");
-	checkname(tkind.TK_NOT, "!");
+	checktokname(tkind.TK_AND, "&&");
+	checktokname(tkind.TK_OR, "||");
+	checktokname(tkind.TK_NOT, "!");
 
-	checkname(tkind.TK_LARROW, "<-");
-	checkname(tkind.TK_ARROW, "->");
-	checkname(tkind.TK_FATARROW, "=>");
+	checktokname(tkind.TK_LARROW, "<-");
+	checktokname(tkind.TK_ARROW, "->");
+	checktokname(tkind.TK_FATARROW, "=>");
 
-	checkname(tkind.TK_MODRESET, "//ww:module-reset");
-	checkname(tkind.TK_MODPATH, "//ww:module");
-	checkname(tkind.TK_LAST, "<last>");
+	checktokname(tkind.TK_MODRESET, "//ww:module-reset");
+	checktokname(tkind.TK_MODPATH, "//ww:module");
+	checktokname(tkind.TK_LAST, "<last>");
 
 	// Unknown kind → the post-switch fallback. TK_LAST is the highest
 	// named value (89, after TK_MODPATH=88 landed); 90 is out of band,
 	// exercising the "<?>" tail.
-	checkname(90: tkind, "<?>");
+	checktokname(90: tkind, "<?>");
 };
 
 fn checkkw(s: str, want: tkind) void = {