2015-03-09 19:29:00

160 files changed, 7728 insertions, 3949 deletions

diff --git a/context/data/scite/context/lexers/data/scite-context-data-context.lua b/context/data/scite/context/lexers/data/scite-context-data-context.lua
index c117428b3..88eea6b5d 100644
--- a/context/data/scite/context/lexers/data/scite-context-data-context.lua
+++ b/context/data/scite/context/lexers/data/scite-context-data-context.lua
@@ -1,4 +1,4 @@
 return {
  ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plushundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "etexversion", "pdftexversion", "xetexversion", "xetexrevision", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "spaceasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "setupdocument", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar" },
- ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "doifelsecommandhandler", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "strippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthsargumenttrue", "sixthargumentfalse", "sixtsargumenttrue", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "reqno", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "scratchdimen", "globalscratchdimen", "scratchskip", "globalscratchskip", "scratchmuskip", "globalscratchmuskip", "scratchtoks", "globalscratchtoks", "scratchbox", "globalscratchbox", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "doifinset", "doifnotinset", "doifinsetelse", "doifnextcharelse", "doifnextoptionalelse", "doifnextoptionalcselse", "doiffastoptionalcheckelse", "doifnextbgroupelse", "doifnextbgroupcselse", "doifnextparenthesiselse", "doifundefinedelse", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifdimensionelse", "doifnumberelse", "doifnumber", "doifnotnumber", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifinstringelse", "doifassignmentelse", "docheckassignment", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "nbsp", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "begstrut", "endstrut", "lineheight", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "uncramped", "cramped", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expdoifelse", "expdoif", "expdoifnot", "expdoifcommonelse", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "carryoverpar", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "lefttoright", "righttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath" },
+ ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "doifelsecommandhandler", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "strippedcsname", "checkedstrippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthsargumenttrue", "sixthargumentfalse", "sixtsargumenttrue", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "reqno", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "scratchdimen", "globalscratchdimen", "scratchskip", "globalscratchskip", "scratchmuskip", "globalscratchmuskip", "scratchtoks", "globalscratchtoks", "scratchbox", "globalscratchbox", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "doifinset", "doifnotinset", "doifinsetelse", "doifnextcharelse", "doifnextoptionalelse", "doifnextoptionalcselse", "doiffastoptionalcheckelse", "doifnextbgroupelse", "doifnextbgroupcselse", "doifnextparenthesiselse", "doifundefinedelse", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifdimensionelse", "doifnumberelse", "doifnumber", "doifnotnumber", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifinstringelse", "doifassignmentelse", "docheckassignment", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "nbsp", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "begstrut", "endstrut", "lineheight", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "uncramped", "cramped", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expdoifelse", "expdoif", "expdoifnot", "expdoifcommonelse", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "installctxfunction", "carryoverpar", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "lefttoright", "righttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath" },
 }
\ No newline at end of file
diff --git a/context/data/scite/context/lexers/data/scite-context-data-metafun.lua b/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
index 38c46afad..547b8c145 100644
--- a/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
+++ b/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
@@ -1,4 +1,4 @@
 return {
- ["commands"]={ "transparency", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "textext", "thetextext", "rawtextext", "textextoffset", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "normalfill", "normaldraw", "visualizepaths", "naturalizepaths", "drawboundary", "drawwholepath", "visualizeddraw", "visualizedfill", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "format", "formatted", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "area" },
+ ["commands"]={ "transparency", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "zmod", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "textext", "thetextext", "rawtextext", "textextoffset", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "normalfill", "normaldraw", "visualizepaths", "naturalizepaths", "drawboundary", "drawwholepath", "visualizeddraw", "visualizedfill", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "format", "formatted", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "area" },
  ["internals"]={ "nocolormodel", "greycolormodel", "graycolormodel", "rgbcolormodel", "cmykcolormodel", "shadefactor", "textextoffset", "normaltransparent", "multiplytransparent", "screentransparent", "overlaytransparent", "softlighttransparent", "hardlighttransparent", "colordodgetransparent", "colorburntransparent", "darkentransparent", "lightentransparent", "differencetransparent", "exclusiontransparent", "huetransparent", "saturationtransparent", "colortransparent", "luminositytransparent", "metapostversion", "maxdimensions" },
 }
\ No newline at end of file
diff --git a/context/data/scite/context/scite-context-data-context.properties b/context/data/scite/context/scite-context-data-context.properties
index ab2d9f2cd..584f5d7e0 100644
--- a/context/data/scite/context/scite-context-data-context.properties
+++ b/context/data/scite/context/scite-context-data-context.properties
@@ -79,122 +79,123 @@ resetsystemmode pushsystemmode popsystemmode booleanmodevalue newcount \
 newdimen newskip newmuskip newbox newtoks \
 newread newwrite newmarks newinsert newattribute \
 newif newlanguage newfamily newfam newhelp \
-then begcsname strippedcsname firstargumentfalse firstargumenttrue \
-secondargumentfalse secondargumenttrue thirdargumentfalse thirdargumenttrue fourthargumentfalse \
-fourthargumenttrue fifthargumentfalse fifthsargumenttrue sixthargumentfalse sixtsargumenttrue \
-doglobal dodoglobal redoglobal resetglobal donothing \
-dontcomplain forgetall donetrue donefalse inlineordisplaymath \
-indisplaymath forcedisplaymath startforceddisplaymath stopforceddisplaymath reqno \
-htdp unvoidbox hfilll vfilll mathbox \
-mathlimop mathnolop mathnothing mathalpha currentcatcodetable \
-defaultcatcodetable catcodetablename newcatcodetable startcatcodetable stopcatcodetable \
-startextendcatcodetable stopextendcatcodetable pushcatcodetable popcatcodetable restorecatcodes \
-setcatcodetable letcatcodecommand defcatcodecommand uedcatcodecommand hglue \
-vglue hfillneg vfillneg hfilllneg vfilllneg \
-ruledhss ruledhfil ruledhfill ruledhfilneg ruledhfillneg \
-normalhfillneg ruledvss ruledvfil ruledvfill ruledvfilneg \
-ruledvfillneg normalvfillneg ruledhbox ruledvbox ruledvtop \
-ruledvcenter ruledmbox ruledhskip ruledvskip ruledkern \
-ruledmskip ruledmkern ruledhglue ruledvglue normalhglue \
-normalvglue ruledpenalty filledhboxb filledhboxr filledhboxg \
-filledhboxc filledhboxm filledhboxy filledhboxk scratchcounter \
-globalscratchcounter scratchdimen globalscratchdimen scratchskip globalscratchskip \
-scratchmuskip globalscratchmuskip scratchtoks globalscratchtoks scratchbox \
-globalscratchbox normalbaselineskip normallineskip normallineskiplimit availablehsize \
-localhsize setlocalhsize distributedhsize hsizefraction nextbox \
-dowithnextbox dowithnextboxcs dowithnextboxcontent dowithnextboxcontentcs scratchwidth \
-scratchheight scratchdepth scratchoffset scratchdistance scratchhsize \
-scratchvsize scratchxoffset scratchyoffset scratchhoffset scratchvoffset \
-scratchxposition scratchyposition scratchtopoffset scratchbottomoffset scratchleftoffset \
-scratchrightoffset scratchcounterone scratchcountertwo scratchcounterthree scratchdimenone \
-scratchdimentwo scratchdimenthree scratchskipone scratchskiptwo scratchskipthree \
-scratchmuskipone scratchmuskiptwo scratchmuskipthree scratchtoksone scratchtokstwo \
-scratchtoksthree scratchboxone scratchboxtwo scratchboxthree scratchnx \
-scratchny scratchmx scratchmy scratchunicode scratchleftskip \
-scratchrightskip scratchtopskip scratchbottomskip doif doifnot \
-doifelse doifinset doifnotinset doifinsetelse doifnextcharelse \
-doifnextoptionalelse doifnextoptionalcselse doiffastoptionalcheckelse doifnextbgroupelse doifnextbgroupcselse \
-doifnextparenthesiselse doifundefinedelse doifdefinedelse doifundefined doifdefined \
-doifelsevalue doifvalue doifnotvalue doifnothing doifsomething \
-doifelsenothing doifsomethingelse doifvaluenothing doifvaluesomething doifelsevaluenothing \
-doifdimensionelse doifnumberelse doifnumber doifnotnumber doifcommonelse \
-doifcommon doifnotcommon doifinstring doifnotinstring doifinstringelse \
-doifassignmentelse docheckassignment tracingall tracingnone loggingall \
-removetoks appendtoks prependtoks appendtotoks prependtotoks \
-to endgraf endpar everyendpar reseteverypar \
-finishpar empty null space quad \
-enspace nbsp obeyspaces obeylines obeyedspace \
-obeyedline obeyedtab obeyedpage normalspace executeifdefined \
-singleexpandafter doubleexpandafter tripleexpandafter dontleavehmode removelastspace \
-removeunwantedspaces keepunwantedspaces wait writestatus define \
-defineexpandable redefine setmeasure setemeasure setgmeasure \
-setxmeasure definemeasure freezemeasure measure measured \
-installcorenamespace getvalue getuvalue setvalue setevalue \
-setgvalue setxvalue letvalue letgvalue resetvalue \
-undefinevalue ignorevalue setuvalue setuevalue setugvalue \
-setuxvalue globallet glet udef ugdef \
-uedef uxdef checked unique getparameters \
-geteparameters getgparameters getxparameters forgetparameters copyparameters \
-getdummyparameters dummyparameter directdummyparameter setdummyparameter letdummyparameter \
-usedummystyleandcolor usedummystyleparameter usedummycolorparameter processcommalist processcommacommand \
-quitcommalist quitprevcommalist processaction processallactions processfirstactioninset \
-processallactionsinset unexpanded expanded startexpanded stopexpanded \
-protected protect unprotect firstofoneargument firstoftwoarguments \
-secondoftwoarguments firstofthreearguments secondofthreearguments thirdofthreearguments firstoffourarguments \
-secondoffourarguments thirdoffourarguments fourthoffourarguments firstoffivearguments secondoffivearguments \
-thirdoffivearguments fourthoffivearguments fifthoffivearguments firstofsixarguments secondofsixarguments \
-thirdofsixarguments fourthofsixarguments fifthofsixarguments sixthofsixarguments firstofoneunexpanded \
-firstoftwounexpanded secondoftwounexpanded firstofthreeunexpanded secondofthreeunexpanded thirdofthreeunexpanded \
-gobbleoneargument gobbletwoarguments gobblethreearguments gobblefourarguments gobblefivearguments \
-gobblesixarguments gobblesevenarguments gobbleeightarguments gobbleninearguments gobbletenarguments \
-gobbleoneoptional gobbletwooptionals gobblethreeoptionals gobblefouroptionals gobblefiveoptionals \
-dorecurse doloop exitloop dostepwiserecurse recurselevel \
-recursedepth dofastloopcs dowith newconstant setnewconstant \
-setconstant setconstantvalue newconditional settrue setfalse \
-settruevalue setfalsevalue newmacro setnewmacro newfraction \
-newsignal dosingleempty dodoubleempty dotripleempty doquadrupleempty \
-doquintupleempty dosixtupleempty doseventupleempty dosingleargument dodoubleargument \
-dotripleargument doquadrupleargument doquintupleargument dosixtupleargument doseventupleargument \
-dosinglegroupempty dodoublegroupempty dotriplegroupempty doquadruplegroupempty doquintuplegroupempty \
-permitspacesbetweengroups dontpermitspacesbetweengroups nopdfcompression maximumpdfcompression normalpdfcompression \
-modulonumber dividenumber getfirstcharacter doiffirstcharelse startnointerference \
-stopnointerference twodigits threedigits leftorright offinterlineskip \
-oninterlineskip nointerlineskip strut halfstrut quarterstrut \
-depthstrut setstrut strutbox strutht strutdp \
-strutwd struthtdp begstrut endstrut lineheight \
-ordordspacing ordopspacing ordbinspacing ordrelspacing ordopenspacing \
-ordclosespacing ordpunctspacing ordinnerspacing opordspacing opopspacing \
-opbinspacing oprelspacing opopenspacing opclosespacing oppunctspacing \
-opinnerspacing binordspacing binopspacing binbinspacing binrelspacing \
-binopenspacing binclosespacing binpunctspacing bininnerspacing relordspacing \
-relopspacing relbinspacing relrelspacing relopenspacing relclosespacing \
-relpunctspacing relinnerspacing openordspacing openopspacing openbinspacing \
-openrelspacing openopenspacing openclosespacing openpunctspacing openinnerspacing \
-closeordspacing closeopspacing closebinspacing closerelspacing closeopenspacing \
-closeclosespacing closepunctspacing closeinnerspacing punctordspacing punctopspacing \
-punctbinspacing punctrelspacing punctopenspacing punctclosespacing punctpunctspacing \
-punctinnerspacing innerordspacing inneropspacing innerbinspacing innerrelspacing \
-inneropenspacing innerclosespacing innerpunctspacing innerinnerspacing normalreqno \
-startimath stopimath normalstartimath normalstopimath startdmath \
-stopdmath normalstartdmath normalstopdmath uncramped cramped \
-triggermathstyle mathstylefont mathsmallstylefont mathstyleface mathsmallstyleface \
-mathstylecommand mathpalette mathstylehbox mathstylevbox mathstylevcenter \
-mathstylevcenteredhbox mathstylevcenteredvbox mathtext setmathsmalltextbox setmathtextbox \
-pushmathstyle popmathstyle triggerdisplaystyle triggertextstyle triggerscriptstyle \
-triggerscriptscriptstyle triggeruncrampedstyle triggercrampedstyle triggersmallstyle triggeruncrampedsmallstyle \
-triggercrampedsmallstyle triggerbigstyle triggeruncrampedbigstyle triggercrampedbigstyle luaexpr \
-expdoifelse expdoif expdoifnot expdoifcommonelse expdoifinsetelse \
-ctxdirectlua ctxlatelua ctxsprint ctxwrite ctxcommand \
-ctxdirectcommand ctxlatecommand ctxreport ctxlua luacode \
-lateluacode directluacode registerctxluafile ctxloadluafile luaversion \
-luamajorversion luaminorversion ctxluacode luaconditional luaexpanded \
-startluaparameterset stopluaparameterset luaparameterset definenamedlua obeylualines \
-obeyluatokens startluacode stopluacode startlua stoplua \
-startctxfunction stopctxfunction ctxfunction startctxfunctiondefinition stopctxfunctiondefinition \
-carryoverpar assumelongusagecs Umathbotaccent righttolefthbox lefttorighthbox \
-righttoleftvbox lefttorightvbox righttoleftvtop lefttorightvtop rtlhbox \
-ltrhbox rtlvbox ltrvbox rtlvtop ltrvtop \
-autodirhbox autodirvbox autodirvtop lefttoright righttoleft \
-synchronizelayoutdirection synchronizedisplaydirection synchronizeinlinedirection lesshyphens morehyphens \
-nohyphens dohyphens Ucheckedstartdisplaymath Ucheckedstopdisplaymath 
+then begcsname strippedcsname checkedstrippedcsname firstargumentfalse \
+firstargumenttrue secondargumentfalse secondargumenttrue thirdargumentfalse thirdargumenttrue \
+fourthargumentfalse fourthargumenttrue fifthargumentfalse fifthsargumenttrue sixthargumentfalse \
+sixtsargumenttrue doglobal dodoglobal redoglobal resetglobal \
+donothing dontcomplain forgetall donetrue donefalse \
+inlineordisplaymath indisplaymath forcedisplaymath startforceddisplaymath stopforceddisplaymath \
+reqno htdp unvoidbox hfilll vfilll \
+mathbox mathlimop mathnolop mathnothing mathalpha \
+currentcatcodetable defaultcatcodetable catcodetablename newcatcodetable startcatcodetable \
+stopcatcodetable startextendcatcodetable stopextendcatcodetable pushcatcodetable popcatcodetable \
+restorecatcodes setcatcodetable letcatcodecommand defcatcodecommand uedcatcodecommand \
+hglue vglue hfillneg vfillneg hfilllneg \
+vfilllneg ruledhss ruledhfil ruledhfill ruledhfilneg \
+ruledhfillneg normalhfillneg ruledvss ruledvfil ruledvfill \
+ruledvfilneg ruledvfillneg normalvfillneg ruledhbox ruledvbox \
+ruledvtop ruledvcenter ruledmbox ruledhskip ruledvskip \
+ruledkern ruledmskip ruledmkern ruledhglue ruledvglue \
+normalhglue normalvglue ruledpenalty filledhboxb filledhboxr \
+filledhboxg filledhboxc filledhboxm filledhboxy filledhboxk \
+scratchcounter globalscratchcounter scratchdimen globalscratchdimen scratchskip \
+globalscratchskip scratchmuskip globalscratchmuskip scratchtoks globalscratchtoks \
+scratchbox globalscratchbox normalbaselineskip normallineskip normallineskiplimit \
+availablehsize localhsize setlocalhsize distributedhsize hsizefraction \
+nextbox dowithnextbox dowithnextboxcs dowithnextboxcontent dowithnextboxcontentcs \
+scratchwidth scratchheight scratchdepth scratchoffset scratchdistance \
+scratchhsize scratchvsize scratchxoffset scratchyoffset scratchhoffset \
+scratchvoffset scratchxposition scratchyposition scratchtopoffset scratchbottomoffset \
+scratchleftoffset scratchrightoffset scratchcounterone scratchcountertwo scratchcounterthree \
+scratchdimenone scratchdimentwo scratchdimenthree scratchskipone scratchskiptwo \
+scratchskipthree scratchmuskipone scratchmuskiptwo scratchmuskipthree scratchtoksone \
+scratchtokstwo scratchtoksthree scratchboxone scratchboxtwo scratchboxthree \
+scratchnx scratchny scratchmx scratchmy scratchunicode \
+scratchleftskip scratchrightskip scratchtopskip scratchbottomskip doif \
+doifnot doifelse doifinset doifnotinset doifinsetelse \
+doifnextcharelse doifnextoptionalelse doifnextoptionalcselse doiffastoptionalcheckelse doifnextbgroupelse \
+doifnextbgroupcselse doifnextparenthesiselse doifundefinedelse doifdefinedelse doifundefined \
+doifdefined doifelsevalue doifvalue doifnotvalue doifnothing \
+doifsomething doifelsenothing doifsomethingelse doifvaluenothing doifvaluesomething \
+doifelsevaluenothing doifdimensionelse doifnumberelse doifnumber doifnotnumber \
+doifcommonelse doifcommon doifnotcommon doifinstring doifnotinstring \
+doifinstringelse doifassignmentelse docheckassignment tracingall tracingnone \
+loggingall removetoks appendtoks prependtoks appendtotoks \
+prependtotoks to endgraf endpar everyendpar \
+reseteverypar finishpar empty null space \
+quad enspace nbsp obeyspaces obeylines \
+obeyedspace obeyedline obeyedtab obeyedpage normalspace \
+executeifdefined singleexpandafter doubleexpandafter tripleexpandafter dontleavehmode \
+removelastspace removeunwantedspaces keepunwantedspaces wait writestatus \
+define defineexpandable redefine setmeasure setemeasure \
+setgmeasure setxmeasure definemeasure freezemeasure measure \
+measured installcorenamespace getvalue getuvalue setvalue \
+setevalue setgvalue setxvalue letvalue letgvalue \
+resetvalue undefinevalue ignorevalue setuvalue setuevalue \
+setugvalue setuxvalue globallet glet udef \
+ugdef uedef uxdef checked unique \
+getparameters geteparameters getgparameters getxparameters forgetparameters \
+copyparameters getdummyparameters dummyparameter directdummyparameter setdummyparameter \
+letdummyparameter usedummystyleandcolor usedummystyleparameter usedummycolorparameter processcommalist \
+processcommacommand quitcommalist quitprevcommalist processaction processallactions \
+processfirstactioninset processallactionsinset unexpanded expanded startexpanded \
+stopexpanded protected protect unprotect firstofoneargument \
+firstoftwoarguments secondoftwoarguments firstofthreearguments secondofthreearguments thirdofthreearguments \
+firstoffourarguments secondoffourarguments thirdoffourarguments fourthoffourarguments firstoffivearguments \
+secondoffivearguments thirdoffivearguments fourthoffivearguments fifthoffivearguments firstofsixarguments \
+secondofsixarguments thirdofsixarguments fourthofsixarguments fifthofsixarguments sixthofsixarguments \
+firstofoneunexpanded firstoftwounexpanded secondoftwounexpanded firstofthreeunexpanded secondofthreeunexpanded \
+thirdofthreeunexpanded gobbleoneargument gobbletwoarguments gobblethreearguments gobblefourarguments \
+gobblefivearguments gobblesixarguments gobblesevenarguments gobbleeightarguments gobbleninearguments \
+gobbletenarguments gobbleoneoptional gobbletwooptionals gobblethreeoptionals gobblefouroptionals \
+gobblefiveoptionals dorecurse doloop exitloop dostepwiserecurse \
+recurselevel recursedepth dofastloopcs dowith newconstant \
+setnewconstant setconstant setconstantvalue newconditional settrue \
+setfalse settruevalue setfalsevalue newmacro setnewmacro \
+newfraction newsignal dosingleempty dodoubleempty dotripleempty \
+doquadrupleempty doquintupleempty dosixtupleempty doseventupleempty dosingleargument \
+dodoubleargument dotripleargument doquadrupleargument doquintupleargument dosixtupleargument \
+doseventupleargument dosinglegroupempty dodoublegroupempty dotriplegroupempty doquadruplegroupempty \
+doquintuplegroupempty permitspacesbetweengroups dontpermitspacesbetweengroups nopdfcompression maximumpdfcompression \
+normalpdfcompression modulonumber dividenumber getfirstcharacter doiffirstcharelse \
+startnointerference stopnointerference twodigits threedigits leftorright \
+offinterlineskip oninterlineskip nointerlineskip strut halfstrut \
+quarterstrut depthstrut setstrut strutbox strutht \
+strutdp strutwd struthtdp begstrut endstrut \
+lineheight ordordspacing ordopspacing ordbinspacing ordrelspacing \
+ordopenspacing ordclosespacing ordpunctspacing ordinnerspacing opordspacing \
+opopspacing opbinspacing oprelspacing opopenspacing opclosespacing \
+oppunctspacing opinnerspacing binordspacing binopspacing binbinspacing \
+binrelspacing binopenspacing binclosespacing binpunctspacing bininnerspacing \
+relordspacing relopspacing relbinspacing relrelspacing relopenspacing \
+relclosespacing relpunctspacing relinnerspacing openordspacing openopspacing \
+openbinspacing openrelspacing openopenspacing openclosespacing openpunctspacing \
+openinnerspacing closeordspacing closeopspacing closebinspacing closerelspacing \
+closeopenspacing closeclosespacing closepunctspacing closeinnerspacing punctordspacing \
+punctopspacing punctbinspacing punctrelspacing punctopenspacing punctclosespacing \
+punctpunctspacing punctinnerspacing innerordspacing inneropspacing innerbinspacing \
+innerrelspacing inneropenspacing innerclosespacing innerpunctspacing innerinnerspacing \
+normalreqno startimath stopimath normalstartimath normalstopimath \
+startdmath stopdmath normalstartdmath normalstopdmath uncramped \
+cramped triggermathstyle mathstylefont mathsmallstylefont mathstyleface \
+mathsmallstyleface mathstylecommand mathpalette mathstylehbox mathstylevbox \
+mathstylevcenter mathstylevcenteredhbox mathstylevcenteredvbox mathtext setmathsmalltextbox \
+setmathtextbox pushmathstyle popmathstyle triggerdisplaystyle triggertextstyle \
+triggerscriptstyle triggerscriptscriptstyle triggeruncrampedstyle triggercrampedstyle triggersmallstyle \
+triggeruncrampedsmallstyle triggercrampedsmallstyle triggerbigstyle triggeruncrampedbigstyle triggercrampedbigstyle \
+luaexpr expdoifelse expdoif expdoifnot expdoifcommonelse \
+expdoifinsetelse ctxdirectlua ctxlatelua ctxsprint ctxwrite \
+ctxcommand ctxdirectcommand ctxlatecommand ctxreport ctxlua \
+luacode lateluacode directluacode registerctxluafile ctxloadluafile \
+luaversion luamajorversion luaminorversion ctxluacode luaconditional \
+luaexpanded startluaparameterset stopluaparameterset luaparameterset definenamedlua \
+obeylualines obeyluatokens startluacode stopluacode startlua \
+stoplua startctxfunction stopctxfunction ctxfunction startctxfunctiondefinition \
+stopctxfunctiondefinition installctxfunction carryoverpar assumelongusagecs Umathbotaccent \
+righttolefthbox lefttorighthbox righttoleftvbox lefttorightvbox righttoleftvtop \
+lefttorightvtop rtlhbox ltrhbox rtlvbox ltrvbox \
+rtlvtop ltrvtop autodirhbox autodirvbox autodirvtop \
+lefttoright righttoleft synchronizelayoutdirection synchronizedisplaydirection synchronizeinlinedirection \
+lesshyphens morehyphens nohyphens dohyphens Ucheckedstartdisplaymath \
+Ucheckedstopdisplaymath 
 
diff --git a/context/data/scite/context/scite-context-data-metafun.properties b/context/data/scite/context/scite-context-data-metafun.properties
index 4e82474f8..977ca9dfd 100644
--- a/context/data/scite/context/scite-context-data-metafun.properties
+++ b/context/data/scite/context/scite-context-data-metafun.properties
@@ -4,50 +4,50 @@ exp inv pow pi radian \
 tand cotd sin cos tan \
 cot atan asin acos invsin \
 invcos invtan acosh asinh sinh \
-cosh paired tripled unitcircle fulldiamond \
-unitdiamond fullsquare llcircle lrcircle urcircle \
-ulcircle tcircle bcircle lcircle rcircle \
-lltriangle lrtriangle urtriangle ultriangle uptriangle \
-downtriangle lefttriangle righttriangle triangle smoothed \
-cornered superellipsed randomized squeezed enlonged \
-shortened punked curved unspiked simplified \
-blownup stretched enlarged leftenlarged topenlarged \
-rightenlarged bottomenlarged crossed laddered randomshifted \
-interpolated paralleled cutends peepholed llenlarged \
-lrenlarged urenlarged ulenlarged llmoved lrmoved \
-urmoved ulmoved rightarrow leftarrow centerarrow \
-boundingbox innerboundingbox outerboundingbox pushboundingbox popboundingbox \
-bottomboundary leftboundary topboundary rightboundary xsized \
-ysized xysized sized xyscaled intersection_point \
-intersection_found penpoint bbwidth bbheight withshade \
-withcircularshade withlinearshade defineshade shaded shadedinto \
-withshadecolors withshadedomain withshademethod withshadefactor withshadevector \
-withshadecenter cmyk spotcolor multitonecolor namedcolor \
-drawfill undrawfill inverted uncolored softened \
-grayed greyed onlayer along graphictext \
-loadfigure externalfigure figure register withmask \
-bitmapimage colordecimals ddecimal dddecimal ddddecimal \
-textext thetextext rawtextext textextoffset verbatim \
-thelabel label autoalign transparent withtransparency \
-property properties withproperties asgroup infont \
-space crlf dquote percent SPACE \
-CRLF DQUOTE PERCENT grayscale greyscale \
-withgray withgrey colorpart readfile clearxy \
-unitvector center epsed anchored originpath \
-infinite break xstretched ystretched snapped \
-pathconnectors function constructedfunction constructedpath constructedpairs \
-straightfunction straightpath straightpairs curvedfunction curvedpath \
-curvedpairs evenly oddly condition pushcurrentpicture \
-popcurrentpicture arrowpath tensecircle roundedsquare colortype \
-whitecolor blackcolor basiccolors normalfill normaldraw \
-visualizepaths naturalizepaths drawboundary drawwholepath visualizeddraw \
-visualizedfill draworigin drawboundingbox drawpath drawpoint \
-drawpoints drawcontrolpoints drawcontrollines drawpointlabels drawlineoptions \
-drawpointoptions drawcontroloptions drawlabeloptions draworiginoptions drawboundoptions \
-drawpathoptions resetdrawoptions undashed decorated redecorated \
-undecorated passvariable passarrayvariable tostring format \
-formatted startpassingvariable stoppassingvariable eofill eoclip \
-area 
+cosh zmod paired tripled unitcircle \
+fulldiamond unitdiamond fullsquare llcircle lrcircle \
+urcircle ulcircle tcircle bcircle lcircle \
+rcircle lltriangle lrtriangle urtriangle ultriangle \
+uptriangle downtriangle lefttriangle righttriangle triangle \
+smoothed cornered superellipsed randomized squeezed \
+enlonged shortened punked curved unspiked \
+simplified blownup stretched enlarged leftenlarged \
+topenlarged rightenlarged bottomenlarged crossed laddered \
+randomshifted interpolated paralleled cutends peepholed \
+llenlarged lrenlarged urenlarged ulenlarged llmoved \
+lrmoved urmoved ulmoved rightarrow leftarrow \
+centerarrow boundingbox innerboundingbox outerboundingbox pushboundingbox \
+popboundingbox bottomboundary leftboundary topboundary rightboundary \
+xsized ysized xysized sized xyscaled \
+intersection_point intersection_found penpoint bbwidth bbheight \
+withshade withcircularshade withlinearshade defineshade shaded \
+shadedinto withshadecolors withshadedomain withshademethod withshadefactor \
+withshadevector withshadecenter cmyk spotcolor multitonecolor \
+namedcolor drawfill undrawfill inverted uncolored \
+softened grayed greyed onlayer along \
+graphictext loadfigure externalfigure figure register \
+withmask bitmapimage colordecimals ddecimal dddecimal \
+ddddecimal textext thetextext rawtextext textextoffset \
+verbatim thelabel label autoalign transparent \
+withtransparency property properties withproperties asgroup \
+infont space crlf dquote percent \
+SPACE CRLF DQUOTE PERCENT grayscale \
+greyscale withgray withgrey colorpart readfile \
+clearxy unitvector center epsed anchored \
+originpath infinite break xstretched ystretched \
+snapped pathconnectors function constructedfunction constructedpath \
+constructedpairs straightfunction straightpath straightpairs curvedfunction \
+curvedpath curvedpairs evenly oddly condition \
+pushcurrentpicture popcurrentpicture arrowpath tensecircle roundedsquare \
+colortype whitecolor blackcolor basiccolors normalfill \
+normaldraw visualizepaths naturalizepaths drawboundary drawwholepath \
+visualizeddraw visualizedfill draworigin drawboundingbox drawpath \
+drawpoint drawpoints drawcontrolpoints drawcontrollines drawpointlabels \
+drawlineoptions drawpointoptions drawcontroloptions drawlabeloptions draworiginoptions \
+drawboundoptions drawpathoptions resetdrawoptions undashed decorated \
+redecorated undecorated passvariable passarrayvariable tostring \
+format formatted startpassingvariable stoppassingvariable eofill \
+eoclip area 
 
 keywordclass.metafun.internals=\
 nocolormodel greycolormodel graycolormodel rgbcolormodel \
diff --git a/doc/context/documents/general/manuals/workflows-mkiv.pdf b/doc/context/documents/general/manuals/workflows-mkiv.pdf
index 8d9ee5cd6..7cdd669cc 100644
--- a/doc/context/documents/general/manuals/workflows-mkiv.pdf
+++ b/doc/context/documents/general/manuals/workflows-mkiv.pdf
diff --git a/doc/context/scripts/mkiv/mtx-bibtex.html b/doc/context/scripts/mkiv/mtx-bibtex.html
new file mode 100644
index 000000000..61a679716
--- /dev/null
+++ b/doc/context/scripts/mkiv/mtx-bibtex.html
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<!-- compare with lmx framework variant -->
+
+<!--
+    filename : context-base.xml
+    comment  : companion to mtx-server-ctx-startup.tex
+    author   : Hans Hagen, PRAGMA-ADE, Hasselt NL
+    copyright: PRAGMA ADE / ConTeXt Development Team
+    license  : see context related readme files
+-->
+
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+    <head>
+        <title>bibtex helpers</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+                <style type="text/css">
+            body { color: #FFFFFF; background-color: #808080; font-family: optima, verdana, futura, "lucida sans", arial, geneva, helvetica, sans; font-size: 12px; line-height: 18px; } a:link, a:active, a:visited { color: #FFFFFF; } a.dir-view:link, a.dir-view:active, a.dir-view:visited { color: #FFFFFF; text-decoration: underline; } .valid { color: #00FF00; } .invalid { color: #FF0000; } button, .commonlink, .smallbutton { font-weight: bold; font-size: 12px; text-decoration: none; color: #000000; border-color: #7F7F7F; border-style: solid; border-width: .125ex; background-color: #FFFFFF; padding: .5ex; } .smallbutton { width: 1em; } a.commonlink:link, a.commonlink:active, a.commonlink:visited, a.smalllink:link, a.smalllink:active, a.smalllink:visited { font-weight: bold; font-size: 12px; text-decoration: none; color: #000000; } h1, .title { font-style: normal; font-weight: normal; font-size: 18px; line-height: 18px; margin-bottom: 20px; } h2, .subtitle { font-style: normal; font-weight: normal; font-size: 12px; margin-top: 18px; margin-bottom: 18px; } table { line-height: 18px; font-size: 12px; margin: 0; } th { font-weight: bold; text-align: left; padding-bottom: 6px; } .tc { font-weight: bold; text-align: left; } p, li { max-width: 60em; } .empty-line { margin-top: 4px; } .more-room { margin-right: 1.5em; } .much-more-room { margin-right: 3em; } #main { position: absolute; left: 10%; top: 10%; right: 10%; bottom: 10%; z-index: 2; width: 80%; height: 80%; padding: 0%; margin: 0%; overflow: auto; border-style: none; border-width: 0; background-color: #3F3F3F; } #main-settings { margin: 12px; x_max-width: 60em; line-height: 18px; font-size: 12px; } #left { position: absolute; top : 10%; left: 0%; bottom: 0%; right: 90%; z-index: 1; width: 10%; height: 90%; padding: 0%; margin: 0%; font-size: 16px; border-style: none; border-width: 0; background-color: #4F6F6F; } #right { position: absolute; top : 0%; left: 90%; bottom: 10%; right: 0%; z-index: 1; width: 10%; height: 90%; padding: 0%; margin: 0%; font-size: 16px; border-style: none; border-width: 0; background-color: #4F6F6F; _margin-left: -15px; } #bottom { position: absolute; left: 10%; right: 0%; top: 90%; bottom: 0%; z-index: 1; width: 90%; height: 10%; padding: 0%; margin: 0%; font-size: 16px; border-style: none; border-width: 0; background-color: #6F6F8F; } #top { position: absolute; left: 0%; right: 10%; top: 0%; bottom: 90%; z-index: 1; width: 90%; height: 10%; padding: 0%; margin: 0%; font-size: 16px; border-style: none; border-width: 0; background-color: #6F6F8F; } #top-one { position: absolute; bottom: 50%; width: 100%; buggedheight: 100%; } #top-two { position: relative; margin-bottom: -9px; margin-left: 12px; margin-right: 12px; line-height: 18px; text-align: right; vertical-align: middle; } #bottom-one { position: absolute; bottom: 50%; width: 100%; buggedheight: 100%; } #bottom-two { position: relative; margin-bottom: -9px; margin-left: 12px; margin-right: 12px; line-height: 18px; text-align: left; vertical-align: middle; } #left-one { position: absolute; width: 100%; buggedheight: 100%; } #left-two { position: relative; margin-top: 12px; line-height: 18px; text-align: center; vertical-align: top; } #right-one { display: table; height: 100%; width: 100%; } #right-two { display: table-row; height: 100%; width: 100%; } #right-three { display: table-cell; width: 100%; vertical-align: bottom; _position: absolute; _top: 100%; } #right-four { text-align: center; margin-bottom: 2ex; _position: relative; _top: -100%; } #more-top { position: absolute; top: 0%; left: 90%; bottom: 90%; right: 0%; z-index: 3; width: 10%; height: 10%; padding: 0%; margin: 0%; border-style: none; border-width: 0; } #more-top-settings { text-align: center; } #more-right-settings { margin-right: 12px; margin-left: 12px; line-height: 18px; font-size: 10px; text-align: center; } #right-safari { _display: table; width: 100%; height: 100%; } 
+        </style>
+        <style type="text/css">
+                    </style>
+            </head>
+            <body>
+        <div id="top">            <div id="top-one">
+                <div id="top-two">bibtex helpers </div>
+            </div>
+        </div>
+        <div id="bottom">            <div id="bottom-one">
+                <div id="bottom-two">wiki: http://contextgarden.net | mail: ntg-context@ntg.nl | website: http://www.pragma-ade.nl</div>
+            </div>
+        </div>
+        <div id="left"></div>
+        <div id="right"></div>
+        <div id="main">
+            <div id='main-settings'>
+                <h1>Command line options</h1>
+<table>
+    <tr><th style="width: 10em">flag</th><th style="width: 8em">value</th><th>description</th></tr>
+        <tr><th/><td/><td/></tr>
+        <tr><th>--toxml</th><td></td><td>convert bibtex database(s) to xml</td></tr>
+        <tr><th>--tolua</th><td></td><td>convert bibtex database(s) to lua</td></tr>
+        <tr><th>--search</th><td></td><td>seatch bibtex database(s)</td></tr>
+    </table>
+<br/>
+<h1>Example</h1>
+<tt>mtxrun --script bibtex --tolua bibl-001.bib</tt>
+<br/><tt>mtxrun --script bibtex --tolua --simple bibl-001.bib</tt>
+<br/><tt>mtxrun --script bibtex --toxml bibl-001.bib bibl-002.bib bibl-003.bib biblio.xml</tt>
+<br/><tt>mtxrun --script bibtex --search --list --pattern=match(author:foo) bar.bib</tt>
+<br/><br/>            </div>
+        </div>
+    </body>
+    </html>
diff --git a/doc/context/scripts/mkiv/mtx-bibtex.man b/doc/context/scripts/mkiv/mtx-bibtex.man
new file mode 100644
index 000000000..ddd3cfbc5
--- /dev/null
+++ b/doc/context/scripts/mkiv/mtx-bibtex.man
@@ -0,0 +1,33 @@
+.TH "mtx-bibtex" "1" "01-01-2015" "version 1.00" "bibtex helpers"
+.SH NAME
+.B mtx-bibtex
+.SH SYNOPSIS
+.B mtxrun --script bibtex [
+.I OPTIONS ...
+.B ] [
+.I FILENAMES
+.B ]
+.SH DESCRIPTION
+.B bibtex helpers
+.SH OPTIONS
+.TP
+.B --toxml
+convert bibtex database(s) to xml
+.TP
+.B --tolua
+convert bibtex database(s) to lua
+.TP
+.B --search
+seatch bibtex database(s)
+.SH AUTHOR
+More information about ConTeXt and the tools that come with it can be found at:
+
+
+.B "maillist:"
+ntg-context@ntg.nl / http://www.ntg.nl/mailman/listinfo/ntg-context
+
+.B "webpage:"
+http://www.pragma-ade.nl / http://tex.aanhet.net
+
+.B "wiki:"
+http://contextgarden.net
diff --git a/doc/context/scripts/mkiv/mtx-bibtex.xml b/doc/context/scripts/mkiv/mtx-bibtex.xml
new file mode 100644
index 000000000..5c28b946a
--- /dev/null
+++ b/doc/context/scripts/mkiv/mtx-bibtex.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<application>
+ <metadata>
+  <entry name="name">mtx-bibtex</entry>
+  <entry name="detail">bibtex helpers</entry>
+  <entry name="version">1.00</entry>
+ </metadata>
+ <flags>
+  <category name="basic">
+   <subcategory>
+    <flag name="toxml"><short>convert bibtex database(s) to xml</short></flag>
+    <flag name="tolua"><short>convert bibtex database(s) to lua</short></flag>
+    <flag name="search"><short>seatch bibtex database(s)</short></flag>
+   </subcategory>
+  </category>
+ </flags>
+ <examples>
+  <category>
+   <title>Example</title>
+   <subcategory>
+    <example><command>mtxrun --script bibtex --tolua bibl-001.bib</command></example>
+    <example><command>mtxrun --script bibtex --tolua --simple bibl-001.bib</command></example>
+    <example><command>mtxrun --script bibtex --toxml bibl-001.bib bibl-002.bib bibl-003.bib biblio.xml</command></example>
+    <example><command>mtxrun --script bibtex --search --list --pattern=match(author:foo) bar.bib</command></example>
+   </subcategory>
+  </category>
+ </examples>
+</application>
diff --git a/doc/context/sources/general/manuals/workflows/workflows-mkiv.tex b/doc/context/sources/general/manuals/workflows/workflows-mkiv.tex
index 3070a5be6..919b5cc74 100644
--- a/doc/context/sources/general/manuals/workflows/workflows-mkiv.tex
+++ b/doc/context/sources/general/manuals/workflows/workflows-mkiv.tex
@@ -24,6 +24,7 @@
     \component workflows-suspects
     \component workflows-injectors
     \component workflows-xml
+    \component workflows-setups
 \stopbodymatter
 
 \stopdocument
diff --git a/doc/context/sources/general/manuals/workflows/workflows-setups.tex b/doc/context/sources/general/manuals/workflows/workflows-setups.tex
new file mode 100644
index 000000000..e9d120f7b
--- /dev/null
+++ b/doc/context/sources/general/manuals/workflows/workflows-setups.tex
@@ -0,0 +1,72 @@
+% language=uk
+
+\environment workflows-style
+
+\startcomponent workflows-setups
+
+\startchapter[title={Setups}]
+
+Setups are a powerful way to organize styles. They are basically macros but live
+in their own namespace. One advantage is that spaces in a setup are ignored so
+you can code without bothering about spurious spaces. Here is a trick that you
+can use when one style contains directives for multiple products:
+
+\startbuffer
+\startsetups tex:whatever
+    \fastsetup{tex:whatever:\documentvariable{stylevariant}}
+\stopsetups
+
+\startsetups tex:whatever:foo
+    FOO
+\stopsetups
+
+\startsetups tex:whatever:bar
+    BAR
+\stopsetups
+\stopbuffer
+
+\typebuffer \getbuffer
+
+Here we define a main setup \type {tex:whatever} that gets expanded in one of two
+variants, controlled by a document variable.
+
+\startbuffer
+\setups{tex:whatever}
+
+\setupdocument
+  [stylevariant=foo]
+
+\setups{tex:whatever}
+
+\setupdocument
+  [stylevariant=bar]
+
+\setups{tex:whatever}
+\stopbuffer
+
+\typebuffer
+
+These lines result in:
+
+\getbuffer
+
+In a similar fashion you can define \XML\ setups that are used to render
+elements:
+
+\starttyping
+\startxmlsetups xml:whatever
+    \xmlsetup{#1}{xml:whatever:\documentvariable{stylevariant}}
+\stopxmlsetups
+
+\startxmlsetups xml:whatever:foo
+    FOO: \xmlflush{#1}
+\stopxmlsetups
+
+\startxmlsetups xml:whatever:bar
+    BAR: \xmlflush{#1}
+\stopxmlsetups
+\stoptyping
+
+\stopchapter
+
+\stopcomponent
diff --git a/doc/context/sources/general/manuals/workflows/workflows-style.tex b/doc/context/sources/general/manuals/workflows/workflows-style.tex
index ed64da6b2..9d46aaad8 100644
--- a/doc/context/sources/general/manuals/workflows/workflows-style.tex
+++ b/doc/context/sources/general/manuals/workflows/workflows-style.tex
@@ -35,7 +35,6 @@
 \setuptype
   [color=maincolor]
 
-
 \setupdocument
   [metadata:author=<author>,
    metadata:title=<title>,
diff --git a/metapost/context/base/mp-chem.mpiv b/metapost/context/base/mp-chem.mpiv
index a316a1a30..7ca40bbea 100644
--- a/metapost/context/base/mp-chem.mpiv
+++ b/metapost/context/base/mp-chem.mpiv
@@ -11,7 +11,8 @@
 %C therefore copyrighted by \PRAGMA. See licen-en.pdf for
 %C details.
 
-%D This module is incomplete and experimental.
+%D This module is incomplete and experimental. Okay, it's not that bad but we do need
+%D some disclaimer.
 
 % either consistent setting or not
 
@@ -300,7 +301,6 @@ enddef ;
 
 chem_init_all ; % WHY does this not work unless defined and then called?
 
-
 % Like most often in ConTeXt, we will trap but then silently ignore mistaken use,
 % unless of course the error be too harmful...
 
@@ -529,6 +529,17 @@ vardef chem_set (suffix $) =
     % This is a fairly complicated optimization and ajustement. It took some
     % thinking to get right, so beware!
 
+    % And then even more time fixing a bug of a rotation +- half the symmetry
+    % angle of a structure depending on the scale and/or the font size
+    % (through chem_b_length).
+
+    % first save the symmetry angle of the structure (as in chem_rot):
+    chem_num0 := if chem_stacked[$] : 3 else : 0 fi ;
+    chem_num9 := if chem_tetra[$] : 360 else :
+                 abs(angle(point 0+chem_num0 of chem_b_path[$]) -
+                     angle(point 1+chem_num0 of chem_b_path[$]))
+                 fi ;
+
     if (chem_adjacent<>0) and chem_star[P] and chem_star[$] :
         % nop
         chem_adjacent := 0 ;
@@ -581,7 +592,8 @@ vardef chem_set (suffix $) =
                           -((point (chem_adjacent-1) of chem_b_path[P]) chem_transformed(P)) ;
         fi
         % adjust the bond angles
-        chem_rotation := (chem_rotation + angle(chem_pair1)-angle(chem_pair3)) mod 360 ;
+        chem_num4 := (angle(chem_pair1)-angle(chem_pair3)) zmod chem_num9 ;
+        chem_rotation := chem_rotation + chem_num4 ;
         if not chem_star[$] :
             chem_pair4 :=
                 if chem_star[P] :
@@ -666,7 +678,8 @@ vardef chem_set (suffix $) =
                 fi
             endfor
             if not chem_front[$] : % adjust rotation
-                chem_rotation := (chem_rotation + angle(chem_pair1)-angle(chem_pair3)) mod 360 ;
+                chem_num4 := angle(chem_pair1)-angle(chem_pair3) ;
+                chem_rotation := (chem_rotation + chem_num4) mod 360 ;
             fi ;
             chem_t := identity chem_transformed($) ;
             chem_pair4 := (point chem_num3 of chem_b_path[$]) transformed chem_t ;
@@ -674,6 +687,9 @@ vardef chem_set (suffix $) =
                 currentpicture := currentpicture shifted chem_pair4 ;
                 chem_origin    := chem_origin    shifted chem_pair4 ;
             fi
+            if not chem_front[$] : % adjust rotation
+                chem_rotation := chem_rotation zmod chem_num9 ;
+            fi
         fi
         chem_substituent := 0 ;
     fi ;
@@ -1571,9 +1587,9 @@ vardef chem_rot (suffix $) (expr d, s) = % ROT
             chem_rotation := 0
         else :
             chem_num0 := if chem_stacked[$] : 3 else : 0 fi ;
-            chem_num1 := .5(angle(point d+chem_num0 of chem_b_path[$]) -
+            chem_num1 := .5(angle(point d+chem_num0   of chem_b_path[$]) -
                             angle(point d+chem_num0-1 of chem_b_path[$])) ;
-            chem_rotation := (chem_rotation + s*chem_num1) mod 360 ;
+            chem_rotation := (chem_rotation + s*chem_num1) zmod 360 ;
         fi
     fi
 enddef ;
@@ -1584,7 +1600,7 @@ vardef chem_mir (suffix $) (expr d, s)  = % MIR
     if not chem_front[$] :
         if d=0 : % inversion
             if chem_mirror=origin :
-                chem_rotation := (chem_rotation + 180*s) mod 360 ;
+                chem_rotation := (chem_rotation + 180*s) zmod 360 ;
             else :
                 chem_mirror := chem_mirror rotated 90 ;
             fi
@@ -1600,7 +1616,7 @@ vardef chem_mir (suffix $) (expr d, s)  = % MIR
                     chem_num0 := -360 - chem_num0 ;
                 fi
                 chem_num0 := chem_num0 * s ;
-                chem_rotation := (chem_rotation + 2chem_num0) mod 360 ;
+                chem_rotation := (chem_rotation + 2chem_num0) zmod 360 ;
                 chem_mirror := origin ;
             fi
         fi
diff --git a/metapost/context/base/mp-mlib.mpiv b/metapost/context/base/mp-mlib.mpiv
index 1140673ab..907c0c4b7 100644
--- a/metapost/context/base/mp-mlib.mpiv
+++ b/metapost/context/base/mp-mlib.mpiv
@@ -390,11 +390,11 @@ string mfun_prescript_separator ; mfun_prescript_separator := char(13) ;
 % Shades
 
 % for while we had this:
-%
-% newinternal shadefactor  ; shadefactor  := 1 ;
-% pair        shadeoffset  ; shadeoffset  := origin ;
-% boolean     trace_shades ; trace_shades := false ;
-%
+
+newinternal shadefactor  ; shadefactor  := 1 ;      % currently obsolete
+pair        shadeoffset  ; shadeoffset  := origin ; % currently obsolete
+boolean     trace_shades ; trace_shades := false ;  % still there
+
 % def withlinearshading (expr a, b) =
 %     withprescript "sh_type=linear"
 %     withprescript "sh_domain=0 1"
@@ -523,8 +523,8 @@ def withcircularshade (expr a, b, ra, rb, ca, cb) =
     withprescript "sh_factor=1"
     withprescript "sh_color_a="  & colordecimals ca
     withprescript "sh_color_b="  & colordecimals cb
-    withprescript "sh_center_a=" & ddecimal (a shifted shadeoffset)
-    withprescript "sh_center_b=" & ddecimal (b shifted shadeoffset)
+    withprescript "sh_center_a=" & ddecimal a % (a shifted shadeoffset)
+    withprescript "sh_center_b=" & ddecimal b % (b shifted shadeoffset)
     withprescript "sh_radius_a=" & decimal ra
     withprescript "sh_radius_b=" & decimal rb
 enddef ;
@@ -535,8 +535,8 @@ def withlinearshade (expr a, b, ca, cb) =
     withprescript "sh_factor=1"
     withprescript "sh_color_a="  & colordecimals ca
     withprescript "sh_color_b="  & colordecimals cb
-    withprescript "sh_center_a=" & ddecimal (a shifted shadeoffset)
-    withprescript "sh_center_b=" & ddecimal (b shifted shadeoffset)
+    withprescript "sh_center_a=" & ddecimal a % (a shifted shadeoffset)
+    withprescript "sh_center_b=" & ddecimal b % (b shifted shadeoffset)
 enddef ;
 
 % replaced (obsolete):
@@ -595,8 +595,8 @@ vardef define_circular_shade (expr a, b, ra, rb, ca, cb) =
     & mfun_prescript_separator & "sh_factor=1"
     & mfun_prescript_separator & "sh_color_a="  & colordecimals ca
     & mfun_prescript_separator & "sh_color_b="  & colordecimals cb
-    & mfun_prescript_separator & "sh_center_a=" & ddecimal (a shifted shadeoffset)
-    & mfun_prescript_separator & "sh_center_b=" & ddecimal (b shifted shadeoffset)
+    & mfun_prescript_separator & "sh_center_a=" & ddecimal a % (a shifted shadeoffset)
+    & mfun_prescript_separator & "sh_center_b=" & ddecimal b % (b shifted shadeoffset)
     & mfun_prescript_separator & "sh_radius_a=" & decimal ra
     & mfun_prescript_separator & "sh_radius_b=" & decimal rb
     ;
@@ -610,8 +610,8 @@ vardef define_linear_shade (expr a, b, ca, cb) =
     & mfun_prescript_separator & "sh_factor=1"
     & mfun_prescript_separator & "sh_color_a=" & colordecimals ca
     & mfun_prescript_separator & "sh_color_b=" & colordecimals cb
-    & mfun_prescript_separator & "sh_center_a=" & ddecimal (a shifted shadeoffset)
-    & mfun_prescript_separator & "sh_center_b=" & ddecimal (b shifted shadeoffset)
+    & mfun_prescript_separator & "sh_center_a=" & ddecimal a % (a shifted shadeoffset)
+    & mfun_prescript_separator & "sh_center_b=" & ddecimal b % (b shifted shadeoffset)
     ;
     mfun_defined_cs
 enddef ;
diff --git a/metapost/context/base/mp-tool.mpii b/metapost/context/base/mp-tool.mpii
index 62bd122f5..a5bb345a1 100644
--- a/metapost/context/base/mp-tool.mpii
+++ b/metapost/context/base/mp-tool.mpii
@@ -1407,7 +1407,7 @@ primarydef pct along pat = % also negative
 enddef ;
 
 primarydef len on pat = % no outer ( ) .. somehow fails
-    (arctime if len>0 : len else : (arclength(pat)+len) fi of pat) of pat
+    (arctime if len>=0 : len else : (arclength(pat)+len) fi of pat) of pat
 enddef ;
 
 % this cuts of a piece from both ends
diff --git a/metapost/context/base/mp-tool.mpiv b/metapost/context/base/mp-tool.mpiv
index dda8e84a1..30c3f0f50 100644
--- a/metapost/context/base/mp-tool.mpiv
+++ b/metapost/context/base/mp-tool.mpiv
@@ -368,6 +368,11 @@ vardef asinh  primary x = ln(x+(x++1))     enddef ;
 vardef sinh   primary x = save xx ; xx = exp x ; (xx-1/xx)/2 enddef ;
 vardef cosh   primary x = save xx ; xx = exp x ; (xx+1/xx)/2 enddef ;
 
+%D Like mod, but useful for anglesl it returns (-.5d,+.5d] and is used
+%D in for instance mp-chem.
+
+primarydef a zmod b = (-((b/2 - a) mod b) + b/2) enddef ;
+
 %D Sometimes this is handy:
 
 def undashed =
@@ -1364,7 +1369,7 @@ primarydef pct along pat = % also negative
 enddef ;
 
 primarydef len on pat = % no outer ( ) .. somehow fails
-    (arctime if len>0 : len else : (arclength(pat)+len) fi of pat) of pat
+    (arctime if len>=0 : len else : (arclength(pat)+len) fi of pat) of pat
 enddef ;
 
 % this cuts of a piece from both ends
@@ -2315,7 +2320,7 @@ enddef ;
 %D Handy:
 
 def break =
-    exitif true fi ;
+    exitif true ; % fi
 enddef ;
 
 %D New too:
diff --git a/scripts/context/lua/mtx-context.lua b/scripts/context/lua/mtx-context.lua
index 8a18cab39..ac93145be 100644
--- a/scripts/context/lua/mtx-context.lua
+++ b/scripts/context/lua/mtx-context.lua
@@ -644,6 +644,22 @@ function scripts.context.run(ctxdata,filename)
                 scripts.context.make(formatname,a_engine)
                 formatfile, scriptfile = resolvers.locateformat(formatname)
             end
+            --
+            local function combine(key)
+                local flag = validstring(environment[key])
+                local plus = analysis[key]
+                if flag and plus then
+                    return plus .. "," .. flag -- flag wins
+                else
+                    return flag or plus -- flag wins
+                end
+            end
+            local a_trackers    = analysis.trackers
+            local a_experiments = analysis.experiments
+            local directives    = combine("directives")
+            local trackers      = combine("trackers")
+            local experiments   = combine("experiments")
+            --
             if formatfile and scriptfile then
                 local suffix     = validstring(getargument("suffix"))
                 local resultname = validstring(getargument("result"))
@@ -691,9 +707,9 @@ function scripts.context.run(ctxdata,filename)
                 local maxnofruns = once and 1 or multipass_nofruns
                 --
                 local c_flags = {
-                    directives  = validstring(environment.directives),   -- gets passed via mtxrun
-                    trackers    = validstring(environment.trackers),     -- gets passed via mtxrun
-                    experiments = validstring(environment.experiments),  -- gets passed via mtxrun
+                    directives  = directives,   -- gets passed via mtxrun
+                    trackers    = trackers,     -- gets passed via mtxrun
+                    experiments = experiments,  -- gets passed via mtxrun
                     --
                     result      = validstring(resultname),
                     input       = validstring(getargument("input") or filename), -- alternative input
diff --git a/scripts/context/lua/mtx-epub.lua b/scripts/context/lua/mtx-epub.lua
index a383cfd90..69d9bb72c 100644
--- a/scripts/context/lua/mtx-epub.lua
+++ b/scripts/context/lua/mtx-epub.lua
@@ -34,6 +34,46 @@ if not modules then modules = { } end modules ['mtx-epub'] = {
 -- coverpage tests
 -- split up
 
+-- todo: automated cover page:
+--
+-- \startMPpage
+--     StartPage ;
+--         fill Page withcolor .5red ;
+--         numeric n ;
+--         for i=10 downto 1 :
+--             n := i * PaperWidth/40  ;
+--             draw
+--                 lrcorner Page shifted (0,n)
+--               % -- lrcorner Page
+--                 -- lrcorner Page shifted (-n,0)
+--               % -- cycle
+--                 withpen pencircle scaled 1mm
+--                 withcolor white ;
+--         endfor ;
+--         picture p ; p := image (
+--             draw
+--                 anchored.top(
+--                     textext.bot("\tttf Some Title")
+--                         xsized .8PaperWidth
+--                    ,center topboundary Page
+--                 )
+--                     withcolor white ;
+--         ) ;
+--         picture q ; q := image (
+--             draw
+--                 anchored.top(
+--                     textext.bot("\tttf An Author")
+--                         xsized .4PaperWidth
+--                         shifted (0,-PaperHeight/40)
+--                    ,center bottomboundary p
+--                 )
+--                     withcolor white ;
+--         ) ;
+--         draw p ;
+--         draw q ;
+--     StopPage ;
+-- \stopMPpage
+
 local format, gsub, find = string.format, string.gsub, string.find
 local concat, sortedhash = table.concat, table.sortedhash
 
@@ -389,7 +429,7 @@ function scripts.epub.make(purge,rename,svgmath,svgstyle)
     end
 
     if not specfull or not isfile(specfull) then
-        report("unknown specificaton file for %a",filename)
+        report("unknown specificaton file %a for %a",specfull or "?",filename)
         return
     end
 
@@ -459,7 +499,8 @@ function scripts.epub.make(purge,rename,svgmath,svgstyle)
 
     local pdftosvg   = os.which("mudraw") and formatters[ [[mudraw -o "%s" "%s" %s]] ]
 
-    local f_svgname  = formatters["%s-page-%s.svg"]
+    local f_svgpage  = formatters["%s-page-%s.svg"]
+    local f_svgname  = formatters["%s.svg"]
 
     local notupdated = 0
     local updated    = 0
@@ -521,10 +562,15 @@ function scripts.epub.make(purge,rename,svgmath,svgstyle)
         local name = url.filename(data.name)
         local used = url.filename(data.used)
         local base = basename(used)
-        local page = data.page or "1"
+        local page = tonumber(data.page) or 1
         -- todo : check timestamp and prefix, rename to image-*
         if suffix(used) == "pdf" then
-            name = f_svgname(nameonly(name),page)
+            -- todo: pass svg name
+            if page > 1 then
+                name = f_svgpage(nameonly(name),page)
+            else
+                name = f_svgname(nameonly(name))
+            end
             local source  = used
             local target  = joinfile(imagesource,name)
             if needsupdating(source,target) then
diff --git a/scripts/context/lua/mtx-interface.lua b/scripts/context/lua/mtx-interface.lua
index 82cefd638..1640f0891 100644
--- a/scripts/context/lua/mtx-interface.lua
+++ b/scripts/context/lua/mtx-interface.lua
@@ -248,7 +248,7 @@ function scripts.interface.editor(editor,split,forcedinterfaces)
             local mappings     = { }
             local environments = { }
             local x = xml.load(keyfile)
-            for e, d, k in xml.elements(x,"cd:command") do
+            for e, d, k in xml.elements(x,"/cd:interface/cd:commands/cd:command") do -- somehow this was variable
                 local at = d[k].at
                 local name, value = at.name, at.value
                 if name and value then
@@ -256,7 +256,7 @@ function scripts.interface.editor(editor,split,forcedinterfaces)
                 end
             end
             local x = xml.load(xmlfile)
-            for e, d, k in xml.elements(x,"cd:command") do
+            for e, d, k in xml.elements(x,"/cd:interface/cd:command") do
                 local at = d[k].at
                 local name, type = at.name, at["type"]
                 if name and name ~= "" then
@@ -322,7 +322,7 @@ function scripts.interface.check()
         if f then
             f:write("\\starttext\n")
             local x = xml.load(xmlfile)
-            for e, d, k in xml.elements(x,"cd:command") do
+            for e, d, k in xml.elements(x,"/cd:interface/cd:command") do
                 local dk = d[k]
                 local at = dk.at
                 if at then
@@ -384,6 +384,7 @@ function scripts.interface.interfaces()
                     return a .. b .. c .. b
                 end)
             end
+            -- we could just replace attributes
             for language, _ in next, commands.setuplayout do
                 local texresult, xmlresult = { }, { }
                 texresult[#texresult+1] = format("%% this file is auto-generated, don't edit this file\n%%")
@@ -403,6 +404,7 @@ function scripts.interface.interfaces()
                 report("saving interface translations '%s'",xmlfilename)
                 if language ~= "en" and xmldata ~= "" then
                     local newdata = xmldata:gsub("(<cd:interface.*language=.)en(.)","%1"..language.."%2",1)
+-- newdata = replace(newdata, 'cd:command', 'name', interface.commands, interface.elements, language)
                     newdata = replace(newdata, 'cd:string', 'value', interface.commands, interface.elements, language)
                     newdata = replace(newdata, 'cd:variable' , 'value', interface.variables, nil, language)
                     newdata = replace(newdata, 'cd:parameter', 'name', interface.constants, nil, language)
diff --git a/scripts/context/lua/mtxrun.lua b/scripts/context/lua/mtxrun.lua
index 0ac7e5013..c9096d81e 100644
--- a/scripts/context/lua/mtxrun.lua
+++ b/scripts/context/lua/mtxrun.lua
@@ -6558,7 +6558,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 21550, stripped down to: 14916
+-- original size: 21610, stripped down to: 14974
 
 if not modules then modules={} end modules ['util-prs']={
   version=1.001,
@@ -6813,7 +6813,7 @@ function parsers.simple_hash_to_string(h,separator)
   end
   return concat(t,separator or ",")
 end
-local str=C((1-whitespace-equal)^1)
+local str=Cs(lpegpatterns.unquoted)+C((1-whitespace-equal)^1)
 local setting=Cf(Carg(1)*(whitespace^0*Cg(str*whitespace^0*(equal*whitespace^0*str+Cc(""))))^1,rawset)
 local splitter=setting^1
 function utilities.parsers.options_to_hash(str,target)
@@ -6940,7 +6940,7 @@ function parsers.rfc4180splitter(specification)
   local field=escaped+non_escaped+Cc("")
   local record=Ct(field*(separator*field)^1)
   local headerline=record*Cp()
-  local wholeblob=Ct((newline^-1*record)^0)
+  local wholeblob=Ct((newline^(specification.strict and -1 or 1)*record)^0)
   return function(data,getheader)
     if getheader then
       local header,position=lpegmatch(headerline,data)
@@ -9478,7 +9478,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["lxml-tab"] = package.loaded["lxml-tab"] or true
 
--- original size: 43805, stripped down to: 26812
+-- original size: 43882, stripped down to: 26870
 
 if not modules then modules={} end modules ['lxml-tab']={
   version=1.001,
@@ -10115,14 +10115,17 @@ function xml.checkbom(root)
     insert(dt,2,"\n" )
   end
 end
-local function verbose_element(e,handlers) 
+local f_attribute=formatters['%s=%q']
+local function verbose_element(e,handlers,escape) 
   local handle=handlers.handle
   local serialize=handlers.serialize
   local ens,etg,eat,edt,ern=e.ns,e.tg,e.at,e.dt,e.rn
   local ats=eat and next(eat) and {}
   if ats then
+    local n=0
     for k,v in next,eat do
-      ats[#ats+1]=formatters['%s=%q'](k,escaped(v))
+      n=n+1
+      ats[n]=f_attribute(k,escaped(v))
     end
   end
   if ern and trace_entities and ern~=ens then
@@ -16666,7 +16669,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["data-tre"] = package.loaded["data-tre"] or true
 
--- original size: 7987, stripped down to: 5309
+-- original size: 8479, stripped down to: 5580
 
 if not modules then modules={} end modules ['data-tre']={
   version=1.001,
@@ -16711,6 +16714,18 @@ function resolvers.finders.tree(specification)
           return fullname
         end
       end
+      local pattern=lower(pattern)
+      for i=1,#names do
+        local fullname=lower(names[i])
+        if find(fullname,pattern) then
+          if isfile(fullname) then
+            found[spec]=fullname
+            return fullname
+          else
+            break
+          end
+        end
+      end
     end
     okay=notfound() 
     found[spec]=okay
@@ -16731,9 +16746,7 @@ function resolvers.locators.tree(specification)
 end
 function resolvers.hashers.tree(specification)
   local name=specification.filename
-  if trace_locating then
-    report_trees("analysing %a",name)
-  end
+    report_trees("analyzing %a",name)
   resolvers.methodhandler("hashers",name)
   resolvers.generators.file(specification)
 end
@@ -17761,8 +17774,8 @@ end -- of closure
 
 -- used libraries    : l-lua.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-sto.lua util-prs.lua util-fmt.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-mrg.lua util-tpl.lua util-env.lua luat-env.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 744704
--- stripped bytes    : 272130
+-- original bytes    : 745333
+-- stripped bytes    : 272372
 
 -- end library merge
 
@@ -17988,6 +18001,7 @@ local helpinfo = [[
   <category name="basic">
    <subcategory>
     <flag name="script"><short>run an mtx script (lua prefered method) (<ref name="noquotes"/>), no script gives list</short></flag>
+    <flag name="evaluate"><short>run code passed on the commandline (between quotes)</short></flag>
     <flag name="execute"><short>run a script or program (texmfstart method) (<ref name="noquotes"/>)</short></flag>
     <flag name="resolve"><short>resolve prefixed arguments</short></flag>
     <flag name="ctxlua"><short>run internally (using preloaded libs)</short></flag>
@@ -18643,6 +18657,39 @@ function runners.associate(filename)
     os.launch(filename)
 end
 
+function runners.evaluate(code,filename) -- for Luigi
+    if code == "loop" then
+        while true do
+            io.write("> ")
+            local code = io.read()
+            if code ~= "" then
+                local temp = string.match(code,"^= (.*)$")
+                if temp then
+                    code = "print("..temp..")"
+                end
+                local compiled, message = loadstring(code)
+                if type(compiled) ~= "function" then
+                    io.write("! " .. (message or code).."\n")
+                else
+                    io.write(compiled())
+                end
+            end
+        end
+    else
+        if type(code) ~= "string" or code == "" then
+            code = filename
+        end
+        if code ~= "" then
+            local compiled, message = loadstring(code)
+            if type(compiled) ~= "function" then
+                io.write("invalid lua code: " .. (message or code))
+                return
+            end
+            io.write(compiled())
+        end
+    end
+end
+
 function runners.gethelp(filename)
     local url = environment.argument("url")
     if url and url ~= "" then
@@ -18803,6 +18850,10 @@ if e_argument("script") or e_argument("scripts") then
         ok = runners.execute_ctx_script(filename)
     end
 
+elseif e_argument("evaluate") then
+
+    runners.evaluate(e_argument("evaluate"),filename)
+
 elseif e_argument("selfmerge") then
 
     -- embed used libraries
diff --git a/scripts/context/stubs/mswin/mtxrun.lua b/scripts/context/stubs/mswin/mtxrun.lua
index 0ac7e5013..c9096d81e 100644
--- a/scripts/context/stubs/mswin/mtxrun.lua
+++ b/scripts/context/stubs/mswin/mtxrun.lua
@@ -6558,7 +6558,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 21550, stripped down to: 14916
+-- original size: 21610, stripped down to: 14974
 
 if not modules then modules={} end modules ['util-prs']={
   version=1.001,
@@ -6813,7 +6813,7 @@ function parsers.simple_hash_to_string(h,separator)
   end
   return concat(t,separator or ",")
 end
-local str=C((1-whitespace-equal)^1)
+local str=Cs(lpegpatterns.unquoted)+C((1-whitespace-equal)^1)
 local setting=Cf(Carg(1)*(whitespace^0*Cg(str*whitespace^0*(equal*whitespace^0*str+Cc(""))))^1,rawset)
 local splitter=setting^1
 function utilities.parsers.options_to_hash(str,target)
@@ -6940,7 +6940,7 @@ function parsers.rfc4180splitter(specification)
   local field=escaped+non_escaped+Cc("")
   local record=Ct(field*(separator*field)^1)
   local headerline=record*Cp()
-  local wholeblob=Ct((newline^-1*record)^0)
+  local wholeblob=Ct((newline^(specification.strict and -1 or 1)*record)^0)
   return function(data,getheader)
     if getheader then
       local header,position=lpegmatch(headerline,data)
@@ -9478,7 +9478,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["lxml-tab"] = package.loaded["lxml-tab"] or true
 
--- original size: 43805, stripped down to: 26812
+-- original size: 43882, stripped down to: 26870
 
 if not modules then modules={} end modules ['lxml-tab']={
   version=1.001,
@@ -10115,14 +10115,17 @@ function xml.checkbom(root)
     insert(dt,2,"\n" )
   end
 end
-local function verbose_element(e,handlers) 
+local f_attribute=formatters['%s=%q']
+local function verbose_element(e,handlers,escape) 
   local handle=handlers.handle
   local serialize=handlers.serialize
   local ens,etg,eat,edt,ern=e.ns,e.tg,e.at,e.dt,e.rn
   local ats=eat and next(eat) and {}
   if ats then
+    local n=0
     for k,v in next,eat do
-      ats[#ats+1]=formatters['%s=%q'](k,escaped(v))
+      n=n+1
+      ats[n]=f_attribute(k,escaped(v))
     end
   end
   if ern and trace_entities and ern~=ens then
@@ -16666,7 +16669,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["data-tre"] = package.loaded["data-tre"] or true
 
--- original size: 7987, stripped down to: 5309
+-- original size: 8479, stripped down to: 5580
 
 if not modules then modules={} end modules ['data-tre']={
   version=1.001,
@@ -16711,6 +16714,18 @@ function resolvers.finders.tree(specification)
           return fullname
         end
       end
+      local pattern=lower(pattern)
+      for i=1,#names do
+        local fullname=lower(names[i])
+        if find(fullname,pattern) then
+          if isfile(fullname) then
+            found[spec]=fullname
+            return fullname
+          else
+            break
+          end
+        end
+      end
     end
     okay=notfound() 
     found[spec]=okay
@@ -16731,9 +16746,7 @@ function resolvers.locators.tree(specification)
 end
 function resolvers.hashers.tree(specification)
   local name=specification.filename
-  if trace_locating then
-    report_trees("analysing %a",name)
-  end
+    report_trees("analyzing %a",name)
   resolvers.methodhandler("hashers",name)
   resolvers.generators.file(specification)
 end
@@ -17761,8 +17774,8 @@ end -- of closure
 
 -- used libraries    : l-lua.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-sto.lua util-prs.lua util-fmt.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-mrg.lua util-tpl.lua util-env.lua luat-env.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 744704
--- stripped bytes    : 272130
+-- original bytes    : 745333
+-- stripped bytes    : 272372
 
 -- end library merge
 
@@ -17988,6 +18001,7 @@ local helpinfo = [[
   <category name="basic">
    <subcategory>
     <flag name="script"><short>run an mtx script (lua prefered method) (<ref name="noquotes"/>), no script gives list</short></flag>
+    <flag name="evaluate"><short>run code passed on the commandline (between quotes)</short></flag>
     <flag name="execute"><short>run a script or program (texmfstart method) (<ref name="noquotes"/>)</short></flag>
     <flag name="resolve"><short>resolve prefixed arguments</short></flag>
     <flag name="ctxlua"><short>run internally (using preloaded libs)</short></flag>
@@ -18643,6 +18657,39 @@ function runners.associate(filename)
     os.launch(filename)
 end
 
+function runners.evaluate(code,filename) -- for Luigi
+    if code == "loop" then
+        while true do
+            io.write("> ")
+            local code = io.read()
+            if code ~= "" then
+                local temp = string.match(code,"^= (.*)$")
+                if temp then
+                    code = "print("..temp..")"
+                end
+                local compiled, message = loadstring(code)
+                if type(compiled) ~= "function" then
+                    io.write("! " .. (message or code).."\n")
+                else
+                    io.write(compiled())
+                end
+            end
+        end
+    else
+        if type(code) ~= "string" or code == "" then
+            code = filename
+        end
+        if code ~= "" then
+            local compiled, message = loadstring(code)
+            if type(compiled) ~= "function" then
+                io.write("invalid lua code: " .. (message or code))
+                return
+            end
+            io.write(compiled())
+        end
+    end
+end
+
 function runners.gethelp(filename)
     local url = environment.argument("url")
     if url and url ~= "" then
@@ -18803,6 +18850,10 @@ if e_argument("script") or e_argument("scripts") then
         ok = runners.execute_ctx_script(filename)
     end
 
+elseif e_argument("evaluate") then
+
+    runners.evaluate(e_argument("evaluate"),filename)
+
 elseif e_argument("selfmerge") then
 
     -- embed used libraries
diff --git a/scripts/context/stubs/unix/mtxrun b/scripts/context/stubs/unix/mtxrun
index 0ac7e5013..c9096d81e 100644
--- a/scripts/context/stubs/unix/mtxrun
+++ b/scripts/context/stubs/unix/mtxrun
@@ -6558,7 +6558,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 21550, stripped down to: 14916
+-- original size: 21610, stripped down to: 14974
 
 if not modules then modules={} end modules ['util-prs']={
   version=1.001,
@@ -6813,7 +6813,7 @@ function parsers.simple_hash_to_string(h,separator)
   end
   return concat(t,separator or ",")
 end
-local str=C((1-whitespace-equal)^1)
+local str=Cs(lpegpatterns.unquoted)+C((1-whitespace-equal)^1)
 local setting=Cf(Carg(1)*(whitespace^0*Cg(str*whitespace^0*(equal*whitespace^0*str+Cc(""))))^1,rawset)
 local splitter=setting^1
 function utilities.parsers.options_to_hash(str,target)
@@ -6940,7 +6940,7 @@ function parsers.rfc4180splitter(specification)
   local field=escaped+non_escaped+Cc("")
   local record=Ct(field*(separator*field)^1)
   local headerline=record*Cp()
-  local wholeblob=Ct((newline^-1*record)^0)
+  local wholeblob=Ct((newline^(specification.strict and -1 or 1)*record)^0)
   return function(data,getheader)
     if getheader then
       local header,position=lpegmatch(headerline,data)
@@ -9478,7 +9478,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["lxml-tab"] = package.loaded["lxml-tab"] or true
 
--- original size: 43805, stripped down to: 26812
+-- original size: 43882, stripped down to: 26870
 
 if not modules then modules={} end modules ['lxml-tab']={
   version=1.001,
@@ -10115,14 +10115,17 @@ function xml.checkbom(root)
     insert(dt,2,"\n" )
   end
 end
-local function verbose_element(e,handlers) 
+local f_attribute=formatters['%s=%q']
+local function verbose_element(e,handlers,escape) 
   local handle=handlers.handle
   local serialize=handlers.serialize
   local ens,etg,eat,edt,ern=e.ns,e.tg,e.at,e.dt,e.rn
   local ats=eat and next(eat) and {}
   if ats then
+    local n=0
     for k,v in next,eat do
-      ats[#ats+1]=formatters['%s=%q'](k,escaped(v))
+      n=n+1
+      ats[n]=f_attribute(k,escaped(v))
     end
   end
   if ern and trace_entities and ern~=ens then
@@ -16666,7 +16669,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["data-tre"] = package.loaded["data-tre"] or true
 
--- original size: 7987, stripped down to: 5309
+-- original size: 8479, stripped down to: 5580
 
 if not modules then modules={} end modules ['data-tre']={
   version=1.001,
@@ -16711,6 +16714,18 @@ function resolvers.finders.tree(specification)
           return fullname
         end
       end
+      local pattern=lower(pattern)
+      for i=1,#names do
+        local fullname=lower(names[i])
+        if find(fullname,pattern) then
+          if isfile(fullname) then
+            found[spec]=fullname
+            return fullname
+          else
+            break
+          end
+        end
+      end
     end
     okay=notfound() 
     found[spec]=okay
@@ -16731,9 +16746,7 @@ function resolvers.locators.tree(specification)
 end
 function resolvers.hashers.tree(specification)
   local name=specification.filename
-  if trace_locating then
-    report_trees("analysing %a",name)
-  end
+    report_trees("analyzing %a",name)
   resolvers.methodhandler("hashers",name)
   resolvers.generators.file(specification)
 end
@@ -17761,8 +17774,8 @@ end -- of closure
 
 -- used libraries    : l-lua.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-sto.lua util-prs.lua util-fmt.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-mrg.lua util-tpl.lua util-env.lua luat-env.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 744704
--- stripped bytes    : 272130
+-- original bytes    : 745333
+-- stripped bytes    : 272372
 
 -- end library merge
 
@@ -17988,6 +18001,7 @@ local helpinfo = [[
   <category name="basic">
    <subcategory>
     <flag name="script"><short>run an mtx script (lua prefered method) (<ref name="noquotes"/>), no script gives list</short></flag>
+    <flag name="evaluate"><short>run code passed on the commandline (between quotes)</short></flag>
     <flag name="execute"><short>run a script or program (texmfstart method) (<ref name="noquotes"/>)</short></flag>
     <flag name="resolve"><short>resolve prefixed arguments</short></flag>
     <flag name="ctxlua"><short>run internally (using preloaded libs)</short></flag>
@@ -18643,6 +18657,39 @@ function runners.associate(filename)
     os.launch(filename)
 end
 
+function runners.evaluate(code,filename) -- for Luigi
+    if code == "loop" then
+        while true do
+            io.write("> ")
+            local code = io.read()
+            if code ~= "" then
+                local temp = string.match(code,"^= (.*)$")
+                if temp then
+                    code = "print("..temp..")"
+                end
+                local compiled, message = loadstring(code)
+                if type(compiled) ~= "function" then
+                    io.write("! " .. (message or code).."\n")
+                else
+                    io.write(compiled())
+                end
+            end
+        end
+    else
+        if type(code) ~= "string" or code == "" then
+            code = filename
+        end
+        if code ~= "" then
+            local compiled, message = loadstring(code)
+            if type(compiled) ~= "function" then
+                io.write("invalid lua code: " .. (message or code))
+                return
+            end
+            io.write(compiled())
+        end
+    end
+end
+
 function runners.gethelp(filename)
     local url = environment.argument("url")
     if url and url ~= "" then
@@ -18803,6 +18850,10 @@ if e_argument("script") or e_argument("scripts") then
         ok = runners.execute_ctx_script(filename)
     end
 
+elseif e_argument("evaluate") then
+
+    runners.evaluate(e_argument("evaluate"),filename)
+
 elseif e_argument("selfmerge") then
 
     -- embed used libraries
diff --git a/scripts/context/stubs/win64/mtxrun.lua b/scripts/context/stubs/win64/mtxrun.lua
index 0ac7e5013..c9096d81e 100644
--- a/scripts/context/stubs/win64/mtxrun.lua
+++ b/scripts/context/stubs/win64/mtxrun.lua
@@ -6558,7 +6558,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 21550, stripped down to: 14916
+-- original size: 21610, stripped down to: 14974
 
 if not modules then modules={} end modules ['util-prs']={
   version=1.001,
@@ -6813,7 +6813,7 @@ function parsers.simple_hash_to_string(h,separator)
   end
   return concat(t,separator or ",")
 end
-local str=C((1-whitespace-equal)^1)
+local str=Cs(lpegpatterns.unquoted)+C((1-whitespace-equal)^1)
 local setting=Cf(Carg(1)*(whitespace^0*Cg(str*whitespace^0*(equal*whitespace^0*str+Cc(""))))^1,rawset)
 local splitter=setting^1
 function utilities.parsers.options_to_hash(str,target)
@@ -6940,7 +6940,7 @@ function parsers.rfc4180splitter(specification)
   local field=escaped+non_escaped+Cc("")
   local record=Ct(field*(separator*field)^1)
   local headerline=record*Cp()
-  local wholeblob=Ct((newline^-1*record)^0)
+  local wholeblob=Ct((newline^(specification.strict and -1 or 1)*record)^0)
   return function(data,getheader)
     if getheader then
       local header,position=lpegmatch(headerline,data)
@@ -9478,7 +9478,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["lxml-tab"] = package.loaded["lxml-tab"] or true
 
--- original size: 43805, stripped down to: 26812
+-- original size: 43882, stripped down to: 26870
 
 if not modules then modules={} end modules ['lxml-tab']={
   version=1.001,
@@ -10115,14 +10115,17 @@ function xml.checkbom(root)
     insert(dt,2,"\n" )
   end
 end
-local function verbose_element(e,handlers) 
+local f_attribute=formatters['%s=%q']
+local function verbose_element(e,handlers,escape) 
   local handle=handlers.handle
   local serialize=handlers.serialize
   local ens,etg,eat,edt,ern=e.ns,e.tg,e.at,e.dt,e.rn
   local ats=eat and next(eat) and {}
   if ats then
+    local n=0
     for k,v in next,eat do
-      ats[#ats+1]=formatters['%s=%q'](k,escaped(v))
+      n=n+1
+      ats[n]=f_attribute(k,escaped(v))
     end
   end
   if ern and trace_entities and ern~=ens then
@@ -16666,7 +16669,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["data-tre"] = package.loaded["data-tre"] or true
 
--- original size: 7987, stripped down to: 5309
+-- original size: 8479, stripped down to: 5580
 
 if not modules then modules={} end modules ['data-tre']={
   version=1.001,
@@ -16711,6 +16714,18 @@ function resolvers.finders.tree(specification)
           return fullname
         end
       end
+      local pattern=lower(pattern)
+      for i=1,#names do
+        local fullname=lower(names[i])
+        if find(fullname,pattern) then
+          if isfile(fullname) then
+            found[spec]=fullname
+            return fullname
+          else
+            break
+          end
+        end
+      end
     end
     okay=notfound() 
     found[spec]=okay
@@ -16731,9 +16746,7 @@ function resolvers.locators.tree(specification)
 end
 function resolvers.hashers.tree(specification)
   local name=specification.filename
-  if trace_locating then
-    report_trees("analysing %a",name)
-  end
+    report_trees("analyzing %a",name)
   resolvers.methodhandler("hashers",name)
   resolvers.generators.file(specification)
 end
@@ -17761,8 +17774,8 @@ end -- of closure
 
 -- used libraries    : l-lua.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-sto.lua util-prs.lua util-fmt.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-mrg.lua util-tpl.lua util-env.lua luat-env.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 744704
--- stripped bytes    : 272130
+-- original bytes    : 745333
+-- stripped bytes    : 272372
 
 -- end library merge
 
@@ -17988,6 +18001,7 @@ local helpinfo = [[
   <category name="basic">
    <subcategory>
     <flag name="script"><short>run an mtx script (lua prefered method) (<ref name="noquotes"/>), no script gives list</short></flag>
+    <flag name="evaluate"><short>run code passed on the commandline (between quotes)</short></flag>
     <flag name="execute"><short>run a script or program (texmfstart method) (<ref name="noquotes"/>)</short></flag>
     <flag name="resolve"><short>resolve prefixed arguments</short></flag>
     <flag name="ctxlua"><short>run internally (using preloaded libs)</short></flag>
@@ -18643,6 +18657,39 @@ function runners.associate(filename)
     os.launch(filename)
 end
 
+function runners.evaluate(code,filename) -- for Luigi
+    if code == "loop" then
+        while true do
+            io.write("> ")
+            local code = io.read()
+            if code ~= "" then
+                local temp = string.match(code,"^= (.*)$")
+                if temp then
+                    code = "print("..temp..")"
+                end
+                local compiled, message = loadstring(code)
+                if type(compiled) ~= "function" then
+                    io.write("! " .. (message or code).."\n")
+                else
+                    io.write(compiled())
+                end
+            end
+        end
+    else
+        if type(code) ~= "string" or code == "" then
+            code = filename
+        end
+        if code ~= "" then
+            local compiled, message = loadstring(code)
+            if type(compiled) ~= "function" then
+                io.write("invalid lua code: " .. (message or code))
+                return
+            end
+            io.write(compiled())
+        end
+    end
+end
+
 function runners.gethelp(filename)
     local url = environment.argument("url")
     if url and url ~= "" then
@@ -18803,6 +18850,10 @@ if e_argument("script") or e_argument("scripts") then
         ok = runners.execute_ctx_script(filename)
     end
 
+elseif e_argument("evaluate") then
+
+    runners.evaluate(e_argument("evaluate"),filename)
+
 elseif e_argument("selfmerge") then
 
     -- embed used libraries
diff --git a/tex/context/base/anch-bck.mkvi b/tex/context/base/anch-bck.mkvi
index cccf14ee4..273cf0159 100644
--- a/tex/context/base/anch-bck.mkvi
+++ b/tex/context/base/anch-bck.mkvi
@@ -20,10 +20,6 @@
 
 \unprotect
 
-% we can flush 5 in one call (saved 4 lua calls) .. brrr wself .. will change
-
-\def\MPposset#1{\ctxcommand{MPposset("#1")}} % will go
-
 % This might be overloaded later on:
 
 % \defineoverlay[\v!text-2][\positionoverlay{\v!text-2}]
@@ -50,7 +46,7 @@
 % tricky: we need to catch newly set! otherwise an old run can have positions
 
 \unexpanded\def\anch_backgrounds_text_initialize
-  {\ctxcommand{doifelsepositionsused()}\enableparpositions\donothing
+  {\doifelsepositionsused\enableparpositions\donothing
    \global\let\anch_backgrounds_text_initialize\relax}
 
 \appendtoks
diff --git a/tex/context/base/anch-pgr.lua b/tex/context/base/anch-pgr.lua
index 7c8c4545f..198e8a499 100644
--- a/tex/context/base/anch-pgr.lua
+++ b/tex/context/base/anch-pgr.lua
@@ -19,6 +19,10 @@ local lpegmatch = lpeg.match
 local jobpositions = job.positions
 local formatters   = string.formatters
 
+local scanstring   = tokens.scanstring
+local scannumber   = tokens.scannumber
+local scandimen    = tokens.scandimen
+
 local report_graphics = logs.reporter("graphics")
 
 local f_b_tag   = formatters["b:%s"]
@@ -552,7 +556,7 @@ f_template_b = formatters[f_template_b]
 f_template_c = formatters[f_template_c]
 f_template_d = formatters[f_template_d]
 
-function backgrounds.fetchmultipar(n,anchor,page,obeyhang)
+local function fetchmultipar(n,anchor,page,obeyhang)
     local data = pbg[n]
     if not data then
         data = calculatemultipar(n,obeyhang)
@@ -596,16 +600,18 @@ function backgrounds.fetchmultipar(n,anchor,page,obeyhang)
     return f_template_a(0,"origin",0,0,0)
 end
 
+backgrounds.fetchmultipar = fetchmultipar
+
 backgrounds.point = f_point
 backgrounds.pair  = f_pair
 backgrounds.path  = f_path
 
 function commands.fetchmultipar(n,anchor,page)
-    context(backgrounds.fetchmultipar(n,anchor,page))
+    context(fetchmultipar(n,anchor,page))
 end
 
 function commands.fetchmultishape(n,anchor,page)
-    context(backgrounds.fetchmultipar(n,anchor,page,true))
+    context(fetchmultipar(n,anchor,page,true))
 end
 
 local f_template_a = [[
diff --git a/tex/context/base/anch-pos.mkiv b/tex/context/base/anch-pos.mkiv
index a87a32c06..f91dfb0f9 100644
--- a/tex/context/base/anch-pos.mkiv
+++ b/tex/context/base/anch-pos.mkiv
@@ -281,6 +281,9 @@
 \unexpanded\def\anch_mark_text_box#1%
   {\ctxcommand{markregionbox(\number#1,"\textanchor")}} % needs an hbox
 
+\unexpanded\def\anch_mark_tagged_box#1#2%
+  {\ctxcommand{markregionbox(\number#1,"#2")}} % needs an hbox
+
 %D We can copy a position with:
 %D
 %D \starttyping
diff --git a/tex/context/base/back-exp.lua b/tex/context/base/back-exp.lua
index 0c99a6fd5..d4c252384 100644
--- a/tex/context/base/back-exp.lua
+++ b/tex/context/base/back-exp.lua
@@ -364,15 +364,15 @@ local styletemplate = [[
         local hyphen   = finetuning.hyphen
         local align    = finetuning.align
         --
-        if not bodyfont or bodyfont == "" then
+        if type(bodyfont) == "number" then
+            bodyfont = todimen(bodyfont)
+        else
             bodyfont = "12pt"
-        elseif type(bodyfont) == "number" then
-            bodyfont = todimen(bodyfont,"pt","%ipt") or "12pt"
         end
-        if not width or width == "" then
+        if type(width) == "number" then
+            width = todimen(width) or "50em"
+        else
             width = "50em"
-        elseif type(width) == "number" then
-            width = todimen(width,"pt","%ipt") or "50em"
         end
         if hyphen == v_yes then
             hyphen = "manual"
@@ -422,39 +422,50 @@ do
 local imagetemplate = [[
 %element%[id="%id%"], div.%element%[id="%id%"] {
     display           : block ;
-    background-image  : url(%url%) ;
+    background-image  : url('%url%') ;
     background-size   : 100%% auto ;
     background-repeat : no-repeat ;
     width             : %width% ;
     height            : %height% ;
 }]]
 
+    local f_svgname = formatters["%s.svg"]
+    local f_svgpage = formatters["%s-page-%s.svg"]
+    local collected = { }
 
-    local function substitute(name)
+    local function usedname(name,page)
         if file.suffix(name) == "pdf" then
             -- temp hack .. we will have a remapper
-            return file.replacesuffix(name,"svg")
+            if page and page > 1 then
+                name = f_svgpage(file.nameonly(name),page)
+            else
+                name = f_svgname(file.nameonly(name))
+            end
+        end
+        local scheme = url.hasscheme(name)
+        if not scheme or scheme == "file" then
+            -- or can we just use the name ?
+            return file.join("../images",file.basename(url.filename(name)))
         else
             return name
         end
     end
 
-    local collected = { }
-
     function wrapups.allusedimages(basename)
         local result = { formatters["/* %s for file %s */"]("images",basename) }
         for element, details in sortedhash(usedimages) do
             for detail, data in sortedhash(details) do
                 local name = data.name
+                local page = tonumber(data.page) or 1
                 local spec = {
                     element = element,
                     id      = data.id,
                     name    = name,
-                    url     = url.addscheme(substitute(name)),
+                    page    = page,
+                    url     = usedname(name,page),
                     width   = data.width,
                     height  = data.height,
                     used    = data.used,
-                    page    = data.page,
                 }
                 result[#result+1] = replacetemplate(imagetemplate,spec)
                 collected[detail] = spec
@@ -725,8 +736,8 @@ do
             name   = name,
             used   = used,
             page   = page and page > 1 and page or nil,
-            width  = todimen(width, "cm","%0.3Fcm"),
-            height = todimen(height,"cm","%0.3Fcm"),
+            width  = todimen(width, "cm","%0.3F%s"),
+            height = todimen(height,"cm","%0.3F%s"),
         }
     end
 
@@ -2511,13 +2522,17 @@ local function collectresults(head,list,pat,pap) -- is last used (we also have c
                                     nofcurrentcontent = nofcurrentcontent + 1
                                     currentcontent[nofcurrentcontent] = utfchar(u)
                                 end
-                            else -- weird, happens in hz (we really need to get rid of the pseudo fonts)
+                            elseif c > 0 then
                                 nofcurrentcontent = nofcurrentcontent + 1
                                 currentcontent[nofcurrentcontent] = utfchar(c)
+                            else
+                                -- we can have -1 as side effect of an explicit hyphen (unless we expand)
                             end
-                        else
+                        elseif c > 0 then
                             nofcurrentcontent = nofcurrentcontent + 1
                             currentcontent[nofcurrentcontent] = utfchar(c)
+                        else
+                            -- we can have -1 as side effect of an explicit hyphen (unless we expand)
                         end
                     end
                 end
diff --git a/tex/context/base/blob-ini.lua b/tex/context/base/blob-ini.lua
index 32fac7662..7c30131bc 100644
--- a/tex/context/base/blob-ini.lua
+++ b/tex/context/base/blob-ini.lua
@@ -199,14 +199,3 @@ function commands.strwd(str) context(strwd(str)) end
 function commands.strht(str) context(strht(str)) end
 function commands.strdp(str) context(strdp(str)) end
 function commands.strhd(str) context(strhd(str)) end
-
--- less efficient:
---
--- function commands.widthof(str)
---     local b = blobs.new()
---     blobs.append(b,str)
---     blobs.pack(b)
---     local w = blobs.dimensions(b)
---     context(number.todimen(w))
---     blobs.dispose(b)
--- end
diff --git a/tex/context/base/buff-ini.lua b/tex/context/base/buff-ini.lua
index 040aa731e..9954ad39f 100644
--- a/tex/context/base/buff-ini.lua
+++ b/tex/context/base/buff-ini.lua
@@ -257,6 +257,8 @@ local function undent(str) -- new version, needs testing: todo: not always neede
     return lpegmatch(stripper,str) or str
 end
 
+buffers.undent = undent
+
 function commands.grabbuffer(name,begintag,endtag,bufferdata,catcodes,doundent) -- maybe move \\ to call
     local dn = getcontent(name)
     if dn == "" then
diff --git a/tex/context/base/buff-ver.lua b/tex/context/base/buff-ver.lua
index 832c14122..7e7120eae 100644
--- a/tex/context/base/buff-ver.lua
+++ b/tex/context/base/buff-ver.lua
@@ -624,14 +624,16 @@ end
 
 local function getrange(lines,first,last,range) -- 1,3 1,+3 fromhere,tothere
     local noflines = #lines
-    local first, last = first or 1, last or noflines
+    local first    = first or 1
+    local last     = last or noflines
     if last < 0 then
         last = noflines + last
     end
-    local range = settings.range
     local what = settings_to_array(range)
-    local r_first, r_last = what[1], what[2]
-    local f, l = tonumber(r_first), tonumber(r_last)
+    local r_first = what[1]
+    local r_last  = what[2]
+    local f       = tonumber(r_first)
+    local l       = tonumber(r_last)
     if r_first then
         if f then
             if f > first then
@@ -688,6 +690,7 @@ local function filter(lines,settings) -- todo: inline or display in settings
     end
     local line, n = 0, 0
     local first, last, m = getstrip(lines)
+    local range = settings.range
     if range then
         first, last = getrange(lines,first,last,range)
         first, last = getstrip(lines,first,last)
diff --git a/tex/context/base/buff-ver.mkiv b/tex/context/base/buff-ver.mkiv
index 019e645c4..1e5a9e690 100644
--- a/tex/context/base/buff-ver.mkiv
+++ b/tex/context/base/buff-ver.mkiv
@@ -332,8 +332,9 @@
      tab     = "\typeparameter\c!tab",
      method  = "\typeparameter\c!option",
      nature  = "inline",
-     compact = "\typeparameter\c!compact", % none | all | last (all needed in tabulate etc for manuals)
-    }}%
+     compact = "\typeparameter\c!compact",        % none | all | last (all needed in tabulate etc for manuals)
+     escape  = \!!bs\typeparameter\c!escape\!!es, % new but rather useless imo (escaping in general is not used much)
+   }}%
    \dostoptagged
    \buff_verbatim_right_of_type
    \egroup}
diff --git a/tex/context/base/char-fio.lua b/tex/context/base/char-fio.lua
index 766ea7123..4f091ebec 100644
--- a/tex/context/base/char-fio.lua
+++ b/tex/context/base/char-fio.lua
@@ -6,6 +6,11 @@ if not modules then modules = { } end modules ['char-fio'] = {
     license   = "see context related readme files"
 }
 
+-- % directives="filters.utf.reorder=false"
+
+
+local next = next
+
 -- --
 
 local sequencers      = utilities.sequencers
@@ -30,19 +35,46 @@ disableaction(textfileactions,         "characters.filters.utf.collapse")
 appendaction (textfileactions,"system","characters.filters.utf.decompose")
 disableaction(textfileactions,         "characters.filters.utf.decompose")
 
+local report    = logs.reporter("unicode filter")
+local reporting = "no"
+
+-- this is messy as for performance reasons i don't want this to happen
+-- per line by default
+
+local enforced = {
+    ["characters.filters.utf.reorder"]   = true,
+    ["characters.filters.utf.collapse"]  = true,
+    ["characters.filters.utf.decompose"] = true,
+}
+
 function characters.filters.utf.enable()
-    enableaction(textfileactions,"characters.filters.utf.reorder")
-    enableaction(textfileactions,"characters.filters.utf.collapse")
-    enableaction(textfileactions,"characters.filters.utf.decompose")
+    for k, v in next, enforced do
+        if v then
+            if reporting == "yes" then
+                report("%a enabled",k)
+            end
+            enableaction(textfileactions,v)
+        else
+            if reporting == "yes" then
+                report("%a not enabled",k)
+            end
+        end
+    end
+    reporting = "never"
 end
 
 local function configure(what,v)
-    if not v then
-        disableaction(textfileactions,what)
-        disableaction(textlineactions,what)
-    elseif v == "line" then
+    if v == "line" then
         disableaction(textfileactions,what)
         enableaction (textlineactions,what)
+    elseif not toboolean(v) then
+        if reporting ~= "never" then
+            report("%a disabled",k)
+            reporting = "yes"
+        end
+        enforced[what] = false
+        disableaction(textfileactions,what)
+        disableaction(textlineactions,what)
     else -- true or text
         enableaction (textfileactions,what)
         disableaction(textlineactions,what)
diff --git a/tex/context/base/char-ini.lua b/tex/context/base/char-ini.lua
index 267b51b46..0f632935d 100644
--- a/tex/context/base/char-ini.lua
+++ b/tex/context/base/char-ini.lua
@@ -945,6 +945,7 @@ if not characters.lhash then
      -- if k < 0x11000 then
             local l = v.lccode
             if l then
+                -- we have an uppercase
                 if type(l) == "number" then
                     lhash[utfchar(k)] = utfchar(l)
                 elseif #l == 2 then
@@ -955,6 +956,7 @@ if not characters.lhash then
             else
                 local u = v.uccode
                 if u then
+                    -- we have an lowercase
                     if type(u) == "number" then
                         uhash[utfchar(k)] = utfchar(u)
                     elseif #u == 2 then
@@ -979,8 +981,8 @@ if not characters.lhash then
 
     if storage then
         storage.register("characters/lhash", lhash, "characters.lhash")
-        storage.register("characters/uhash", lhash, "characters.uhash")
-        storage.register("characters/shash", lhash, "characters.shash")
+        storage.register("characters/uhash", uhash, "characters.uhash")
+        storage.register("characters/shash", shash, "characters.shash")
     end
 
 end
diff --git a/tex/context/base/char-tex.lua b/tex/context/base/char-tex.lua
index 5ca8eea05..e03307cc3 100644
--- a/tex/context/base/char-tex.lua
+++ b/tex/context/base/char-tex.lua
@@ -225,6 +225,16 @@ local accentmapping = allocate {
         O = "Õ", o = "õ",
         U = "Ũ", u = "ũ",
     },
+    ["o"] = { [""] = "ø",
+    },
+    ["O"] = { [""] = "Ø",
+    },
+    ["a"] = {
+        ["a"] = "å",
+    },
+    ["A"] = {
+        ["A"] = "Å",
+    },
 }
 
 texcharacters.accentmapping = accentmapping
diff --git a/tex/context/base/chem-str.lua b/tex/context/base/chem-str.lua
index cd7a2db06..6c1d3b837 100644
--- a/tex/context/base/chem-str.lua
+++ b/tex/context/base/chem-str.lua
@@ -60,6 +60,8 @@ local mpnamedcolor = attributes.colors.mpnamedcolor
 local topoints     = number.topoints
 local todimen      = string.todimen
 
+local trialtypesetting = context.trialtypesetting
+
 chemistry = chemistry or { }
 local chemistry = chemistry
 
@@ -422,7 +424,11 @@ local function process(level,spec,text,n,rulethickness,rulecolor,offset,default_
                 insert(sstack,variant)
                 m = m + 1 ; metacode[m] = syntax.save.direct
             elseif operation == "restore" then
-                variant = remove(sstack)
+                if #sstack > 0 then
+                    variant = remove(sstack)
+                else
+                    report_chemistry("restore without save")
+                end
                 local ss = syntax[variant]
                 keys, max = ss.keys, ss.max
                 m = m + 1 ; metacode[m] = syntax.restore.direct
@@ -721,7 +727,7 @@ function chemistry.start(settings)
     width,  left,   right, sp_width  = calculated(width, left,  right,bondlength,unit,scale)
     height, bottom, top,   sp_height = calculated(height,bottom,top,  bondlength,unit,scale)
     --
-    if width ~= "true" and height ~= "true" and texgetcount("@@trialtypesetting") ~= 0 then
+    if width ~= "true" and height ~= "true" and trialtypesetting() then
         if trace_structure then
             report_chemistry("skipping trial run")
         end
diff --git a/tex/context/base/chem-str.mkiv b/tex/context/base/chem-str.mkiv
index 6aec16f9e..801683cfd 100644
--- a/tex/context/base/chem-str.mkiv
+++ b/tex/context/base/chem-str.mkiv
@@ -67,7 +67,7 @@
   [\s!format=metafun,
   %\s!extensions=\v!yes,      % Should we add extensions and initializations?
   %\s!initializations=\v!yes, % Would this give EmWidth, etc.?
-  ]
+   \c!method=\s!double]
 
 \startMPdefinitions{chemistry}
     input mp-chem.mpiv ;
@@ -720,7 +720,7 @@
    \c!rotation=0,    % unitless number (interpreted as degrees)
    \c!symalign=\v!auto,
    \c!location=,     % not yet used (was interaction related in mkii)
-   \c!offset=.25em,
+   \c!offset=.25\emwidth,
    \c!unit=\emwidth,
    \c!factor=3,
    \c!color=,
diff --git a/tex/context/base/cldf-ini.lua b/tex/context/base/cldf-ini.lua
index ff466586f..62158e08b 100644
--- a/tex/context/base/cldf-ini.lua
+++ b/tex/context/base/cldf-ini.lua
@@ -32,19 +32,23 @@ if not modules then modules = { } end modules ['cldf-ini'] = {
 -- context(string.formatters["%!tex!"]("${}"))
 -- context("%!tex!","${}")
 
-local tex = tex
-
-context       = context or { }
-local context = context
-
-local format, gsub, validstring, stripstring = string.format, string.gsub, string.valid, string.strip
-local next, type, tostring, tonumber, setmetatable, unpack, select = next, type, tostring, tonumber, setmetatable, unpack, select
+local format, validstring, stripstring = string.format, string.valid, string.strip
+local next, type, tostring, tonumber, setmetatable, unpack, select, rawset = next, type, tostring, tonumber, setmetatable, unpack, select, rawset
 local insert, remove, concat = table.insert, table.remove, table.concat
 local lpegmatch, lpegC, lpegS, lpegP, lpegV, lpegCc, lpegCs, patterns = lpeg.match, lpeg.C, lpeg.S, lpeg.P, lpeg.V, lpeg.Cc, lpeg.Cs, lpeg.patterns
-local formatters = string.formatters -- using formatteds is slower in this case
+local formatters = string.formatters -- using formatters is slower in this case
+
+context                 = context    or { }
+commands                = commands   or { }
+interfaces              = interfaces or { }
+
+local context           = context
+local commands          = commands
+local interfaces        = interfaces
 
 local loaddata          = io.loaddata
 
+local tex               = tex
 local texsprint         = tex.sprint
 local texprint          = tex.print
 local texwrite          = tex.write
@@ -87,7 +91,7 @@ local storefunction, flushfunction
 local storenode, flushnode
 local registerfunction, unregisterfunction, reservefunction, knownfunctions, callfunctiononce
 
-if luafunctions then
+-- if luafunctions then
 
     local freed, nofused, noffreed = { }, 0, 0 -- maybe use the number of @@trialtypesetting
 
@@ -148,26 +152,123 @@ if luafunctions then
         end
     end
 
-    registerfunction = function(f)
-        if type(f) == "string" then
-            f = loadstring(f)
+ -- registerfunction = function(f)
+ --     if type(f) == "string" then
+ --         f = loadstring(f)
+ --     end
+ --     if type(f) ~= "function" then
+ --         f = function() report_cld("invalid function %A",f) end
+ --     end
+ --     if noffreed > 0 then
+ --         local n = freed[noffreed]
+ --         freed[noffreed] = nil
+ --         noffreed = noffreed - 1
+ --         luafunctions[n] = f
+ --         return n
+ --     else
+ --         nofused = nofused + 1
+ --         luafunctions[nofused] = f
+ --         return nofused
+ --     end
+ -- end
+
+    storage.storedfunctions = storage.storedfunctions or { }
+    local storedfunctions   = storage.storedfunctions
+    local initex            = environment.initex
+
+    storage.register("storage/storedfunctions", storedfunctions, "storage.storedfunctions")
+
+    local f_resolve = nil
+    local p_resolve  = ((1-lpegP("."))^1 / function(s) f_resolve = f_resolve[s] end * lpegP(".")^0)^1
+
+    function resolvestoredfunction(str)
+        f_resolve = global
+        lpegmatch(p_resolve,str)
+        return f_resolve
+    end
+
+    local function expose(slot,f,...) -- so we can register yet undefined functions
+        local func = resolvestoredfunction(f)
+        if not func then
+            func = function() report_cld("beware: unknown function %i called: %s",slot,f) end
         end
-        if type(f) ~= "function" then
-            f = function() report_cld("invalid function %A",f) end
+        luafunctions[slot] = func
+        return func(...)
+    end
+
+    if initex then
+        -- todo: log stored functions
+    else
+        local slots = table.sortedkeys(storedfunctions)
+        local last  = #slots
+        if last > 0 then
+            -- we restore the references
+            for i=1,last do
+                local slot = slots[i]
+                local data = storedfunctions[slot]
+                luafunctions[slot] = function(...)
+                    return expose(slot,data,...)
+                end
+            end
+            -- we now know how many are defined
+            nofused = slots[last]
+            -- normally there are no holes in the list yet
+            for i=1,nofused do
+                if not luafunctions[i] then
+                    noffreed = noffreed + 1
+                    freed[noffreed] = i
+                end
+            end
+         -- report_cld("%s registered functions, %s freed slots",last,noffreed)
         end
+    end
+
+    registerfunction = function(f,direct) -- either f=code or f=namespace,direct=name
+        local slot, func
         if noffreed > 0 then
-            local n = freed[noffreed]
+            slot = freed[noffreed]
             freed[noffreed] = nil
             noffreed = noffreed - 1
-            luafunctions[n] = f
-            return n
         else
             nofused = nofused + 1
-            luafunctions[nofused] = f
-            return nofused
+            slot = nofused
         end
+        if direct then
+            if initex then
+                func = function(...)
+                    expose(slot,f,...)
+                end
+                if initex then
+                    storedfunctions[slot] = f
+                end
+            else
+                func = resolvestoredfunction(f)
+            end
+            if type(func) ~= "function" then
+                func = function() report_cld("invalid resolve %A",f) end
+            end
+        elseif type(f) == "string" then
+            func = loadstring(f)
+            if type(func) ~= "function" then
+                func = function() report_cld("invalid code %A",f) end
+            end
+        elseif type(f) == "function" then
+            func = f
+        else
+            func = function() report_cld("invalid function %A",f) end
+        end
+        luafunctions[slot] = func
+        return slot
     end
 
+ -- do
+ --     commands.test = function(str) report_cld("test function: %s", str) end
+ --     if initex then
+ --         registerfunction("commands.test") -- number 1
+ --     end
+ --     luafunctions[1]("okay")
+ -- end
+
     unregisterfunction = function(slot)
         if luafunctions[slot] then
             noffreed = noffreed + 1
@@ -201,92 +302,116 @@ if luafunctions then
 
     knownfunctions = luafunctions
 
-else
-
-    local luafunctions, noffunctions = { }, 0
-    local luanodes, nofnodes = { }, 0
-
-    usedstack = function()
-        return noffunctions + nofnodes, 0
-    end
+    -- The next hack is a convenient way to define scanners at the Lua end and
+    -- get them available at the TeX end. There is some dirty magic needed to
+    -- prevent overload during format loading.
 
-    flushfunction = function(n)
-        local sn = luafunctions[n]
-        if not sn then
-            report_cld("data with id %a cannot be found on stack",n)
-        elseif not sn() and texgetcount("@@trialtypesetting") == 0 then  -- @@trialtypesetting is private!
-            luafunctions[n] = nil
-        end
-    end
+    -- interfaces.scanners.foo = function() context("[%s]",tokens.scanners.string()) end : \scan_foo
 
-    storefunction = function(ti)
-        noffunctions = noffunctions + 1
-        luafunctions[noffunctions] = ti
-        return noffunctions
-    end
+    interfaces.storedscanners = interfaces.storedscanners or { }
+    local storedscanners      = interfaces.storedscanners
 
- -- freefunction = function(n)
- --     luafunctions[n] = nil
- -- end
+    storage.register("interfaces/storedscanners", storedscanners, "interfaces.storedscanners")
 
-    flushnode = function(n)
-        local sn = luanodes[n]
-        if not sn then
-            report_cld("data with id %a cannot be found on stack",n)
-        elseif texgetcount("@@trialtypesetting") == 0 then  -- @@trialtypesetting is private!
-            writenode(sn)
-            luanodes[n] = nil
+    interfaces.scanners = table.setmetatablenewindex(function(t,k,v)
+        if storedscanners[k] then
+            -- \scan_<k> is already in the format
+         -- report_cld("using interface scanner: %s",k)
         else
-            writenode(copynodelist(sn))
+            -- todo: allocate slot here and pass it
+            storedscanners[k] = true
+         -- report_cld("installing interface scanner: %s",k)
+            context("\\installctxfunction{scan_%s}{interfaces.scanners.%s}",k,k)
         end
-    end
+        rawset(t,k,v)
+    end)
 
-    storenode = function(ti)
-        nofnodes = nofnodes + 1
-        luanodes[nofnodes] = ti
-        return nofnodes
-    end
-
-    _cldf_ = flushfunction -- global
-    _cldn_ = flushnode     -- global
- -- _cldl_ = function(n) return luafunctions[n]() end -- luafunctions(n)
-    _cldl_ = luafunctions
-
-    registerfunction = function(f)
-        if type(f) == "string" then
-            f = loadstring(f)
-        end
-        if type(f) ~= "function" then
-            f = function() report_cld("invalid function %A",f) end
-        end
-        noffunctions = noffunctions + 1
-        luafunctions[noffunctions] = f
-        return noffunctions
-    end
-
-    unregisterfunction = function(slot)
-        if luafunctions[slot] then
-            luafunctions[slot] = nil
-        else
-            report_cld("invalid function slot %A",slot)
-        end
-    end
-
-    reservefunction = function()
-        noffunctions = noffunctions + 1
-        return noffunctions
-    end
-
-    callfunctiononce = function(slot)
-        luafunctions[slot](slot)
-        luafunctions[slot] = nil
-    end
-
-    table.setmetatablecall(luafunctions,function(t,n) return luafunctions[n](n) end)
-
-    knownfunctions = luafunctions
-
-end
+-- else -- by now this is obsolete
+--
+--     local luafunctions, noffunctions = { }, 0
+--     local luanodes, nofnodes = { }, 0
+--
+--     usedstack = function()
+--         return noffunctions + nofnodes, 0
+--     end
+--
+--     flushfunction = function(n)
+--         local sn = luafunctions[n]
+--         if not sn then
+--             report_cld("data with id %a cannot be found on stack",n)
+--         elseif not sn() and texgetcount("@@trialtypesetting") == 0 then  -- @@trialtypesetting is private!
+--             luafunctions[n] = nil
+--         end
+--     end
+--
+--     storefunction = function(ti)
+--         noffunctions = noffunctions + 1
+--         luafunctions[noffunctions] = ti
+--         return noffunctions
+--     end
+--
+--  -- freefunction = function(n)
+--  --     luafunctions[n] = nil
+--  -- end
+--
+--     flushnode = function(n)
+--         local sn = luanodes[n]
+--         if not sn then
+--             report_cld("data with id %a cannot be found on stack",n)
+--         elseif texgetcount("@@trialtypesetting") == 0 then  -- @@trialtypesetting is private!
+--             writenode(sn)
+--             luanodes[n] = nil
+--         else
+--             writenode(copynodelist(sn))
+--         end
+--     end
+--
+--     storenode = function(ti)
+--         nofnodes = nofnodes + 1
+--         luanodes[nofnodes] = ti
+--         return nofnodes
+--     end
+--
+--     _cldf_ = flushfunction -- global
+--     _cldn_ = flushnode     -- global
+--  -- _cldl_ = function(n) return luafunctions[n]() end -- luafunctions(n)
+--     _cldl_ = luafunctions
+--
+--     registerfunction = function(f)
+--         if type(f) == "string" then
+--             f = loadstring(f)
+--         end
+--         if type(f) ~= "function" then
+--             f = function() report_cld("invalid function %A",f) end
+--         end
+--         noffunctions = noffunctions + 1
+--         luafunctions[noffunctions] = f
+--         return noffunctions
+--     end
+--
+--     unregisterfunction = function(slot)
+--         if luafunctions[slot] then
+--             luafunctions[slot] = nil
+--         else
+--             report_cld("invalid function slot %A",slot)
+--         end
+--     end
+--
+--     reservefunction = function()
+--         noffunctions = noffunctions + 1
+--         return noffunctions
+--     end
+--
+--     callfunctiononce = function(slot)
+--         luafunctions[slot](slot)
+--         luafunctions[slot] = nil
+--     end
+--
+--     table.setmetatablecall(luafunctions,function(t,n) return luafunctions[n](n) end)
+--
+--     knownfunctions = luafunctions
+--
+-- end
 
 context.registerfunction   = registerfunction
 context.unregisterfunction = unregisterfunction
@@ -295,8 +420,12 @@ context.knownfunctions     = knownfunctions
 context.callfunctiononce   = callfunctiononce   _cldo_ = callfunctiononce
 context.storenode          = storenode -- private helper
 
-function commands.ctxfunction(code)
-    context(registerfunction(code))
+function commands.ctxfunction(code,namespace)
+    context(registerfunction(code,namespace))
+end
+
+function context.trialtypesetting()
+    return texgetcount("@@trialtypesetting") ~= 0
 end
 
 -- local f_cldo       = formatters["_cldo_(%i)"]
diff --git a/tex/context/base/cont-new.mkiv b/tex/context/base/cont-new.mkiv
index 2d0f07dad..d38507d34 100644
--- a/tex/context/base/cont-new.mkiv
+++ b/tex/context/base/cont-new.mkiv
@@ -11,7 +11,7 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
-\newcontextversion{2015.02.03 23:55}
+\newcontextversion{2015.03.09 19:27}
 
 %D This file is loaded at runtime, thereby providing an excellent place for
 %D hacks, patches, extensions and new features.
diff --git a/tex/context/base/context-version.pdf b/tex/context/base/context-version.pdf
index 31c5d44c1..1907d4063 100644
--- a/tex/context/base/context-version.pdf
+++ b/tex/context/base/context-version.pdf
diff --git a/tex/context/base/context.mkiv b/tex/context/base/context.mkiv
index d6522da7e..9e66e2f65 100644
--- a/tex/context/base/context.mkiv
+++ b/tex/context/base/context.mkiv
@@ -28,7 +28,7 @@
 %D up and the dependencies are more consistent.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2015.02.03 23:55}
+\edef\contextversion{2015.03.09 19:27}
 \edef\contextkind   {beta}
 
 %D For those who want to use this:
@@ -129,6 +129,8 @@
 \loadmarkfile{luat-ini}
 
 \loadmarkfile{toks-ini}
+\loadmarkfile{toks-tra}
+%loadmarkfile{toks-map} % obsolete, never used
 
 \loadmarkfile{attr-ini}
 
@@ -405,6 +407,7 @@
 \loadmarkfile{typo-fln}
 \loadmarkfile{typo-sus}
 \loadmarkfile{typo-lig}
+\loadmarkfile{typo-chr}
 
 \loadmkvifile{type-ini}
 \loadmarkfile{type-set}
diff --git a/tex/context/base/core-env.lua b/tex/context/base/core-env.lua
index 94f237c2e..75cbbb607 100644
--- a/tex/context/base/core-env.lua
+++ b/tex/context/base/core-env.lua
@@ -13,19 +13,15 @@ if not modules then modules = { } end modules ['core-env'] = {
 
 local P, C, S, Cc, lpegmatch, patterns = lpeg.P, lpeg.C, lpeg.S, lpeg.Cc, lpeg.match, lpeg.patterns
 
-local csname_id         = token.csname_id
-local create            = token.create
 local texgetcount       = tex.getcount
 local texsetcount       = tex.setcount
 
 local allocate          = utilities.storage.allocate
 local setmetatableindex = table.setmetatableindex
+local setmetatablecall  = table.setmetatablecall
 
 local context           = context
 
-local undefined         = csname_id("*undefined*crap*")
-local iftrue            = create("iftrue")[2] -- inefficient hack
-
 tex.modes               = allocate { }
 tex.systemmodes         = allocate { }
 tex.constants           = allocate { }
@@ -36,52 +32,204 @@ tex.isdefined           = allocate { }
 local modes             = { }
 local systemmodes       = { }
 
-setmetatableindex(tex.modes, function(t,k)
-    local m = modes[k]
-    if m then
-        return m()
-    else
-        local n = "mode>" .. k
-        if csname_id(n) == undefined then
-            return false
+if newtoken then
+
+    -- undefined: mode == 0 or cmdname = "undefined_cs"
+
+    local create = newtoken.create
+
+    local cache = table.setmetatableindex(function(t,k)
+        local v = create(k)
+        t[k] = v
+        return v
+    end)
+
+    -- we can have a modes cache too
+
+    local iftrue    = cache["iftrue"].mode
+    local undefined = cache["*undefined*crap*"].mode -- is this ok?
+
+    setmetatableindex(tex.modes, function(t,k)
+        local m = modes[k]
+        if m then
+            return m()
+        else
+            local n = "mode>" .. k
+            if cache[n].mode == 0 then
+                return false
+            else
+                modes[k] = function() return texgetcount(n) == 1 end
+                return texgetcount(n) == 1 -- 2 is prevented
+            end
+        end
+    end)
+
+    setmetatableindex(tex.systemmodes, function(t,k)
+        local m = systemmodes[k]
+        if m then
+            return m()
         else
-            modes[k] = function() return texgetcount(n) == 1 end
-            return texgetcount(n) == 1 -- 2 is prevented
+            local n = "mode>*" .. k
+            if cache[n].mode == 0 then
+                return false
+            else
+                systemmodes[k] = function() return texgetcount(n) == 1 end
+                return texgetcount(n) == 1 -- 2 is prevented
+            end
         end
+    end)
+
+    setmetatableindex(tex.constants, function(t,k)
+        return cache[k].mode ~= 0 and texgetcount(k) or 0
+    end)
+
+    setmetatableindex(tex.conditionals, function(t,k) -- 0 == true
+        return cache[k].mode ~= 0 and texgetcount(k) == 0
+    end)
+
+    table.setmetatableindex(tex.ifs, function(t,k)
+     -- local mode = cache[k].mode
+     -- if mode == 0 then
+     --     return nil
+     -- else
+     --     return mode == iftrue
+     -- end
+        return cache[k].mode == iftrue
+    end)
+
+    setmetatableindex(tex.isdefined, function(t,k)
+        return k and cache[k].mode ~= 0
+    end)
+
+    setmetatablecall(tex.isdefined, function(t,k)
+        return k and cache[k].mode ~= 0
+    end)
+
+    local dimencode   = cache["scratchdimen"  ].command
+    local countcode   = cache["scratchcounter"].command
+    local tokencode   = cache["scratchtoken"  ].command
+    local skipcode    = cache["scratchskip"   ].command
+
+    local types = {
+        [dimencode] = "dimen",
+        [countcode] = "count",
+        [tokencode] = "token",
+        [skipcode ] = "skip",
+    }
+
+    function tex.isdimen(name)
+        return cache[name].command == dimencode
     end
-end)
 
-setmetatableindex(tex.systemmodes, function(t,k)
-    local m = systemmodes[k]
-    if m then
-        return m()
-    else
-        local n = "mode>*" .. k
-        if csname_id(n) == undefined then
-            return false
+    function tex.iscount(name)
+        return cache[name].command == countcode
+    end
+
+    function tex.istoken(name)
+        return cache[name].command == tokencode
+    end
+
+    function tex.isskip(name)
+        return cache[name].command == skipcode
+    end
+
+    function tex.type(name)
+        return types[cache[name].command] or "macro"
+    end
+
+else
+
+    local csname_id = token.csname_id
+    local create    = token.create
+
+    local undefined = csname_id("*undefined*crap*")
+    local iftrue    = create("iftrue")[2] -- inefficient hack
+
+    setmetatableindex(tex.modes, function(t,k)
+        local m = modes[k]
+        if m then
+            return m()
+        else
+            local n = "mode>" .. k
+            if csname_id(n) == undefined then
+                return false
+            else
+                modes[k] = function() return texgetcount(n) == 1 end
+                return texgetcount(n) == 1 -- 2 is prevented
+            end
+        end
+    end)
+
+    setmetatableindex(tex.systemmodes, function(t,k)
+        local m = systemmodes[k]
+        if m then
+            return m()
         else
-            systemmodes[k] = function() return texgetcount(n) == 1 end
-            return texgetcount(n) == 1 -- 2 is prevented
+            local n = "mode>*" .. k
+            if csname_id(n) == undefined then
+                return false
+            else
+                systemmodes[k] = function() return texgetcount(n) == 1 end
+                return texgetcount(n) == 1 -- 2 is prevented
+            end
         end
+    end)
+
+    setmetatableindex(tex.constants, function(t,k)
+        return csname_id(k) ~= undefined and texgetcount(k) or 0
+    end)
+
+    setmetatableindex(tex.conditionals, function(t,k) -- 0 == true
+        return csname_id(k) ~= undefined and texgetcount(k) == 0
+    end)
+
+    setmetatableindex(tex.ifs, function(t,k)
+     -- k = "if" .. k -- better not
+        return csname_id(k) ~= undefined and create(k)[2] == iftrue -- inefficient, this create, we need a helper
+    end)
+
+    setmetatableindex(tex.isdefined, function(t,k)
+        return k and csname_id(k) ~= undefined
+    end)
+    setmetatablecall(tex.isdefined, function(t,k)
+        return k and csname_id(k) ~= undefined
+    end)
+
+    local lookuptoken = token.lookup
+
+    local dimencode   = lookuptoken("scratchdimen"  )[1]
+    local countcode   = lookuptoken("scratchcounter")[1]
+    local tokencode   = lookuptoken("scratchtoken"  )[1]
+    local skipcode    = lookuptoken("scratchskip"   )[1]
+
+    local types = {
+        [dimencode] = "dimen",
+        [countcode] = "count",
+        [tokencode] = "token",
+        [skipcode ] = "skip",
+    }
+
+    function tex.isdimen(name)
+        return lookuptoken(name)[1] == dimencode
     end
-end)
 
-setmetatableindex(tex.constants, function(t,k)
-    return csname_id(k) ~= undefined and texgetcount(k) or 0
-end)
+    function tex.iscount(name)
+        return lookuptoken(name)[1] == countcode
+    end
 
-setmetatableindex(tex.conditionals, function(t,k) -- 0 == true
-    return csname_id(k) ~= undefined and texgetcount(k) == 0
-end)
+    function tex.istoken(name)
+        return lookuptoken(name)[1] == tokencode
+    end
 
-setmetatableindex(tex.ifs, function(t,k)
- -- k = "if" .. k -- better not
-    return csname_id(k) ~= undefined and create(k)[2] == iftrue -- inefficient, this create, we need a helper
-end)
+    function tex.isskip(name)
+        return lookuptoken(name)[1] == skipcode
+    end
 
-setmetatableindex(tex.isdefined, function(t,k)
-    return csname_id(k) ~= undefined
-end)
+    function tex.type(name)
+        return types[lookuptoken(name)[1]] or "macro"
+    end
+
+end
 
 function context.setconditional(name,value)
     if value then
@@ -91,27 +239,6 @@ function context.setconditional(name,value)
     end
 end
 
-
--- todo : global
-
--- not possible as we let at the tex end to zerocount and plusone
---
--- function tex.settrue(name,glob)
---     if glob then
---         texsetcount("global",name,0)
---     else
---         texsetcount(name,0)
---     end
--- end
---
--- function tex.setfalse(name,glob)
---     if glob then
---         texsetcount("global",name,1)
---     else
---         texsetcount(name,1)
---     end
--- end
-
 ----  arg = P("{") * C(patterns.nested) * P("}") + Cc("")
 
 local sep = S("), ")
@@ -130,41 +257,3 @@ function commands.autosetups(str)
     lpegmatch(pattern,str)
 end
 
--- new (inefficient)
-
-local lookuptoken = token.lookup
-
-local dimencode   = lookuptoken("scratchdimen"  )[1]
-local countcode   = lookuptoken("scratchcounter")[1]
-local tokencode   = lookuptoken("scratchtoken"  )[1]
-local skipcode    = lookuptoken("scratchskip"   )[1]
-
-local types = {
-    [dimencode] = "dimen",
-    [countcode] = "count",
-    [tokencode] = "token",
-    [skipcode ] = "skip",
-}
-
-function tex.isdimen(name)
-    return lookuptoken(name)[1] == dimencode
-end
-
-function tex.iscount(name)
-    return lookuptoken(name)[1] == countcode
-end
-
-function tex.istoken(name)
-    return lookuptoken(name)[1] == tokencode
-end
-
-function tex.isskip(name)
-    return lookuptoken(name)[1] == skipcode
-end
-
-function tex.type(name)
-    return types[lookuptoken(name)[1]] or "macro"
-end
-
---  inspect(tex.isdimen("xxxxxxxxxxxxxxx"))
---  inspect(tex.isdimen("textwidth"))
diff --git a/tex/context/base/core-env.mkiv b/tex/context/base/core-env.mkiv
index 1e47ac517..0ee5a0fb3 100644
--- a/tex/context/base/core-env.mkiv
+++ b/tex/context/base/core-env.mkiv
@@ -467,7 +467,11 @@
 % but it won't work out well with multiple setups (intercepted at the
 % lua end) that then get only one argument.
 
-\def\fastsetup#1{\csname\??setup:#1\endcsname\empty} % no checking and we assume it being defined (at least for now)
+% no checking and we assume it being defined:
+
+\def\fastsetup                     #1{\csname\??setup:#1\endcsname\empty}
+\def\fastsetupwithargument       #1#2{\csname\??setup:#2\endcsname{#1}}
+\def\fastsetupwithargumentswapped  #1{\csname\??setup:#1\endcsname}
 
 % the next one is meant for \c!setups situations, hence the check for
 % a shortcut
diff --git a/tex/context/base/data-tre.lua b/tex/context/base/data-tre.lua
index 4aca21b68..4388731f9 100644
--- a/tex/context/base/data-tre.lua
+++ b/tex/context/base/data-tre.lua
@@ -64,6 +64,20 @@ function resolvers.finders.tree(specification) -- to be adapted to new formats
                     return fullname
                 end
             end
+            -- let's be nice:
+            local pattern = lower(pattern)
+            for i=1,#names do
+                local fullname = lower(names[i])
+                if find(fullname,pattern) then
+                    if isfile(fullname) then
+                        found[spec] = fullname
+                        return fullname
+                    else
+                        -- no os name mapping
+                        break
+                    end
+                end
+            end
         end
         okay = notfound() -- false
         found[spec] = okay
@@ -86,9 +100,9 @@ end
 
 function resolvers.hashers.tree(specification)
     local name = specification.filename
-    if trace_locating then
-        report_trees("analysing %a",name)
-    end
+ -- if trace_locating then
+        report_trees("analyzing %a",name)
+ -- end
     resolvers.methodhandler("hashers",name)
 
     resolvers.generators.file(specification)
diff --git a/tex/context/base/enco-ini.mkiv b/tex/context/base/enco-ini.mkiv
index 07bdaebd9..29b0542da 100644
--- a/tex/context/base/enco-ini.mkiv
+++ b/tex/context/base/enco-ini.mkiv
@@ -401,37 +401,105 @@
 \unexpanded\def\inch        {\mathematics{\prime\prime}} % was: \hbox{\rm\char125\relax}
 \unexpanded\def\fraction#1#2{\mathematics{#1\over#2}}
 
-\def\periodswidth  {.5em}
-\def\periodsdefault{3}    % was 5, but now it's like \unknown
-
-\unexpanded\def\periods
-  {\dosingleempty\enco_periods}
-
+% \def\periodswidth  {.5em}
+% \def\periodsdefault{3}    % was 5, but now it's like \unknown
+%
+% \unexpanded\def\periods
+%   {\dosingleempty\enco_periods}
+%
 % \def\doperiods[#1]% todo: also n=,width= or maybe just #1,#2
 %   {\dontleavehmode
 %    \begingroup
 %    \scratchdimen\periodswidth
 %    \hbox to \iffirstargument#1\else\periodsdefault\fi \scratchdimen
-%      {\leaders\hbox to \scratchdimen{\hss.\hss}\hss}%
+%      {\leaders\hbox to \scratchdimen{\hss\periodsymbol\hss}\hss}%
 %    \endgroup}
 %
 % better for export:
+%
+% \unexpanded\def\enco_periods[#1]% todo: also n=,width= or maybe just #1,#2
+%   {\dontleavehmode
+%    \hbox\bgroup
+%    \setbox\scratchbox\hbox to \periodswidth{\hss\periodsymbol\hss}%
+%    \dorecurse{\iffirstargument#1\else\periodsdefault\fi}{\copy\scratchbox}%
+%    \egroup}
+%
+% \unexpanded\def\unknown
+%   {\periods\relax} % relax prevents lookahead for []
+%
+% per request:
+
+%D \startbuffer
+%D \startlines
+%D     x\periods x
+%D     x\periods[10]x
+%D     x\periods[n=10,symbol={,}]x
+%D     x\periods[n=4,symbol={!!},width=1em]x
+%D     x\periods[n=4,symbol={!!},width=fit]x
+%D     x\periods[n=4,symbol={!!},width=fit,distance=1em]x
+%D     x\unknown x
+%D \stoplines
+%D \stopbuffer
+%D
+%D \typbuffer \getbuffer
+
+\def\periodswidth  {.5\emwidth}  % downward compatible
+\def\periodsdefault{3}           % downward compatible
+
+\installcorenamespace {periods}
+
+\installsetuponlycommandhandler \??periods {periods}
+
+\setupperiods
+  [\c!n=\periodsdefault,
+   \c!width=\periodswidth, % can also be \v!fit
+   \c!distance=.25\emwidth,
+   \c!symbol=.]
 
-\unexpanded\def\enco_periods[#1]% todo: also n=,width= or maybe just #1,#2
+\unexpanded\def\periods
   {\dontleavehmode
    \hbox\bgroup
-   \setbox\scratchbox\hbox to \periodswidth{\hss.\hss}%
-   \dorecurse{\iffirstargument#1\else\periodsdefault\fi}{\copy\scratchbox}%
+   \doifnextoptionalelse\enco_periods_yes\enco_periods_nop}
+
+\unexpanded\def\enco_periods_yes[#1]%
+  {\doifassignmentelse{#1}
+     {\setupcurrentperiods[#1]%
+      \scratchcounter\periodsparameter\c!n}
+     {\doifelsenothing{#1}
+        {\scratchcounter\periodsparameter\c!n}%
+        {\scratchcounter#1}}%
+   \enco_periods_finish}
+
+\unexpanded\def\enco_periods_nop
+  {\scratchcounter\periodsparameter\c!n
+   \enco_periods_finish}
+
+\unexpanded\def\enco_periods_finish
+  {\edef\p_width{\periodsparameter\c!width}%
+   \ifx\p_width\v!fit
+     \enco_periods_finish_fit
+   \else
+     \enco_periods_finish_width
+   \fi
    \egroup}
 
+\unexpanded\def\enco_periods_finish_width
+  {\setbox\scratchbox\hbox to \p_width
+     {\hss\periodsparameter\c!symbol\hss}%
+   \dorecurse\scratchcounter{\copy\scratchbox}}
+
+\unexpanded\def\enco_periods_finish_fit
+  {\edef\p_symbol{\periodsparameter\c!symbol}%
+   \scratchdistance\periodsparameter\c!distance
+   \hskip\scratchdistance
+   \dorecurse\scratchcounter{\p_symbol\hskip\scratchdistance}}
+
 \unexpanded\def\unknown
-  {\periods\relax} % relax prevents lookahead for []
+  {\dontleavehmode
+   \hbox\bgroup
+   \enco_periods_nop}
 
-% Example by Wolfgang Schuster on the context list:
-%
-% \unexpanded\def\fourdots{{\def\periodswidth{.3em}\periods[4]}}
-%
-% Hello\fourdots\ World\fourdots \par Hello\fourdots\ World.
+%D Left-overs:
 
 \appendtoks
     \let\buildtextaccent\secondoftwoarguments
diff --git a/tex/context/base/export-example.css b/tex/context/base/export-example.css
index cbe4ccf4e..41321ead4 100644
--- a/tex/context/base/export-example.css
+++ b/tex/context/base/export-example.css
@@ -122,6 +122,7 @@ construct[detail="important"], div.construct.important {
 }
 
 highlight, div.highlight { /* todo: style and color */
+	display : inline ;
 }
 
 /* section        : display */
diff --git a/tex/context/base/export-example.tex b/tex/context/base/export-example.tex
index 3a70b92fd..32cb79c5e 100644
--- a/tex/context/base/export-example.tex
+++ b/tex/context/base/export-example.tex
@@ -9,9 +9,7 @@
    hyphen=yes]
 
 \setupbackend
-  [export=export-example.xml,
-   xhtml=export-example.xhtml,
-   css=export-example.css]
+  [export=yes]
 
 % \setupalign
 %   [flushleft]
diff --git a/tex/context/base/file-job.lua b/tex/context/base/file-job.lua
index 0d1986463..ff99aa651 100644
--- a/tex/context/base/file-job.lua
+++ b/tex/context/base/file-job.lua
@@ -88,10 +88,12 @@ function commands.locatefilepath(name)
 end
 
 function commands.usepath(paths)
+    report_jobfiles("using path: %s",paths)
     registerextrapath(paths)
 end
 
 function commands.usesubpath(subpaths)
+    report_jobfiles("using subpath: %s",subpaths)
     registerextrapath(nil,subpaths)
 end
 
@@ -773,6 +775,10 @@ function document.getargument(key,default) -- commands
     context(v or default or "")
 end
 
+function document.setargument(key,value)
+    document.arguments[key] = value -- only strings
+end
+
 function document.getfilename(i) -- commands
     context(document.files[tonumber(i)] or "")
 end
diff --git a/tex/context/base/font-ctx.lua b/tex/context/base/font-ctx.lua
index ee2a71ac5..a7f915023 100644
--- a/tex/context/base/font-ctx.lua
+++ b/tex/context/base/font-ctx.lua
@@ -1004,8 +1004,34 @@ do  -- else too many locals
         return (gsub(cs,".->", ""))
     end
 
+--     local scan_string  = newtoken.scan_string
+--     local scan_dimen   = newtoken.scan_dimen
+--     local scan_number  = newtoken.scan_number
+--     local scan_boolean = newtoken.scan_boolean
+
+--     function commands.definefont_two()
+
+--         local global          = scan_boolean()
+--         local cs              = scan_string()
+--         local str             = scan_string()
+--         local size            = scan_number()
+--         local inheritancemode = scan_number()
+--         local classfeatures   = scan_string()
+--         local fontfeatures    = scan_string()
+--         local classfallbacks  = scan_string()
+--         local fontfallbacks   = scan_string()
+--         local mathsize        = scan_number()
+--         local textsize        = scan_number()
+--         local relativeid      = scan_string()
+--         local classgoodies    = scan_string()
+--         local goodies         = scan_string()
+--         local classdesignsize = scan_string()
+--         local fontdesignsize  = scan_string()
+--         local scaledfontmode  = scan_number()
+
     function commands.definefont_two(global,cs,str,size,inheritancemode,classfeatures,fontfeatures,classfallbacks,fontfallbacks,
             mathsize,textsize,relativeid,classgoodies,goodies,classdesignsize,fontdesignsize,scaledfontmode)
+
         if trace_defining then
             report_defining("start stage two: %s (size %s)",str,size)
         end
@@ -1242,9 +1268,12 @@ do
     function definers.internal(specification,cs)
         specification = specification or { }
         local name    = specification.name
-        local size    = specification.size and number.todimen(specification.size) or texgetdimen("bodyfontsize")
+        local size    = tonumber(specification.size)
         local number  = tonumber(specification.number)
         local id      = nil
+        if not size then
+            size = texgetdimen("bodyfontsize")
+        end
         if number then
             id = number
         elseif name and name ~= "" then
diff --git a/tex/context/base/font-fil.mkvi b/tex/context/base/font-fil.mkvi
index 158bcda71..0f1d27564 100644
--- a/tex/context/base/font-fil.mkvi
+++ b/tex/context/base/font-fil.mkvi
@@ -290,75 +290,75 @@
 % resolve
 
 \def\font_helpers_set_features_yes#name%
-  {\ifcsname\??fontfile\fontclass#name\s!features \endcsname\expandafter\let\expandafter\m_font_features  % class + symbolic_name
-     \csname\??fontfile\fontclass#name\s!features \endcsname\else
-   \ifcsname\??fontfile          #name\s!features \endcsname\expandafter\let\expandafter\m_font_features  % symbolic_name
-     \csname\??fontfile          #name\s!features \endcsname\else
+  {\ifcsname\??fontfile\fontclass#name\s!features \endcsname \edef\m_font_features  % class + symbolic_name
+    {\csname\??fontfile\fontclass#name\s!features \endcsname}\else
+   \ifcsname\??fontfile          #name\s!features \endcsname \edef\m_font_features  % symbolic_name
+    {\csname\??fontfile          #name\s!features \endcsname}\else
    \ifcsname\??fontfile\fontclass            #name\endcsname\expandafter\font_helpers_set_features_yes    % class + parent_name
-     \csname\??fontfile\fontclass            #name\endcsname\else
-   \ifcsname\??fontfile                      #name\endcsname\expandafter\font_helpers_set_features_yes    % parent_name
-     \csname\??fontfile                      #name\endcsname\else
+     \csname\??fontfile\fontclass            #name\endcsname \else
+   \ifcsname\??fontfile                      #name\endcsname \expandafter\font_helpers_set_features_yes    % parent_name
+     \csname\??fontfile                      #name\endcsname \else
    \let\m_font_features\empty\fi\fi\fi\fi}
 
 \def\font_helpers_set_fallbacks_yes#name%
-  {\ifcsname\??fontfile\fontclass#name\s!fallbacks\endcsname\expandafter\let\expandafter\m_font_fallbacks
-     \csname\??fontfile\fontclass#name\s!fallbacks\endcsname\else
-   \ifcsname\??fontfile          #name\s!fallbacks\endcsname\expandafter\let\expandafter\m_font_fallbacks
-     \csname\??fontfile          #name\s!fallbacks\endcsname\else
-   \ifcsname\??fontfile\fontclass            #name\endcsname\expandafter\font_helpers_set_fallbacks_yes
-     \csname\??fontfile\fontclass            #name\endcsname\else
-   \ifcsname\??fontfile                      #name\endcsname\expandafter\font_helpers_set_fallbacks_yes
-     \csname\??fontfile                      #name\endcsname\else
+  {\ifcsname\??fontfile\fontclass#name\s!fallbacks\endcsname \edef\m_font_fallbacks
+    {\csname\??fontfile\fontclass#name\s!fallbacks\endcsname}\else
+   \ifcsname\??fontfile          #name\s!fallbacks\endcsname \edef\m_font_fallbacks
+    {\csname\??fontfile          #name\s!fallbacks\endcsname}\else
+   \ifcsname\??fontfile\fontclass            #name\endcsname \expandafter\font_helpers_set_fallbacks_yes
+     \csname\??fontfile\fontclass            #name\endcsname \else
+   \ifcsname\??fontfile                      #name\endcsname \expandafter\font_helpers_set_fallbacks_yes
+     \csname\??fontfile                      #name\endcsname \else
    \let\m_font_fallbacks\empty\fi\fi\fi\fi}
 
 \def\font_helpers_set_goodies_yes#name%
-  {\ifcsname\??fontfile\fontclass#name\s!goodies  \endcsname\expandafter\let\expandafter\m_font_goodies
-     \csname\??fontfile\fontclass#name\s!goodies  \endcsname\else
-   \ifcsname\??fontfile          #name\s!goodies  \endcsname\expandafter\let\expandafter\m_font_goodies
-     \csname\??fontfile          #name\s!goodies  \endcsname\else
-   \ifcsname\??fontfile\fontclass            #name\endcsname\expandafter\font_helpers_set_goodies_yes
-     \csname\??fontfile\fontclass            #name\endcsname\else
-   \ifcsname\??fontfile                      #name\endcsname\expandafter\font_helpers_set_goodies_yes
-     \csname\??fontfile                      #name\endcsname\else
+  {\ifcsname\??fontfile\fontclass#name\s!goodies  \endcsname \edef\m_font_goodies
+    {\csname\??fontfile\fontclass#name\s!goodies  \endcsname}\else
+   \ifcsname\??fontfile          #name\s!goodies  \endcsname \edef\m_font_goodies
+    {\csname\??fontfile          #name\s!goodies  \endcsname}\else
+   \ifcsname\??fontfile\fontclass            #name\endcsname \expandafter\font_helpers_set_goodies_yes
+     \csname\??fontfile\fontclass            #name\endcsname \else
+   \ifcsname\??fontfile                      #name\endcsname \expandafter\font_helpers_set_goodies_yes
+     \csname\??fontfile                      #name\endcsname \else
    \let\m_font_goodies\empty\fi\fi\fi\fi}
 
 \def\font_helpers_set_designsize_yes#name%
-  {\ifcsname\??fontfile\fontclass#name\s!designsize\endcsname\expandafter\let\expandafter\m_font_designsize
-     \csname\??fontfile\fontclass#name\s!designsize\endcsname\else
-   \ifcsname\??fontfile          #name\s!designsize\endcsname\expandafter\let\expandafter\m_font_designsize
-     \csname\??fontfile          #name\s!designsize\endcsname\else
-   \ifcsname\??fontfile\fontclass             #name\endcsname\expandafter\font_helpers_set_designsize_yes
-     \csname\??fontfile\fontclass             #name\endcsname\else
-   \ifcsname\??fontfile                       #name\endcsname\expandafter\font_helpers_set_designsize_yes
-     \csname\??fontfile                       #name\endcsname\else
+  {\ifcsname\??fontfile\fontclass#name\s!designsize\endcsname \edef\m_font_designsize
+    {\csname\??fontfile\fontclass#name\s!designsize\endcsname}\else
+   \ifcsname\??fontfile          #name\s!designsize\endcsname \edef\m_font_designsize
+    {\csname\??fontfile          #name\s!designsize\endcsname}\else
+   \ifcsname\??fontfile\fontclass             #name\endcsname \expandafter\font_helpers_set_designsize_yes
+     \csname\??fontfile\fontclass             #name\endcsname \else
+   \ifcsname\??fontfile                       #name\endcsname \expandafter\font_helpers_set_designsize_yes
+     \csname\??fontfile                       #name\endcsname \else
    \let\m_font_designsize\empty\fi\fi\fi\fi}
 
 \def\font_helpers_set_features_nop#name%
-  {\ifcsname\??fontfile#name\s!features \endcsname\expandafter\let\expandafter\m_font_features
-     \csname\??fontfile#name\s!features \endcsname\else
-   \ifcsname\??fontfile            #name\endcsname\expandafter\font_helpers_set_features_nop
-     \csname\??fontfile            #name\endcsname\else
+  {\ifcsname\??fontfile#name\s!features \endcsname \edef\m_font_features
+    {\csname\??fontfile#name\s!features \endcsname}\else
+   \ifcsname\??fontfile            #name\endcsname \expandafter\font_helpers_set_features_nop
+     \csname\??fontfile            #name\endcsname \else
    \let\m_font_features\empty\fi\fi}
 
 \def\font_helpers_set_fallbacks_nop#name%
-  {\ifcsname\??fontfile#name\s!fallbacks\endcsname\expandafter\let\expandafter\m_font_fallbacks
-     \csname\??fontfile#name\s!fallbacks\endcsname\else
-   \ifcsname\??fontfile            #name\endcsname\expandafter\font_helpers_set_fallbacks_nop
-     \csname\??fontfile            #name\endcsname\else
+  {\ifcsname\??fontfile#name\s!fallbacks\endcsname \edef\m_font_fallbacks
+    {\csname\??fontfile#name\s!fallbacks\endcsname}\else
+   \ifcsname\??fontfile            #name\endcsname \expandafter\font_helpers_set_fallbacks_nop
+     \csname\??fontfile            #name\endcsname \else
    \let\m_font_fallbacks\empty\fi\fi}
 
 \def\font_helpers_set_goodies_nop#name%
-  {\ifcsname\??fontfile#name\s!goodies  \endcsname\expandafter\let\expandafter\m_font_goodies
-     \csname\??fontfile#name\s!goodies  \endcsname\else
-   \ifcsname\??fontfile            #name\endcsname\expandafter\font_helpers_set_goodies_nop
-     \csname\??fontfile            #name\endcsname\else
+  {\ifcsname\??fontfile#name\s!goodies  \endcsname \edef\m_font_goodies
+    {\csname\??fontfile#name\s!goodies  \endcsname}\else
+   \ifcsname\??fontfile            #name\endcsname \expandafter\font_helpers_set_goodies_nop
+     \csname\??fontfile            #name\endcsname \else
    \let\m_font_goodies\empty\fi\fi}
 
 \def\font_helpers_set_designsize_nop#name%
-  {\ifcsname\??fontfile#name\s!designsize\endcsname\expandafter\let\expandafter\m_font_designsize
-     \csname\??fontfile#name\s!designsize\endcsname\else
-   \ifcsname\??fontfile             #name\endcsname\expandafter\font_helpers_set_designsize_nop
-     \csname\??fontfile             #name\endcsname\else
+  {\ifcsname\??fontfile#name\s!designsize\endcsname \edef\m_font_designsize
+    {\csname\??fontfile#name\s!designsize\endcsname}\else
+   \ifcsname\??fontfile             #name\endcsname \expandafter\font_helpers_set_designsize_nop
+     \csname\??fontfile             #name\endcsname \else
    \let\m_font_designsize\empty\fi\fi}
 
 \def\font_helpers_update_font_parameters_yes
diff --git a/tex/context/base/font-ini.mkvi b/tex/context/base/font-ini.mkvi
index 03e08affc..60104f31a 100644
--- a/tex/context/base/font-ini.mkvi
+++ b/tex/context/base/font-ini.mkvi
@@ -900,11 +900,19 @@
 \unexpanded\def\definefrozenfont
   {\dotripleempty\font_basics_define_frozen_font}
 
+% \def\font_basics_define_frozen_font[#name][#specification][#settings]%
+%   {\begingroup
+%    \font_basics_define_font[#name][#specification][#settings]%
+%    \csname#name\endcsname
+%    \expandafter\expandafter\expandafter\endgroup\expandafter\let\csname#name\endcsname\lastrawfontcall}
+
 \def\font_basics_define_frozen_font[#name][#specification][#settings]%
   {\begingroup
    \font_basics_define_font[#name][#specification][#settings]%
    \csname#name\endcsname
-   \expandafter\endgroup\expandafter\let\csname#name\endcsname\lastrawfontcall}
+   \global\let\lastglobalrawfontcall\lastrawfontcall
+   \endgroup
+   \expandafter\let\csname#name\endcsname\lastglobalrawfontcall}
 
 %D The instance namespace protection makes the switch local so that we can redefine a
 %D logical name and/or change the size in between.
diff --git a/tex/context/base/font-inj.lua b/tex/context/base/font-inj.lua
index 87d3f9b27..cb9ed891c 100644
--- a/tex/context/base/font-inj.lua
+++ b/tex/context/base/font-inj.lua
@@ -14,6 +14,7 @@ if not nodes.properties then return end
 
 local next, rawget = next, rawget
 local utfchar = utf.char
+local fastcopy = table.fastcopy
 
 local trace_injections = false  trackers.register("fonts.injections", function(v) trace_injections = v end)
 
@@ -89,6 +90,28 @@ function injections.reset(n)
     end
 end
 
+function injections.copy(target,source)
+    local sp = rawget(properties,source)
+    if sp then
+        local tp = rawget(properties,target)
+        local si = rawget(sp,"injections")
+        if si then
+            si = fastcopy(si)
+            if tp then
+                tp.injections = si
+            else
+                propertydata[target] = {
+                    injections = si,
+                }
+            end
+        else
+            if tp then
+                tp.injections = nil
+            end
+        end
+    end
+end
+
 function injections.setligaindex(n,index)
     local p = rawget(properties,n)
     if p then
@@ -114,7 +137,7 @@ function injections.getligaindex(n,default)
     if p then
         local i = rawget(p,"injections")
         if i then
-            return p.ligaindex or default
+            return i.ligaindex or default
         end
     end
     return default
@@ -186,12 +209,14 @@ function injections.setpair(current,factor,rlmode,r2lflag,spec,injection) -- r2l
             if p then
                 local i = rawget(p,"injections")
                 if i then
-                    if leftkern ~= 0 or rightkern ~= 0 then
-                        i.leftkern  = i.leftkern  or 0 + leftkern
-                        i.rightkern = i.rightkern or 0 + rightkern
+                    if leftkern ~= 0 then
+                        i.leftkern  = (i.leftkern  or 0) + leftkern
+                    end
+                    if rightkern ~= 0 then
+                        i.rightkern = (i.rightkern or 0) + rightkern
                     end
                     if yoffset ~= 0 then
-                        i.yoffset = i.yoffset or 0 + yoffset
+                        i.yoffset = (i.yoffset or 0) + yoffset
                     end
                 elseif leftkern ~= 0 or rightkern ~= 0 then
                     p.injections = {
@@ -241,7 +266,7 @@ function injections.setkern(current,factor,rlmode,x,injection)
         if p then
             local i = rawget(p,injection)
             if i then
-                i.leftkern = dx + i.leftkern or 0
+                i.leftkern = dx + (i.leftkern or 0)
             else
                 p[injection] = {
                     leftkern = dx,
@@ -312,7 +337,7 @@ local function show(n,what,nested,symbol)
     if n then
         local p = rawget(properties,n)
         if p then
-            local i = p[what]
+            local i = rawget(p,what)
             if i then
                 local leftkern  = i.leftkern  or 0
                 local rightkern = i.rightkern or 0
@@ -354,9 +379,9 @@ local function showsub(n,what,where)
     report_injections("end subrun")
 end
 
-local function trace(head)
-    report_injections("begin run: %s kerns, %s pairs, %s marks and %s cursives registered",
-        nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
+local function trace(head,where)
+    report_injections("begin run %s: %s kerns, %s pairs, %s marks and %s cursives registered",
+        where or "",nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
     local n = head
     while n do
         local id = getid(n)
@@ -479,7 +504,9 @@ local function inject_marks(marks,nofmarks)
                     local pp = rawget(properties,p)
                     if pp then
                         pp = rawget(pp,"injections")
-                        rightkern = pp.rightkern
+                        if pp then
+                            rightkern = pp.rightkern
+                        end
                     end
                     if rightkern then -- x and w ~= 0
                         if pn.markdir < 0 then
@@ -495,7 +522,7 @@ local function inject_marks(marks,nofmarks)
                             else
                                 ox = px - pn.markx - leftkern
                             end
-                         -- report_injections("l2r case 1: %p",ox)
+-- report_injections("l2r case 1: %p",ox)
                         end
                     else
                         -- we need to deal with fonts that have marks with width
@@ -529,7 +556,7 @@ local function inject_marks(marks,nofmarks)
                     end
                     setfield(n,"yoffset",oy)
                 else
-                 -- normally this can't happen (only when in trace mode which is a special case anyway)
+                    -- normally this can't happen (only when in trace mode which is a special case anyway)
                  -- report_injections("missing mark anchor %i",pn.markbase or 0)
                 end
             end
@@ -551,7 +578,7 @@ local function inject_cursives(glyphs,nofglyphs)
             if cursivex then
                 if cursiveanchor then
                     if cursivex ~= 0 then
-                        pn.leftkern = pn.leftkern or 0 + cursivex
+                        pn.leftkern = (pn.leftkern or 0) + cursivex
                     end
                     if lastanchor then
                         if maxc == 0 then
@@ -644,7 +671,7 @@ end
 local function inject_everything(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"everything")
     end
     local glyphs, nofglyphs, marks, nofmarks
     if nofregisteredpairs > 0 then
@@ -656,7 +683,7 @@ local function inject_everything(head,where)
         if nofregisteredcursives > 0 then
             inject_cursives(glyphs,nofglyphs)
         end
-        if nofregisteredmarks > 0 then
+        if nofregisteredmarks > 0 then -- and nofmarks > 0
             inject_marks(marks,nofmarks)
         end
         inject_kerns(head,glyphs,nofglyphs)
@@ -675,7 +702,7 @@ end
 local function inject_kerns_only(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"kerns")
     end
     local n = head
     local p = nil
@@ -818,7 +845,7 @@ end
 local function inject_pairs_only(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"pairs")
     end
     --
     local n = head
diff --git a/tex/context/base/font-nod.lua b/tex/context/base/font-nod.lua
index 636a668bc..26c736582 100644
--- a/tex/context/base/font-nod.lua
+++ b/tex/context/base/font-nod.lua
@@ -11,10 +11,10 @@ if not modules then modules = { } end modules ['font-nod'] = {
 might become a runtime module instead. This module will be cleaned up!</p>
 --ldx]]--
 
-local tonumber, tostring = tonumber, tostring
+local tonumber, tostring, rawget = tonumber, tostring, rawget
 local utfchar = utf.char
-local concat = table.concat
-local match, gmatch, concat, rep = string.match, string.gmatch, table.concat, string.rep
+local concat, fastcopy = table.concat, table.fastcopy
+local match, rep = string.match, string.rep
 
 local report_nodes = logs.reporter("fonts","tracing")
 
@@ -92,6 +92,25 @@ local fontcharacters   = hashes.characters
 local fontproperties   = hashes.properties
 local fontparameters   = hashes.parameters
 
+local properties = nodes.properties.data
+
+-- direct.set_properties_mode(true,false)
+-- direct.set_properties_mode(true,true)  -- default
+
+local function freeze(h,where)
+ -- report_nodes("freezing %s",where)
+    for n in traverse_nodes(tonut(h)) do -- todo: disc but not traced anyway
+        local p = properties[n]
+        if p then
+            local i = p.injections         if i then p.injections        = fastcopy(i) end
+         -- local i = r.preinjections      if i then p.preinjections     = fastcopy(i) end
+         -- local i = r.postinjections     if i then p.postinjections    = fastcopy(i) end
+         -- local i = r.replaceinjections  if i then p.replaceinjections = fastcopy(i) end
+            -- only injections
+        end
+    end
+end
+
 function char_tracers.collect(head,list,tag,n)
     head = tonut(head)
     n = n or 0
@@ -269,7 +288,8 @@ end
 function step_tracers.glyphs(n,i)
     local c = collection[i]
     if c then
-        local b = hpack_node_list(copy_node_list(c)) -- multiple arguments
+        local c = copy_node_list(c)
+        local b = hpack_node_list(c) -- multiple arguments
         setbox(n,b)
     end
 end
@@ -414,10 +434,11 @@ end
 function step_tracers.check(head)
     if collecting then
         step_tracers.reset()
-        local n = copy_node_list(tonut(head))
+        local h = tonut(head)
+        local n = copy_node_list(h)
+        freeze(n,"check")
         injections.keepcounts(n) -- one-time
         injections.handler(n,"trace")
-     -- handlers.protectglyphs(n) -- can be option
         protect_glyphs(n)
         collection[1] = n
     end
@@ -427,10 +448,11 @@ function step_tracers.register(head)
     if collecting then
         local nc = #collection+1
         if messages[nc] then
-            local n = copy_node_list(tonut(head))
+            local h = tonut(head)
+            local n = copy_node_list(h)
+            freeze(n,"register")
             injections.keepcounts(n) -- one-time
             injections.handler(n,"trace")
-         -- handlers.protectglyph   s(n) -- can be option
             protect_glyphs(n)
             collection[nc] = n
         end
diff --git a/tex/context/base/font-otn.lua b/tex/context/base/font-otn.lua
index e1be424b1..52fcbcbd6 100644
--- a/tex/context/base/font-otn.lua
+++ b/tex/context/base/font-otn.lua
@@ -42,7 +42,7 @@ if not modules then modules = { } end modules ['font-otn'] = {
 --
 -- beware:
 --
--- we do some disc juglling where we need to keep in mind that the
+-- we do some disc jugling where we need to keep in mind that the
 -- pre, post and replace fields can have prev pointers to a nesting
 -- node ... i wonder if that is still needed
 --
@@ -274,6 +274,7 @@ local setcursive         = injections.setcursive
 local setkern            = injections.setkern
 local setpair            = injections.setpair
 local resetinjection     = injections.reset
+local copyinjection      = injections.copy
 local setligaindex       = injections.setligaindex
 local getligaindex       = injections.getligaindex
 
@@ -385,10 +386,13 @@ local function copy_glyph(g) -- next and prev are untouched !
     if components then
         setfield(g,"components",nil)
         local n = copy_node(g)
+        copyinjection(n,g) -- we need to preserve the lig indices
         setfield(g,"components",components)
         return n
     else
-        return copy_node(g)
+        local n = copy_node(g)
+        copyinjection(n,g) -- we need to preserve the lig indices
+        return n
     end
 end
 
@@ -613,7 +617,9 @@ local function toligature(kind,lookupname,head,start,stop,char,markflag,discfoun
                 if trace_marks then
                     logwarning("%s: keep mark %s, gets index %s",pref(kind,lookupname),gref(char),getligaindex(start))
                 end
-                head, current = insert_node_after(head,current,copy_node(start)) -- unlikely that mark has components
+                local n = copy_node(start)
+                copyinjection(n,start)
+                head, current = insert_node_after(head,current,n) -- unlikely that mark has components
             elseif trace_marks then
                 logwarning("%s: delete mark %s",pref(kind,lookupname),gref(char))
             end
diff --git a/tex/context/base/font-pre.mkiv b/tex/context/base/font-pre.mkiv
index 6176c33ab..c184a2118 100644
--- a/tex/context/base/font-pre.mkiv
+++ b/tex/context/base/font-pre.mkiv
@@ -585,6 +585,7 @@
 \definefontfeature[f:smallcaps][smcp=yes]
 \definefontfeature[f:oldstyle] [onum=yes]
 \definefontfeature[f:tabular]  [tnum=yes]
+\definefontfeature[f:superiors][sups=yes]
 
 \definealternativestyle [\v!smallcaps] [\setsmallcaps] [\setsmallcaps]
 \definealternativestyle [\v!oldstyle]  [\setoldstyle ] [\setoldstyle ]
@@ -592,6 +593,7 @@
 \unexpanded\def\setsmallcaps{\doaddfeature{f:smallcaps}}
 \unexpanded\def\setoldstyle {\doaddfeature{f:oldstyle}}
 \unexpanded\def\settabular  {\doaddfeature{f:tabular}}
+\unexpanded\def\setsuperiors{\doaddfeature{f:superiors}}
 
 %D \macros
 %D   {tinyfont}
@@ -669,3 +671,30 @@
 %
 %   /lessorequalslant
 %   /greaterorequalslant
+
+% \unprotect
+%
+% \definehighlight[\v!italic    ][\c!command=\v!no,\c!style=\v!italic]
+% \definehighlight[\v!bold      ][\c!command=\v!no,\c!style=\v!bold]
+% \definehighlight[\v!bolditalic][\c!command=\v!no,\c!style=\v!bolditalic]
+% \definehighlight[\v!mono]      [\c!command=\v!no,\c!style=\v!mono]
+% \definehighlight[\v!monobold]  [\c!command=\v!no,\c!style=\v!monobold]
+%
+% \definehighlight[important]    [\c!command=\v!no,\c!style=\v!bold]
+% \definehighlight[unimportant]  [\c!command=\v!no,\c!color=darkgray]
+% \definehighlight[warning]      [\c!command=\v!no,\c!style=\v!bold,\c!color=darkblue]
+% \definehighlight[error]        [\c!command=\v!no,\c!style=\v!bold,\c!color=darkred]
+%
+% \protect
+%
+% \starttext
+%     \highlight[italic]     {italic}
+%     \highlight[bolditalic] {bolditalic}
+%     \highlight[bold]       {bold}
+%     \highlight[mono]       {mono}
+%     \highlight[monobold]   {monobold}
+%     \highlight[important]  {important}
+%     \highlight[unimportant]{unimportant}
+%     \highlight[warning]    {warning}
+%     \highlight[error]      {error}
+% \stoptext
diff --git a/tex/context/base/font-tfm.lua b/tex/context/base/font-tfm.lua
index 49df94e68..ab0378851 100644
--- a/tex/context/base/font-tfm.lua
+++ b/tex/context/base/font-tfm.lua
@@ -72,15 +72,15 @@ local function read_from_tfm(specification)
         properties.filename = specification.filename
         properties.format   = fonts.formats.tfm -- better than nothing
         parameters.size     = size
-        shared.rawdata      = { }
-        shared.features     = features
-        shared.processes    = next(features) and tfm.setfeatures(tfmdata,features) or nil
         --
         tfmdata.properties  = properties
         tfmdata.resources   = resources
         tfmdata.parameters  = parameters
         tfmdata.shared      = shared
         --
+        shared.rawdata      = { }
+        shared.features     = features
+        shared.processes    = next(features) and tfm.setfeatures(tfmdata,features) or nil
         parameters.slant         = parameters.slant          or parameters[1] or 0
         parameters.space         = parameters.space          or parameters[2] or 0
         parameters.space_stretch = parameters.space_stretch  or parameters[3] or 0
diff --git a/tex/context/base/lang-ini.lua b/tex/context/base/lang-ini.lua
index 27c4f774e..0c3d9d80b 100644
--- a/tex/context/base/lang-ini.lua
+++ b/tex/context/base/lang-ini.lua
@@ -58,9 +58,9 @@ local numbers        = languages.numbers
 languages.data       = languages.data       or { }
 local data           = languages.data
 
-storage.register("languages/numbers",   numbers,   "languages.numbers")
 storage.register("languages/registered",registered,"languages.registered")
 storage.register("languages/associated",associated,"languages.associated")
+storage.register("languages/numbers",   numbers,   "languages.numbers")
 storage.register("languages/data",      data,      "languages.data")
 
 local nofloaded  = 0
diff --git a/tex/context/base/lang-ini.mkiv b/tex/context/base/lang-ini.mkiv
index a55c4665a..71b631be9 100644
--- a/tex/context/base/lang-ini.mkiv
+++ b/tex/context/base/lang-ini.mkiv
@@ -111,6 +111,44 @@
      \csname\??language\s!default#2\endcsname
    \fi\fi\fi}
 
+\def\mainlanguageparameter#1%
+  {\ifcsname\??language\currentmainlanguage#1\endcsname
+     \csname\??language\currentmainlanguage#1\endcsname
+   \else\ifcsname\??language\currentmainlanguage\s!default\endcsname
+     \expandafter\specificlanguageparameter\csname\??language\currentmainlanguage\s!default\endcsname{#1}%
+   \else\ifcsname\??language\s!default#1\endcsname
+     \csname\??language\s!default#1\endcsname
+   \fi\fi\fi}
+
+\def\currentusedlanguage{\currentlanguage}
+
+\let\usedlanguageparameter\languageparameter
+
+\def\askedlanguageparameter#1% assumes \currentusedlanguage being set
+  {\ifcsname\??language\currentusedlanguage#1\endcsname
+     \csname\??language\currentusedlanguage#1\endcsname
+   \else\ifcsname\??language\currentusedlanguage\s!default\endcsname
+     \expandafter\specificlanguageparameter\csname\??language\currentusedlanguage\s!default\endcsname{#1}%
+   \else\ifcsname\??language\s!default#1\endcsname
+     \csname\??language\s!default#1\endcsname
+   \fi\fi\fi}
+
+\unexpanded\def\setlanguageparameter#1%
+  {\edef\currentusedlanguage{\reallanguagetag{#1\c!language}}%
+  %\let\setlanguageparameter\gobbleoneargument
+   \ifx\currentusedlanguage\empty
+     \let\currentusedlanguage  \currentlanguage
+     \let\usedlanguageparameter\languageparameter
+   \else\ifx\currentusedlanguage\v!global
+     \let\currentusedlanguage  \currentmainlanguage
+     \let\usedlanguageparameter\mainlanguageparameter
+   \else\ifx\currentusedlanguage\v!local
+     \let\currentusedlanguage  \currentlanguage
+     \let\usedlanguageparameter\languageparameter
+   \else
+     \let\usedlanguageparameter\askedlanguageparameter
+   \fi\fi\fi}
+
 \unexpanded\def\setupcurrentlanguage[#1]%
   {\setcurrentlanguage\currentmainlanguage{#1}}
 
diff --git a/tex/context/base/lang-lab.lua b/tex/context/base/lang-lab.lua
index 1540bc04e..1675146be 100644
--- a/tex/context/base/lang-lab.lua
+++ b/tex/context/base/lang-lab.lua
@@ -63,6 +63,7 @@ function labels.define(class,name,prefixed)
     if list then
         report_labels("defining label set %a",name)
         for tag, data in next, list do
+            tag = variables[tag] or tag
             if data.hidden then
                 -- skip
             elseif prefixed then
diff --git a/tex/context/base/lang-lab.mkiv b/tex/context/base/lang-lab.mkiv
index 27d35776d..c5c2adc01 100644
--- a/tex/context/base/lang-lab.mkiv
+++ b/tex/context/base/lang-lab.mkiv
@@ -237,7 +237,8 @@
   {\expandafter\def\csname\??label\currenttextprefixclass:\currenttextprefixtag:#1\endcsname{#2}}
 
 \unexpanded\def\setlabeltextpair#1#2#3#4#5% a fast one for usage at the Lua end
-  {\expandafter\def\csname\??label#1:\reallanguagetag{#2}:#3\endcsname{{#4}{#5}}} % class tag key left right
+  {%\writestatus{!!!!}{#1:\reallanguagetag{#2}:#3}%
+   \expandafter\def\csname\??label#1:\reallanguagetag{#2}:#3\endcsname{{#4}{#5}}} % class tag key left right
 
 \def\lang_labels_text_prefix_copy[#1][#2]%
   {\ifsecondargument
@@ -319,7 +320,7 @@
 %D \assigntranslation[en=something,nl=iets]\to\command
 %D \stoptyping
 
-\def\assigntranslation[#1]\to#2%
+\unexpanded\def\assigntranslation[#1]\to#2% bad, this \to
   {\getparameters[\??translation][#1]%
    \edef#2{\csname\??translation\currentlanguage\endcsname}}
 
diff --git a/tex/context/base/lpdf-ano.lua b/tex/context/base/lpdf-ano.lua
index dd83a44db..ac608baa4 100644
--- a/tex/context/base/lpdf-ano.lua
+++ b/tex/context/base/lpdf-ano.lua
@@ -331,7 +331,7 @@ local f_fith  = formatters["<< /D [ %i 0 R /FitH %0.3F ] >>"]
 local f_fitv  = formatters["<< /D [ %i 0 R /FitV %0.3F ] >>"]
 local f_fitbh = formatters["<< /D [ %i 0 R /FitBH %0.3F ] >>"]
 local f_fitbv = formatters["<< /D [ %i 0 R /FitBV %0.3F ] >>"]
-local f_fitr  = formatters["<< /D [ %i 0 R /FitR [ %0.3F %0.3F %0.3F %0.3F ] ] >>"]
+local f_fitr  = formatters["<< /D [ %i 0 R /FitR %0.3F %0.3F %0.3F %0.3F ] >>"]
 
 local v_standard  = variables.standard
 local v_frame     = variables.frame
@@ -344,15 +344,28 @@ local v_tight     = variables.tight
 
 -- nicer is to create dictionaries and set properties but it's a bit overkill
 
+-- The problem with the following settings is that they are guesses: we never know
+-- if a box is part of something larger that needs to be in view, or that we are
+-- dealing with a vbox or vtop so the used h/d values cannot be trusted in a tight
+-- view. Of course some decent additional offset would be nice so maybe i'll add
+-- that some day. I never use anything else than 'fit' anyway as I think that the
+-- document should fit the device (and vice versa). In fact, with todays swipe
+-- and finger zooming this whole view is rather useless and as with any zooming
+-- one looses the overview and keeps zooming.
+
 local destinationactions = {
-    [v_standard]  = function(r,w,h,d) return f_xyz  (r,pdfrectangle(w,h,d))  end, -- local left,top with zoom (0 in our case)
-    [v_frame]     = function(r,w,h,d) return f_fitr (r,pdfrectangle(w,h,d))  end, -- fit rectangle in window
-    [v_width]     = function(r,w,h,d) return f_fith (r, gethpos()   *factor) end, -- top coordinate, fit width of page in window
-    [v_minwidth]  = function(r,w,h,d) return f_fitbh(r, gethpos()   *factor) end, -- top coordinate, fit width of content in window
-    [v_height]    = function(r,w,h,d) return f_fitv (r,(getvpos()+h)*factor) end, -- left coordinate, fit height of page in window
-    [v_minheight] = function(r,w,h,d) return f_fitbv(r,(getvpos()+h)*factor) end, -- left coordinate, fit height of content in window
-    [v_fit]       =                          f_fit,                               -- fit page in window
-    [v_tight]     =                          f_fitb,                              -- fit content in window
+ -- [v_standard]  = function(r,w,h,d) return f_xyz  (r,pdfrectangle(w,h,d)) end,                   -- local left,top with zoom (0 in our case)
+    [v_standard]  = function(r,w,h,d) return f_xyz  (r,gethpos()*factor,(getvpos()+h)*factor) end, -- local left,top with no zoom
+    [v_frame]     = function(r,w,h,d) return f_fitr (r,pdfrectangle(w,h,d)) end,                   -- fit rectangle in window
+ -- [v_width]     = function(r,w,h,d) return f_fith (r,gethpos()*factor) end,                      -- top coordinate, fit width of page in window
+    [v_width]     = function(r,w,h,d) return f_fith (r,(getvpos()+h)*factor) end,                  -- top coordinate, fit width of page in window
+ -- [v_minwidth]  = function(r,w,h,d) return f_fitbh(r,gethpos()*factor) end,                      -- top coordinate, fit width of content in window
+    [v_minwidth]  = function(r,w,h,d) return f_fitbh(r,(getvpos()+h)*factor) end,                  -- top coordinate, fit width of content in window
+ -- [v_height]    = function(r,w,h,d) return f_fitv (r,(getvpos()+h)*factor) end,                  -- left coordinate, fit height of page in window
+    [v_height]    = function(r,w,h,d) return f_fitv (r,gethpos()*factor) end,                      -- left coordinate, fit height of page in window
+ -- [v_minheight] = function(r,w,h,d) return f_fitbv(r,(getvpos()+h)*factor) end,                  -- left coordinate, fit height of content in window
+    [v_minheight] = function(r,w,h,d) return f_fitbv(r,gethpos()*factor) end,                      -- left coordinate, fit height of content in window    [v_fit]       =                          f_fit,                                                 -- fit page in window
+    [v_tight]     =                          f_fitb,                                               -- fit content in window
 }
 
 local mapping = {
@@ -383,7 +396,7 @@ end)
 
 local function flushdestination(width,height,depth,names,view)
     local r = pdfpagereference(texgetcount("realpageno"))
-    if view == defaultview then
+    if view == defaultview or not view or view == "" then
         r = pagedestinations[r]
     else
         local action = view and destinationactions[view] or defaultaction
diff --git a/tex/context/base/lpdf-mis.lua b/tex/context/base/lpdf-mis.lua
index 748567125..a1b12d8c0 100644
--- a/tex/context/base/lpdf-mis.lua
+++ b/tex/context/base/lpdf-mis.lua
@@ -241,14 +241,19 @@ lpdf.registerdocumentfinalizer(flushjavascripts,"javascripts")
 -- -- --
 
 local pagespecs = {
-    [variables.max]         = { "FullScreen", false, false },
-    [variables.bookmark]    = { "UseOutlines", false, false },
-    [variables.fit]         = { "UseNone", false, true },
-    [variables.doublesided] = { "UseNone", "TwoColumnRight", true },
-    [variables.singlesided] = { "UseNone", false, false },
-    [variables.default]     = { "UseNone", "auto", false },
-    [variables.auto]        = { "UseNone", "auto", false },
-    [variables.none]        = { false, false, false },
+    [variables.max]         = { mode = "FullScreen",  layout = false,            fit = false, fixed = false, duplex = false },
+    [variables.bookmark]    = { mode = "UseOutlines", layout = false,            fit = false, fixed = false, duplex = false },
+    [variables.fit]         = { mode = "UseNone",     layout = false,            fit = true,  fixed = false, duplex = false },
+    [variables.doublesided] = { mode = "UseNone",     layout = "TwoColumnRight", fit = true,  fixed = false, duplex = false },
+    [variables.singlesided] = { mode = "UseNone",     layout = false,            fit = false, fixed = false, duplex = false },
+    [variables.default]     = { mode = "UseNone",     layout = "auto",           fit = false, fixed = false, duplex = false },
+    [variables.auto]        = { mode = "UseNone",     layout = "auto",           fit = false, fixed = false, duplex = false },
+    [variables.none]        = { mode = false,         layout = false,            fit = false, fixed = false, duplex = false },
+    -- new
+    [variables.fixed]       = { mode = "UseNone",     layout = "auto",           fit = false, fixed = true,  duplex = false }, -- noscale
+    [variables.landscape]   = { mode = "UseNone",     layout = "auto",           fit = false, fixed = true,  duplex = "DuplexFlipShortEdge" },
+    [variables.portrait]    = { mode = "UseNone",     layout = "auto",           fit = false, fixed = true,  duplex = "DuplexFlipLongEdge" },
+
 }
 
 local pagespec, topoffset, leftoffset, height, width, doublesided = "default", 0, 0, 0, 0, false
@@ -279,34 +284,50 @@ function codeinjections.setupcanvas(specification)
 end
 
 local function documentspecification()
+    if not pagespec or pagespec == "" then
+        pagespec = variables.default
+    end
+ -- local settings = utilities.parsers.settings_to_array(pagespec)
+ -- local spec     = pagespecs[variables.default]
+ -- for i=1,#settings do
+ --     local s = pagespecs[settings[i]]
+ --     if s then
+ --         for k, v in next, s do
+ --             spec[k] = v
+ --         end
+ --     end
+ -- end
     local spec = pagespecs[pagespec] or pagespecs[variables.default]
-    if spec then
-        local mode, layout, fit = spec[1], spec[2], spec[3]
-        if layout == variables.auto then
-            if doublesided then
-                spec = pagespecs[variables.doublesided] -- to be checked voor interfaces
-                if spec then
-                    mode, layout, fit = spec[1], spec[2], spec[3]
-                end
-            else
-                layout = false
+    if spec.layout == "auto" then
+        if doublesided then
+            local s = pagespecs[variables.doublesided] -- to be checked voor interfaces
+            for k, v in next, s do
+                spec[k] = v
             end
+        else
+            spec.layout = false
         end
-        mode = mode and pdfconstant(mode)
-        layout = layout and pdfconstant(layout)
-        fit = fit and pdfdictionary { FitWindow = true }
-        if layout then
-            addtocatalog("PageLayout",layout)
-        end
-        if mode then
-            addtocatalog("PageMode",mode)
-        end
-        if fit then
-            addtocatalog("ViewerPreferences",fit)
-        end
-        addtoinfo   ("Trapped", pdfconstant("False")) -- '/Trapped' in /Info, 'Trapped' in XMP
-        addtocatalog("Version", pdfconstant(format("1.%s",tex.pdfminorversion)))
     end
+    local layout = spec.layout
+    local mode   = spec.mode
+    local fit    = spec.fit
+    local fixed  = spec.fixed
+    local duplex = spec.duplex
+    if layout then
+        addtocatalog("PageLayout",pdfconstant(layout))
+    end
+    if mode then
+        addtocatalog("PageMode",pdfconstant(mode))
+    end
+    if fit or fixed or duplex then
+        addtocatalog("ViewerPreferences",pdfdictionary {
+            FitWindow    = fit    and true                or nil,
+            PrintScaling = fixed  and pdfconstant("None") or nil,
+            Duplex       = duplex and pdfconstant(duplex) or nil,
+        })
+    end
+    addtoinfo   ("Trapped", pdfconstant("False")) -- '/Trapped' in /Info, 'Trapped' in XMP
+    addtocatalog("Version", pdfconstant(format("1.%s",tex.pdfminorversion)))
 end
 
 -- temp hack: the mediabox is not under our control and has a precision of 4 digits
diff --git a/tex/context/base/luat-ini.mkiv b/tex/context/base/luat-ini.mkiv
index e47e8f74b..168b52095 100644
--- a/tex/context/base/luat-ini.mkiv
+++ b/tex/context/base/luat-ini.mkiv
@@ -204,6 +204,7 @@
 \def\setdocumentargumentdefault#1#2{\ctxlua{document.setdefaultargument("#1","#2")}}
 \def\getdocumentfilename         #1{\ctxlua{document.getfilename("#1")}}
 \def\getdocumentargument         #1{\ctxlua{document.getargument("#1")}}
+\def\setdocumentargument       #1#2{\ctxlua{document.setargument("#1","#2")}}
 \def\getdocumentargumentdefault#1#2{\ctxlua{document.getargument("#1","#2")}}
 \def\doifdocumentargumentelse    #1{\doifsomethingelse{\getdocumentargument{#1}}}
 \def\doifdocumentargument        #1{\doifsomething    {\getdocumentargument{#1}}}
@@ -323,4 +324,21 @@
 \def\ctxfunction#1%
   {\csname\??ctxfunction#1\endcsname}
 
+% In theory this is faster due to the call not being wrapped in a function but in
+% practice the speedup can't be noticed. The actions called for often have lots of
+% lookups so an extra one doesn't matter much. The kind of calls differs a lot per
+% document and often there are other ways to optimize a style. For instance we can
+% gain a lot when defining a font, but when a frozen definition is used that gain
+% gets completely lost. For some calls (take list writers) it can get worse if only
+% because readability gets worse and passing is already efficient due to selective
+% flushing, while with the token scanners one has to scan all of them.
+
+% \startctxfunctiondefinition foo commands.foo() \stopctxfunctiondefinition
+%
+% \installctxfunction\foo{commands.foo}
+
+\normalprotected\def\installctxfunction#1#2%
+  {\expandafter\chardef\csname\??luafunction\checkedstrippedcsname#1\endcsname\ctxcommand{ctxfunction("#2",true)}\relax
+   \expandafter\edef\csname\checkedstrippedcsname#1\endcsname{\noexpand\luafunction\csname\??luafunction\checkedstrippedcsname#1\endcsname}}
+
 \protect \endinput
diff --git a/tex/context/base/luat-mac.lua b/tex/context/base/luat-mac.lua
index 9c3f792dd..15bc14132 100644
--- a/tex/context/base/luat-mac.lua
+++ b/tex/context/base/luat-mac.lua
@@ -144,7 +144,10 @@ local grammar = { "converter",
                 * V("texbody")
                 * stopcode
                 * poplocal,
-    texbody     = (   V("definition")
+    texbody     = (
+leadingcomment -- new per 2015-03-03 (ugly)
++
+                      V("definition")
                     + identifier
                     + V("braced")
                     + (1 - stopcode)
diff --git a/tex/context/base/lxml-ini.mkiv b/tex/context/base/lxml-ini.mkiv
index 0092ea4f4..a7cdff862 100644
--- a/tex/context/base/lxml-ini.mkiv
+++ b/tex/context/base/lxml-ini.mkiv
@@ -56,7 +56,7 @@
 %def\xmlcontent             #1{\ctxlxml{content("#1")}}
 %def\xmlflushstripped       #1{\ctxlxml{strip("#1",true)}}
 \def\xmldirect              #1{\ctxlxml{direct("#1")}} % in loops, not dt but root
-\def\xmlidx             #1#2#3{\ctxlxml{idx("#1","#2",\number#3)}}
+\def\xmlidx             #1#2#3{\ctxlxml{idx("#1","#2",\number#3)}} % not ok
 \def\xmlinclude         #1#2#3{\ctxlxml{include("#1","#2","#3",true)}}
 \def\xmlincludeoptions#1#2#3#4{\ctxlxml{include("#1","#2","#3","#4")}}
 \def\xmlinclusion           #1{\ctxlxml{inclusion("#1")}}
@@ -100,7 +100,19 @@
 
 \def\xmltoparameters        #1{\ctxlxml{toparameters("#1")}}
 
-\def\xmltofile          #1#2#3{\ctxlxml{tofile("#1","#2","#3")}} % id pattern filename
+\def\xmltofile          #1#2#3{\ctxlxml{tofile("#1","#2","#3")}}        % id pattern filename
+\def\xmltobuffer        #1#2#3{\ctxlxml{tobuffer("#1","#2","#3")}}      % id pattern name
+\def\xmltobufferverbose #1#2#3{\ctxlxml{tobuffer("#1","#2","#3",true)}} % id pattern name
+
+% goodie:
+
+\unexpanded\def\xmlprettyprint#1#2%
+  {\xmltobufferverbose{#1}{.}{xml-temp}%
+   \ifdefined\scitebuffer
+     \scitebuffer[#2][xml-temp]%
+   \else
+     \typebuffer[xml-temp][\c!option=#2]%
+   \fi}
 
 % kind of special:
 
@@ -135,8 +147,8 @@
 %\ef\xmlsetup#1#2{\setupwithargument{#2}{#1}}
 \let\xmlsetup\setupwithargumentswapped
 
-\let\xmls\setupwithargumentswapped
-\let\xmlw\setupwithargument
+\let\xmls\setupwithargumentswapped % hardly any faster
+\let\xmlw\setupwithargument        % hardly any faster
 
 \newtoks \registeredxmlsetups
 
diff --git a/tex/context/base/lxml-tab.lua b/tex/context/base/lxml-tab.lua
index 6ab12c898..0a72640d0 100644
--- a/tex/context/base/lxml-tab.lua
+++ b/tex/context/base/lxml-tab.lua
@@ -951,14 +951,18 @@ and then handle the lot.</p>
 
 -- new experimental reorganized serialize
 
-local function verbose_element(e,handlers) -- options
+local f_attribute = formatters['%s=%q']
+
+local function verbose_element(e,handlers,escape) -- options
     local handle = handlers.handle
     local serialize = handlers.serialize
     local ens, etg, eat, edt, ern = e.ns, e.tg, e.at, e.dt, e.rn
     local ats = eat and next(eat) and { }
     if ats then
+        local n = 0
         for k,v in next, eat do
-            ats[#ats+1] = formatters['%s=%q'](k,escaped(v))
+            n = n + 1
+            ats[n] = f_attribute(k,escaped(v))
         end
     end
     if ern and trace_entities and ern ~= ens then
diff --git a/tex/context/base/lxml-tex.lua b/tex/context/base/lxml-tex.lua
index c33fdbc49..3e2ce82c5 100644
--- a/tex/context/base/lxml-tex.lua
+++ b/tex/context/base/lxml-tex.lua
@@ -39,6 +39,7 @@ local xmlapplylpath = xml.applylpath
 local xmlunprivatized, xmlprivatetoken, xmlprivatecodes = xml.unprivatized, xml.privatetoken, xml.privatecodes
 local xmlstripelement = xml.stripelement
 local xmlinclusion, xmlinclusions = xml.inclusion, xml.inclusions
+local xmlcontent = xml.content
 
 local variables         = interfaces and interfaces.variables or { }
 
@@ -1811,3 +1812,17 @@ end
 
 texfinalizers.upperall = xmlfinalizers.upperall
 texfinalizers.lowerall = xmlfinalizers.lowerall
+
+function lxml.tobuffer(id,pattern,name,unescaped)
+    local collected = xmlapplylpath(getid(id),pattern)
+    if collected then
+        if unescaped then
+            collected = xmlcontent(collected[1]) -- expanded entities !
+        else
+            collected = tostring(collected[1])
+        end
+        buffers.assign(name,collected)
+    else
+        buffers.erase(name)
+    end
+end
diff --git a/tex/context/base/m-chart.lua b/tex/context/base/m-chart.lua
index 2b9869379..92b079b8d 100644
--- a/tex/context/base/m-chart.lua
+++ b/tex/context/base/m-chart.lua
@@ -229,6 +229,8 @@ function commands.flow_start_cell(settings)
         settings    = settings,
         x           = 1,
         y           = 1,
+        realx       = 1,
+        realy       = 1,
         name        = "",
     }
 end
@@ -325,9 +327,13 @@ local function inject(includedata,data,hash)
         if si.include then
             inject(si,data,hash)
         else
+            local x = si.x + xoffset
+            local y = si.y + yoffset
             local t = {
-                x        = si.x + xoffset,
-                y        = si.y + yoffset,
+                x        = x,
+                y        = y,
+                realx    = x,
+                realy    = y,
                 settings = settings,
             }
             setmetatableindex(t,si)
@@ -451,10 +457,12 @@ function commands.flow_set_location(x,y)
     else
         y = tonumber(y)
     end
-    temp.x = x or 1
-    temp.y = y or 1
-    last_x = x or last_x
-    last_y = y or last_y
+    temp.x     = x or 1
+    temp.y     = y or 1
+    temp.realx = x or 1
+    temp.realy = y or 1
+    last_x     = x or last_x
+    last_y     = y or last_y
 end
 
 function commands.flow_set_connection(location,displacement,name)
@@ -686,6 +694,7 @@ local function getchart(settings,forced_x,forced_y,forced_nx,forced_ny)
         print("no such chart",chartname)
         return
     end
+-- chart = table.copy(chart)
     chart = expanded(chart,settings)
     local chartsettings = chart.settings.chart
     local autofocus = chart.settings.chart.autofocus
@@ -746,8 +755,8 @@ local function getchart(settings,forced_x,forced_y,forced_nx,forced_ny)
     -- relocate cells
     for i=1,#data do
         local cell = data[i]
-        cell.x = cell.x - minx + 1
-        cell.y = cell.y - miny + 1
+        cell.x = cell.realx - minx + 1
+        cell.y = cell.realy - miny + 1
     end
     chart.from_x = 1
     chart.from_y = 1
@@ -756,7 +765,9 @@ local function getchart(settings,forced_x,forced_y,forced_nx,forced_ny)
     chart.nx     = nx
     chart.ny     = ny
     --
- -- inspect(chart)
+    chart.shift_x = minx + 1
+    chart.shift_y = miny + 1
+    --
     return chart
 end
 
@@ -854,7 +865,7 @@ local function splitchart(chart)
     local delta_x = splitsettings.dx or 0
     local delta_y = splitsettings.dy or 0
     --
-    report_chart("spliting %a from (%s,%s) upto (%s,%s) into (%s,%s) with overlap (%s,%s)",
+    report_chart("spliting %a from (%s,%s) upto (%s,%s) with steps (%s,%s) and overlap (%s,%s)",
         name,from_x,from_y,to_x,to_y,step_x,step_y,delta_x,delta_y)
     --
     local part_x = 0
@@ -866,6 +877,9 @@ local function splitchart(chart)
         if done then
             last_x = to_x
         end
+-- if first_x >= to_x then
+--     break
+-- end
         local part_y = 0
         local first_y = from_y
         while true do
@@ -875,14 +889,31 @@ local function splitchart(chart)
             if done then
                 last_y = to_y
             end
+-- if first_y >= to_y then
+--     break
+-- end
             --
+local data = chart.data
+for i=1,#data do
+    local cell = data[i]
+--     inspect(cell)
+    local cx, cy = cell.x, cell.y
+    if cx >= first_x and cx <= last_x then
+        if cy >= first_y and cy <= last_y then
             report_chart("part (%s,%s) of %a is split from (%s,%s) -> (%s,%s)",part_x,part_y,name,first_x,first_y,last_x,last_y)
-            local x, y, nx, ny = first_x, first_y, last_x - first_x + 1,last_y - first_y + 1
+            local x  = first_x
+            local y  = first_y
+            local nx = last_x - first_x + 1
+            local ny = last_y - first_y + 1
             context.beforeFLOWsplit()
             context.handleFLOWsplit(function()
                 makechart(getchart(settings,x,y,nx,ny)) -- we need to pass frozen settings !
             end)
             context.afterFLOWsplit()
+            break
+        end
+    end
+end
             --
             if done then
                 break
diff --git a/tex/context/base/m-chart.mkvi b/tex/context/base/m-chart.mkvi
index 2b1a7447c..f910b88eb 100644
--- a/tex/context/base/m-chart.mkvi
+++ b/tex/context/base/m-chart.mkvi
@@ -177,7 +177,7 @@
             corner          = "\FLOWlineparameter\c!corner",
             dash            = "\FLOWlineparameter\c!dash",
             arrow           = "\FLOWlineparameter\c!arrow",
-            offset          = "\FLOWlineparameter\c!offset",
+            offset          = \number\dimexpr\FLOWlineparameter\c!offset,
         },
   } }%
   \endgroup}
@@ -259,8 +259,9 @@
 
 \def\FLOW_charts[#name][#settings]
   {\begingroup
-   \setupFLOWsplit[\c!state=\v!start,#settings]%
-   \FLOW_chart[#name][]%
+   \setupFLOWchart[\c!split=\v!yes]%
+   \setupFLOWsplit[#settings]%
+   \module_charts_process[#name][]% \FLOWchart...
    \endgroup}
 
 \appendtoks
diff --git a/tex/context/base/m-scite.mkiv b/tex/context/base/m-scite.mkiv
index 93349122d..7a8e8b06e 100644
--- a/tex/context/base/m-scite.mkiv
+++ b/tex/context/base/m-scite.mkiv
@@ -199,6 +199,7 @@ end
    \installscitecommands
    \tt
    \dontcomplain
+   \setcatcodetable\ctxcatcodes % needed in xml
    \startscite
    \getbuffer[lex]%
    \stopscite
@@ -217,6 +218,7 @@ end
    \installscitecommands
    \tt
    \dontcomplain
+   \setcatcodetable\ctxcatcodes % needed in xml
    \startscite
    \getbuffer[lex]%
    \stopscite
diff --git a/tex/context/base/math-ini.mkiv b/tex/context/base/math-ini.mkiv
index 7cee9fb31..4ee7c6826 100644
--- a/tex/context/base/math-ini.mkiv
+++ b/tex/context/base/math-ini.mkiv
@@ -199,7 +199,7 @@
 
 \installcorenamespace{mathstylealternate} % might become a setuphandler
 
-\unexpanded\def\math_set_font_style_alterternate#1%
+\unexpanded\def\math_set_font_style_alternate#1%
   {\ifcsname\??mathstylealternate\fontclass:#1\endcsname
      \expandafter\math_set_font_alternate\csname\??mathstylealternate\fontclass:#1\endcsname
    \else\ifcsname\??mathstylealternate#1\endcsname
@@ -222,27 +222,27 @@
 \let\setmathalphabet             \math_set_alphabet
 \let\setmathfontstyle            \math_set_font_style
 \let\setmathfontalternate        \math_set_font_alternate
-\let\setmathfontstylealterternate\math_set_font_style_alterternate
+\let\setmathfontstylealternate\math_set_font_style_alternate
 
 \let\mathalternate               \math_set_font_alternate % obsolete
 
-\unexpanded\def\mathupright   {\math_set_attribute\s!regular\s!tf\math_set_font_style_alterternate\s!tf}
-\unexpanded\def\mathdefault   {\math_set_attribute\s!regular\s!it\math_set_font_style_alterternate\s!it}
-\unexpanded\def\mathscript    {\math_set_alphabet \s!script      \math_set_font_style_alterternate\s!script}
-\unexpanded\def\mathfraktur   {\math_set_alphabet \s!fraktur     \math_set_font_style_alterternate\s!fraktur}
-\unexpanded\def\mathblackboard{\math_set_alphabet \s!blackboard  \math_set_font_style_alterternate\s!blackboard}
+\unexpanded\def\mathupright   {\math_set_attribute\s!regular\s!tf\math_set_font_style_alternate\s!tf}
+\unexpanded\def\mathdefault   {\math_set_attribute\s!regular\s!it\math_set_font_style_alternate\s!it}
+\unexpanded\def\mathscript    {\math_set_alphabet \s!script      \math_set_font_style_alternate\s!script}
+\unexpanded\def\mathfraktur   {\math_set_alphabet \s!fraktur     \math_set_font_style_alternate\s!fraktur}
+\unexpanded\def\mathblackboard{\math_set_alphabet \s!blackboard  \math_set_font_style_alternate\s!blackboard}
 
-\unexpanded\def\mathrm        {\math_set_attribute\s!rm\s!tf     \math_set_font_style_alterternate\s!tf}
-\unexpanded\def\mathss        {\math_set_attribute\s!ss\s!tf     \math_set_font_style_alterternate\s!tf}
-\unexpanded\def\mathtt        {\math_set_attribute\s!tt\s!tf     \math_set_font_style_alterternate\s!tf}
+\unexpanded\def\mathrm        {\math_set_attribute\s!rm\s!tf     \math_set_font_style_alternate\s!tf}
+\unexpanded\def\mathss        {\math_set_attribute\s!ss\s!tf     \math_set_font_style_alternate\s!tf}
+\unexpanded\def\mathtt        {\math_set_attribute\s!tt\s!tf     \math_set_font_style_alternate\s!tf}
 
-\unexpanded\def\mathtf        {\math_set_font_style\s!tf         \math_set_font_style_alterternate\s!tf}
-\unexpanded\def\mathsl        {\math_set_font_style\s!it         \math_set_font_style_alterternate\s!it} % no sl
-\unexpanded\def\mathit        {\math_set_font_style\s!it         \math_set_font_style_alterternate\s!it}
+\unexpanded\def\mathtf        {\math_set_font_style\s!tf         \math_set_font_style_alternate\s!tf}
+\unexpanded\def\mathsl        {\math_set_font_style\s!it         \math_set_font_style_alternate\s!it} % no sl
+\unexpanded\def\mathit        {\math_set_font_style\s!it         \math_set_font_style_alternate\s!it}
 
-\unexpanded\def\mathbf        {\math_set_font_style\s!bf         \math_set_font_style_alterternate\s!bf}
-\unexpanded\def\mathbs        {\math_set_font_style\s!bi         \math_set_font_style_alterternate\s!bi} % no sl
-\unexpanded\def\mathbi        {\math_set_font_style\s!bi         \math_set_font_style_alterternate\s!bi}
+\unexpanded\def\mathbf        {\math_set_font_style\s!bf         \math_set_font_style_alternate\s!bf}
+\unexpanded\def\mathbs        {\math_set_font_style\s!bi         \math_set_font_style_alternate\s!bi} % no sl
+\unexpanded\def\mathbi        {\math_set_font_style\s!bi         \math_set_font_style_alternate\s!bi}
 
 \let\tfmath\mathtf % maybe a grouped command
 \let\slmath\mathsl
@@ -280,9 +280,9 @@
 \ifdefined\mb \else \let\mb\relax \fi
 
 % 1: $\setmathattribute{ss}{bf}3$
-% 2: $\setmathattribute{ss}{bf}\setmathfontstylealterternate{bf}3$
+% 2: $\setmathattribute{ss}{bf}\setmathfontstylealternate{bf}3$
 % 3: $\setmathattribute{ss}{bf}\setmathfontstyle{bf}3$
-% 4: $\setmathattribute{ss}{bf}\setmathfontstyle{bf}\setmathfontstylealterternate{bf}3$
+% 4: $\setmathattribute{ss}{bf}\setmathfontstyle{bf}\setmathfontstylealternate{bf}3$
 % 5: $e=mc^2 \quad \mb e=mc^2$
 
 \prependtoks
diff --git a/tex/context/base/math-noa.lua b/tex/context/base/math-noa.lua
index 0dec3a7b2..be1f4a9b5 100644
--- a/tex/context/base/math-noa.lua
+++ b/tex/context/base/math-noa.lua
@@ -715,6 +715,11 @@ end
 -- = we check for correction first because accessing nodes is slower
 -- = the actual glyph is not that important (we can control it with numbers)
 
+-- Italic correction in luatex math is a mess. There are all kind of assumptions based on
+-- old fonts and new font. Eventually there should be a flag that can signal to ignore all
+-- those heuristics. We want to deal with it ourselves also in the perspective of mxed math
+-- and text.
+
 local a_mathitalics = privateattribute("mathitalics")
 
 local italics        = { }
@@ -798,7 +803,7 @@ local function insert_kern(current,kern)
     return sub
 end
 
-registertracker("math.italics", function(v)
+registertracker("math.italics.visualize", function(v)
     if v then
         italic_kern = function(k,font)
             local ex = 1.5 * fontexheights[font]
@@ -843,12 +848,14 @@ italics[math_char] = function(pointer,what,n,parent)
                             report_italics("method %a, adding %p italic correction for lower limit of %C",method,correction,char)
                         end
                     end
-                else
-                    if sup then
+                elseif sup then
+                    if pointer ~= sub then
                         setfield(parent,"sup",insert_kern(sup,italic_kern(correction,font)))
                         if trace_italics then
                             report_italics("method %a, adding %p italic correction before superscript after %C",method,correction,char)
                         end
+                    else
+                        -- otherwise we inject twice
                     end
                 end
             else
diff --git a/tex/context/base/mtx-context-arrange.tex b/tex/context/base/mtx-context-arrange.tex
index 49920293f..39373f0e2 100644
--- a/tex/context/base/mtx-context-arrange.tex
+++ b/tex/context/base/mtx-context-arrange.tex
@@ -27,7 +27,7 @@
 % --printformat           : 2UP, etc
 % --paperformat=spec      : paper*print or paperxprint
 %
-% example: context --extra=arrange --printformat=2UP --paperformat=A4,A3,landscape myfile
+% example: context --extra=arrange --printformat=2UP --paperformat=A4*A3,landscape myfile
 %
 % end help
 
diff --git a/tex/context/base/mtx-context-listing.tex b/tex/context/base/mtx-context-listing.tex
index 8b7efd8a5..a38fc60a9 100644
--- a/tex/context/base/mtx-context-listing.tex
+++ b/tex/context/base/mtx-context-listing.tex
@@ -24,11 +24,18 @@
 % --scite               : pretty print comform suffix using scite lexer
 % --bodyfont=list       : additional bodyfont settings
 % --paperformat=spec    : paper*print or paperxprint
+% --compact             : small margins, small font
 %
 % end help
 
 \input mtx-context-common.tex
 
+\doifdocumentargument {compact} {
+    \setdocumentargument{topspace} {5mm}
+    \setdocumentargument{backspace}{5mm}
+    \setdocumentargument{bodyfont} {8pt}
+}
+
 \setupbodyfont
   [dejavu,11pt,tt,\getdocumentargument{bodyfont}] % dejavu is more complete
 
diff --git a/tex/context/base/mult-aux.mkiv b/tex/context/base/mult-aux.mkiv
index 11414f38b..1fb951048 100644
--- a/tex/context/base/mult-aux.mkiv
+++ b/tex/context/base/mult-aux.mkiv
@@ -1125,6 +1125,85 @@
 %   % \syst_helpers_do_do_process_comma_item##1,]\relax
 % \global\advance\commalevel \minusone
 
+% The next one is experimental (and used in publications):
+
+\let\c_mult_set\relax
+
+\unexpanded\def\mult_interfaces_install_definition_set#1#2#3#4#5#6#7%
+  {\newcount#3%
+   \let#6\empty
+   \unexpanded\def#2%
+     {\expandafter\let\expandafter\c_mult_set\csname #1_t_#6\endcsname
+      \ifx\c_mult_set\relax
+        \expandafter\newtoks\c_mult_set
+        \expandafter\let\csname #1_t_#6\endcsname\c_mult_set
+      \fi}
+   \unexpanded\def#4##1%
+     {\pushmacro#6%
+      \advance#3\plusone
+      \edef#6{##1}%
+      \unprotect}%
+   \unexpanded\def#5%
+     {\protect
+      \advance#3\minusone
+      \popmacro#6}%
+   \unexpanded\def#7##1%
+     {\edef#6{##1}%
+      #2%
+      \the\c_mult_set\relax}}
+
+\unexpanded\def\installdefinitionset#1#2%
+  {\normalexpanded
+     {\mult_interfaces_install_definition_set
+        {\noexpand#1}% \??aa
+        \expandafter\noexpand\csname set_#2_toks\endcsname
+        \expandafter\noexpand\csname #2_nesting_depth\endcsname
+        \expandafter\noexpand\csname push#2\endcsname
+        \expandafter\noexpand\csname pop#2\endcsname
+        \expandafter\noexpand\csname current#2\endcsname
+        \expandafter\noexpand\csname use#2\endcsname}}
+
+\unexpanded\def\mult_interfaces_install_definition_set_member#1#2#3#4#5#6#7#8#9% no everysetups etc
+  {\let#5#2%
+   \unexpanded\def#2%
+     {\ifcase#4\relax\expandafter#5\else\expandafter#6\fi}%
+   \unexpanded\def#6%
+     {\dodoubleempty#7}%
+   \unexpanded\def#7[##1][##2]%
+     {\ifsecondargument
+        #3\c_mult_set\expandafter{\the\c_mult_set#9[##1][##2]}%
+      \else\iffirstargument
+        #3\c_mult_set\expandafter{\the\c_mult_set#8[##1]}%
+      \fi\fi}}
+
+\unexpanded\def\installdefinitionsetmember#1#2#3#4%
+  {\normalexpanded
+     {\mult_interfaces_install_definition_set_member
+        {\noexpand#3}% \??aa
+        \expandafter\noexpand\csname setup#4\endcsname
+        \expandafter\noexpand\csname set_#2_toks\endcsname
+        \expandafter\noexpand\csname #2_nesting_depth\endcsname
+        \expandafter\noexpand\csname normal_setup_#4\endcsname
+        \expandafter\noexpand\csname delayed_setup_#4\endcsname
+        \expandafter\noexpand\csname do_delayed_setup_#4\endcsname
+        \expandafter\noexpand\csname setup#4_\s!single\endcsname
+        \expandafter\noexpand\csname setup#4_\s!double\endcsname}}
+
+%D Another experiment:
+
+\unexpanded\def\mult_interfaces_install_parent_injector#1#2#3#4%
+  {\unexpanded\def#4##1%
+     {\ifx#3\empty
+        \expandafter\def\csname#1#2:\s!parent\endcsname{#1##1}%
+      \fi}}
+
+\unexpanded\def\installparentinjector#1#2%
+  {\normalexpanded{\mult_interfaces_install_parent_injector
+     {\noexpand#1}%
+     \expandafter\noexpand\csname current#2\endcsname
+     \expandafter\noexpand\csname current#2parent\endcsname
+     \expandafter\noexpand\csname inject#2parent\endcsname}}
+
 \protect
 
 %\unprotect
diff --git a/tex/context/base/mult-def.lua b/tex/context/base/mult-def.lua
index d1c340c1e..c3d50d83d 100644
--- a/tex/context/base/mult-def.lua
+++ b/tex/context/base/mult-def.lua
@@ -8969,7 +8969,7 @@ return {
    ["de"]="mindepth",
    ["en"]="mindepth",
    ["fr"]="profondeurmin",
-   ["it"]="mindeoth",
+   ["it"]="mindepth",
    ["nl"]="mindiepte",
    ["pe"]="کمترین‌عمق",
    ["ro"]="mindepth",
@@ -11545,21 +11545,27 @@ return {
   },
   ["maxheight"]={
    ["en"]="maxheight",
+   ["nl"]="maxhoogte",
   },
   ["maxdepth"]={
    ["en"]="maxdepth",
+   ["nl"]="maxdiepte",
   },
   ["maxwidth"]={
    ["en"]="maxwidth",
+   ["nl"]="maxbreedte",
   },
   ["minheight"]={
    ["en"]="minheight",
+   ["nl"]="minhoogte",
   },
   ["mindepth"]={
    ["en"]="mindepth",
+   ["nl"]="mindiepte",
   },
   ["minwidth"]={
    ["en"]="minwidth",
+   ["nl"]="minbreedte",
   },
   ["short"]={
    ["nl"]="kort",
diff --git a/tex/context/base/mult-def.mkiv b/tex/context/base/mult-def.mkiv
index e456d1568..438df2308 100644
--- a/tex/context/base/mult-def.mkiv
+++ b/tex/context/base/mult-def.mkiv
@@ -32,13 +32,15 @@
 
 \ctxlua{interfaces.setuserinterface("\userinterfacetag","\userresponsestag")}
 
-% start todo in muld-def.lua:
+% start todo in mult-def.lua:
 
 \def\v!alphabetic        {alphabetic}
 \def\v!Alphabetic        {Alphabetic}
 
 \def\c!svgstyle          {svgstyle}
 
+\def\c!translate         {translate}
+
 \def\c!nextleft          {nextleft}
 \def\c!nextright         {nextright}
 \def\c!nextleftquotation {nextleftquotation}
diff --git a/tex/context/base/mult-fun.lua b/tex/context/base/mult-fun.lua
index 280d6bd5b..27aa32055 100644
--- a/tex/context/base/mult-fun.lua
+++ b/tex/context/base/mult-fun.lua
@@ -20,6 +20,7 @@ return {
         "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian",
         "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos",
         "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh",
+        "zmod",
         "paired", "tripled",
         "unitcircle", "fulldiamond", "unitdiamond", "fullsquare",
      -- "halfcircle", "quartercircle",
diff --git a/tex/context/base/mult-it.mkii b/tex/context/base/mult-it.mkii
index e31245549..9b0ea7b15 100644
--- a/tex/context/base/mult-it.mkii
+++ b/tex/context/base/mult-it.mkii
@@ -838,7 +838,7 @@
 \setinterfaceconstant{middletext}{testocentro}
 \setinterfaceconstant{midsentence}{midsentence}
 \setinterfaceconstant{min}{min}
-\setinterfaceconstant{mindepth}{mindeoth}
+\setinterfaceconstant{mindepth}{mindepth}
 \setinterfaceconstant{minheight}{altezzamin}
 \setinterfaceconstant{minwidth}{ampiezzamin}
 \setinterfaceconstant{moffset}{moffset}
diff --git a/tex/context/base/mult-low.lua b/tex/context/base/mult-low.lua
index 460128d96..22bab6f32 100644
--- a/tex/context/base/mult-low.lua
+++ b/tex/context/base/mult-low.lua
@@ -156,7 +156,7 @@ return {
         "then",
         "begcsname",
         --
-        "strippedcsname",
+        "strippedcsname","checkedstrippedcsname",
         --
         "firstargumentfalse", "firstargumenttrue",
         "secondargumentfalse", "secondargumenttrue",
@@ -369,7 +369,7 @@ return {
         "obeylualines", "obeyluatokens",
         "startluacode", "stopluacode", "startlua", "stoplua",
         "startctxfunction","stopctxfunction","ctxfunction",
-        "startctxfunctiondefinition","stopctxfunctiondefinition",
+        "startctxfunctiondefinition","stopctxfunctiondefinition", "installctxfunction",
         --
         "carryoverpar",
         --
diff --git a/tex/context/base/mult-nl.mkii b/tex/context/base/mult-nl.mkii
index 07a16f67a..a84494cfb 100644
--- a/tex/context/base/mult-nl.mkii
+++ b/tex/context/base/mult-nl.mkii
@@ -288,15 +288,15 @@
 \setinterfacevariable{mathematics}{wiskunde}
 \setinterfacevariable{mathmatrix}{wiskundematrix}
 \setinterfacevariable{max}{max}
-\setinterfacevariable{maxdepth}{maxdepth}
-\setinterfacevariable{maxheight}{maxheight}
-\setinterfacevariable{maxwidth}{maxwidth}
+\setinterfacevariable{maxdepth}{maxdiepte}
+\setinterfacevariable{maxheight}{maxhoogte}
+\setinterfacevariable{maxwidth}{maxbreedte}
 \setinterfacevariable{may}{mei}
 \setinterfacevariable{mediaeval}{mediaeval}
 \setinterfacevariable{medium}{middel}
 \setinterfacevariable{middle}{midden}
 \setinterfacevariable{min}{min}
-\setinterfacevariable{mindepth}{mindepth}
+\setinterfacevariable{mindepth}{mindiepte}
 \setinterfacevariable{minheight}{minhoogte}
 \setinterfacevariable{minwidth}{minbreedte}
 \setinterfacevariable{mirrored}{gespiegeld}
diff --git a/tex/context/base/node-fnt.lua b/tex/context/base/node-fnt.lua
index 1dd944403..774a68718 100644
--- a/tex/context/base/node-fnt.lua
+++ b/tex/context/base/node-fnt.lua
@@ -319,28 +319,44 @@ function handlers.characters(head)
         -- skip
     elseif b == 1 then
         -- only one font
+        local front = head == start
         local range = basefonts[1]
-        local start, stop = range[1], range[2]
+        local start = range[1]
+        local stop  = range[2]
         if stop then
-            ligaturing(start,stop)
-            kerning(start,stop)
+            start, stop = ligaturing(start,stop)
+            start, stop = kerning(start,stop)
+        elseif start then -- safeguard
+            start = ligaturing(start)
+            start = kerning(start)
         else
-            ligaturing(start)
-            kerning(start)
+            -- something bad happened
+        end
+        if front then
+            -- shouldn't happen
+            head = start
         end
     else
         -- multiple fonts
+        local front = head == start
         for i=1,b do
             local range = basefonts[i]
-            local start, stop = range[1], range[2]
+            local start = range[1]
+            local stop  = range[2]
             if stop then
-                ligaturing(start,stop)
-                kerning(start,stop)
+                start, stop = ligaturing(start,stop)
+                start, stop = kerning(start,stop)
+            elseif start then -- safeguard
+                start = ligaturing(start)
+                start = kerning(start)
             else
-                ligaturing(start)
-                kerning(start)
+                -- something bad happened
             end
         end
+        if front then
+            -- shouldn't happen
+            head = start
+        end
     end
     stoptiming(nodes)
     if trace_characters then
diff --git a/tex/context/base/node-nut.lua b/tex/context/base/node-nut.lua
index cbf1c686c..32f2d57ec 100644
--- a/tex/context/base/node-nut.lua
+++ b/tex/context/base/node-nut.lua
@@ -86,10 +86,14 @@ if not modules then modules = { } end modules ['node-met'] = {
 -- luatex    3.9 sec / 54 pps
 -- luajittex 2.3 sec / 93 pps
 
+local type, rawget = type, rawget
+
 local nodes               = nodes
 local gonuts              = nodes.gonuts
 local direct              = node.direct
 
+local fastcopy            = table.fastcopy
+
 if type(direct) ~= "table" then
     return
 elseif gonuts then
@@ -720,3 +724,31 @@ else
     nodes.getprop = setattr
 
 end
+
+function nuts.copy_properties(source,target,what)
+    local newprops = propertydata[source]
+    if not newprops then
+        -- nothing to copy
+        return
+    end
+    if what then
+        -- copy one category
+        newprops = rawget(source,what)
+        if newprops then
+            newprops = fastcopy(newprops)
+            local p = rawget(propertydata,target)
+            if p then
+                p[what] = newprops
+            else
+                propertydata[target] = {
+                    [what] = newprops,
+                }
+            end
+        end
+    else
+        -- copy all properties
+        newprops = fastcopy(newprops)
+        propertydata[target] = newprops
+    end
+    return newprops -- for checking
+end
diff --git a/tex/context/base/node-ref.lua b/tex/context/base/node-ref.lua
index 4c04e5ea7..9527cc2e8 100644
--- a/tex/context/base/node-ref.lua
+++ b/tex/context/base/node-ref.lua
@@ -314,7 +314,6 @@ local function inject_areas(head,attribute,make,stack,done,skip,parent,pardir,tx
                 -- see dimensions: this is tricky with split off boxes like inserts
                 -- where we can end up with a first and last spanning lines
 
-
                 local r = getattr(current,attribute)
                 -- test \goto{test}[page(2)] test \gotobox{test}[page(2)]
                 -- test \goto{\TeX}[page(2)] test \gotobox{\hbox {x} \hbox {x}}[page(2)]
diff --git a/tex/context/base/node-res.lua b/tex/context/base/node-res.lua
index 1a9d6f02e..43dd3895e 100644
--- a/tex/context/base/node-res.lua
+++ b/tex/context/base/node-res.lua
@@ -146,6 +146,7 @@ local user_n            = register_nut(new_nut("whatsit",whatsitcodes.userdefine
 local user_l            = register_nut(new_nut("whatsit",whatsitcodes.userdefined)) setfield(user_l,"type",110) -- 44
 local user_s            = register_nut(new_nut("whatsit",whatsitcodes.userdefined)) setfield(user_s,"type",115) -- 44
 local user_t            = register_nut(new_nut("whatsit",whatsitcodes.userdefined)) setfield(user_t,"type",116) -- 44
+----- user_c            = register_nut(new_nut("whatsit",whatsitcodes.userdefined)) setfield(user_c,"type",108) -- 44
 local left_margin_kern  = register_nut(new_nut("margin_kern",0))
 local right_margin_kern = register_nut(new_nut("margin_kern",1))
 local lineskip          = register_nut(new_nut("glue",skipcodes.lineskip))
@@ -504,6 +505,17 @@ function nutpool.usertokens(id,tokens)
     return n
 end
 
+-- function nutpool.usercode(id,code)
+--     local n = copy_nut(user_c)
+--     if code then
+--         setfield(n,"user_id",id)
+--         setfield(n,"value",code)
+--     else
+--         setfield(n,"value",id)
+--     end
+--     return n
+-- end
+
 function nutpool.special(str)
     local n = copy_nut(special)
     setfield(n,"data",str)
diff --git a/tex/context/base/node-tex.lua b/tex/context/base/node-tex.lua
index 8f4a65450..c9d3091df 100644
--- a/tex/context/base/node-tex.lua
+++ b/tex/context/base/node-tex.lua
@@ -26,12 +26,12 @@ function kernel.hyphenation(head)
 end
 
 function kernel.ligaturing(head)
-    local head, tail, done = ligaturing(head)
+    local head, tail, done = ligaturing(head) -- we return 3 values indeed
     return head, done
 end
 
 function kernel.kerning(head)
-    local head, tail, done = kerning(head)
+    local head, tail, done = kerning(head) -- we return 3 values indeed
     return head, done
 end
 
diff --git a/tex/context/base/node-tra.lua b/tex/context/base/node-tra.lua
index 5f060e4f3..4d5ae5aca 100644
--- a/tex/context/base/node-tra.lua
+++ b/tex/context/base/node-tra.lua
@@ -78,6 +78,7 @@ local localpar_code    = whatcodes.localpar
 local dir_code         = whatcodes.dir
 
 local dimenfactors     = number.dimenfactors
+local fillorders       = nodes.fillcodes
 local formatters       = string.formatters
 
 -- this will be reorganized:
@@ -358,82 +359,175 @@ local stripper = lpeg.patterns.stripzeros
 --
 -- redefined:
 
-local dimenfactors = number.dimenfactors
+-- local function nodetodimen(d,unit,fmt,strip)
+--     d = tonut(d) -- tricky: direct nuts are an issue
+--     if unit == true then
+--         unit = "pt"
+--         fmt  = "%0.5f%s"
+--     else
+--         unit = unit or 'pt'
+--         if not fmt then
+--             fmt = "%s%s"
+--         elseif fmt == true then
+--             fmt = "%0.5f%s"
+--         end
+--     end
+--     local id = getid(d)
+--     if id == kern_code then
+--         local str = formatters[fmt](getfield(d,"width")*dimenfactors[unit],unit)
+--         return strip and lpegmatch(stripper,str) or str
+--     end
+--     if id == glue_code then
+--         d = getfield(d,"spec")
+--     end
+--     if not d or not getid(d) == gluespec_code then
+--         local str = formatters[fmt](0,unit)
+--         return strip and lpegmatch(stripper,str) or str
+--     end
+--     local width   = getfield(d,"width")
+--     local plus    = getfield(d,"stretch_order")
+--     local minus   = getfield(d,"shrink_order")
+--     local stretch = getfield(d,"stretch")
+--     local shrink  = getfield(d,"shrink")
+--     if plus ~= 0 then
+--         plus = " plus " .. stretch/65536 .. fillcodes[plus]
+--     elseif stretch ~= 0 then
+--         plus = formatters[fmt](stretch*dimenfactors[unit],unit)
+--         plus = " plus " .. (strip and lpegmatch(stripper,plus) or plus)
+--     else
+--         plus = ""
+--     end
+--     if minus ~= 0 then
+--         minus = " minus " .. shrink/65536 .. fillcodes[minus]
+--     elseif shrink ~= 0 then
+--         minus = formatters[fmt](shrink*dimenfactors[unit],unit)
+--         minus = " minus " .. (strip and lpegmatch(stripper,minus) or minus)
+--     else
+--         minus = ""
+--     end
+--     local str = formatters[fmt](getfield(d,"width")*dimenfactors[unit],unit)
+--     return (strip and lpegmatch(stripper,str) or str) .. plus .. minus
+-- end
+--
+-- local function numbertodimen(d,unit,fmt,strip)
+--     if not d then
+--         local str = formatters[fmt](0,unit)
+--         return strip and lpegmatch(stripper,str) or str
+--     end
+--     local t = type(d)
+--     if t == 'string' then
+--         return d
+--     elseif t == "number" then
+--         if unit == true then
+--             unit = "pt"
+--             fmt  = "%0.5f%s"
+--         else
+--             unit = unit or 'pt'
+--             if not fmt then
+--                 fmt = "%s%s"
+--             elseif fmt == true then
+--                 fmt = "%0.5f%s"
+--             end
+--         end
+--         local str = formatters[fmt](d*dimenfactors[unit],unit)
+--         return strip and lpegmatch(stripper,str) or str
+--     else
+--         return nodetodimen(d,unit,fmt,strip) -- real node
+--     end
+-- end
 
-local function nodetodimen(d,unit,fmt,strip)
-    d = tonut(d) -- tricky: direct nuts are an issue
-    if unit == true then
-        unit = "pt"
-        fmt  = "%0.5f%s"
-    else
-        unit = unit or 'pt'
-        if not fmt then
-            fmt = "%s%s"
-        elseif fmt == true then
-            fmt = "%0.5f%s"
-        end
-    end
-    local id = getid(d)
+local f_f_f = formatters["%0.5Fpt plus %0.5F%s minus %0.5F%s"]
+local f_f_m = formatters["%0.5Fpt plus %0.5F%s minus %0.5Fpt"]
+local f_p_f = formatters["%0.5Fpt plus %0.5Fpt minus %0.5F%s"]
+local f_p_m = formatters["%0.5Fpt plus %0.5Fpt minus %0.5Fpt"]
+local f_f_z = formatters["%0.5Fpt plus %0.5F%s"]
+local f_p_z = formatters["%0.5Fpt plus %0.5Fpt"]
+local f_z_f = formatters["%0.5Fpt minus %0.5F%s"]
+local f_z_m = formatters["%0.5Fpt minus %0.5Fpt"]
+local f_z_z = formatters["%0.5Fpt"]
+
+local tonut    = nodes.tonut
+local getfield = nodes.nuts.getfield
+
+local function nodetodimen(n)
+    n = tonut(n)
+    local id = getid(n)
     if id == kern_code then
-        local str = formatters[fmt](getfield(d,"width")*dimenfactors[unit],unit)
-        return strip and lpegmatch(stripper,str) or str
+        local width = getfield(n,"width")
+        if width == 0 then
+            return "0pt"
+        else
+            return f_z_z(width)
+        end
     end
     if id == glue_code then
-        d = getfield(d,"spec")
+        n = getfield(n,"spec")
     end
-    if not d or not getid(d) == gluespec_code then
-        local str = formatters[fmt](0,unit)
-        return strip and lpegmatch(stripper,str) or str
+    if not n or not getid(n) == gluespec_code then
+        return "0pt"
     end
-    local width   = getfield(d,"width")
-    local plus    = getfield(d,"stretch_order")
-    local minus   = getfield(d,"shrink_order")
-    local stretch = getfield(d,"stretch")
-    local shrink  = getfield(d,"shrink")
-    if plus ~= 0 then
-        plus = " plus " .. stretch/65536 .. fillcodes[plus]
+    local stretch_order = getfield(n,"stretch_order")
+    local shrink_order  = getfield(n,"shrink_order")
+    local stretch       = getfield(n,"stretch") / 65536
+    local shrink        = getfield(n,"shrink")  / 65536
+    local width         = getfield(n,"width")   / 65536
+    if stretch_order ~= 0 then
+        if shrink_order ~= 0 then
+            return f_f_f(width,stretch,fillorders[stretch_order],shrink,fillorders[shrink_order])
+        elseif shrink ~= 0 then
+            return f_f_m(width,stretch,fillorders[stretch_order],shrink)
+        else
+            return f_f_z(width,stretch,fillorders[stretch_order])
+        end
+    elseif shrink_order ~= 0 then
+        if stretch ~= 0 then
+            return f_p_f(width,stretch,shrink,fillorders[shrink_order])
+        else
+            return f_z_f(width,shrink,fillorders[shrink_order])
+        end
     elseif stretch ~= 0 then
-        plus = formatters[fmt](stretch*dimenfactors[unit],unit)
-        plus = " plus " .. (strip and lpegmatch(stripper,plus) or plus)
-    else
-        plus = ""
-    end
-    if minus ~= 0 then
-        minus = " minus " .. shrink/65536 .. fillcodes[minus]
+        if shrink ~= 0 then
+            return f_p_m(width,stretch,shrink)
+        else
+            return f_p_z(width,stretch)
+        end
     elseif shrink ~= 0 then
-        minus = formatters[fmt](shrink*dimenfactors[unit],unit)
-        minus = " minus " .. (strip and lpegmatch(stripper,minus) or minus)
+        return f_z_m(width,shrink)
+    elseif width == 0 then
+        return "0pt"
     else
-        minus = ""
+        return f_z_z(width)
     end
-    local str = formatters[fmt](getfield(d,"width")*dimenfactors[unit],unit)
-    return (strip and lpegmatch(stripper,str) or str) .. plus .. minus
 end
 
-local function numbertodimen(d,unit,fmt,strip)
-    if not d then
-        local str = formatters[fmt](0,unit)
-        return strip and lpegmatch(stripper,str) or str
-    end
-    local t = type(d)
-    if t == 'string' then
-        return d
-    elseif t == "number" then
-        if unit == true then
-            unit = "pt"
-            fmt  = "%0.5f%s"
+
+-- number.todimen(123)
+-- number.todimen(123,"cm")
+-- number.todimen(123,false,"%F))
+
+local f_pt = formatters["%p"]
+local f_un = formatters["%F%s"]
+
+dimenfactors[""] = dimenfactors.pt
+
+local function numbertodimen(d,unit,fmt)
+    if not d or d == 0 then
+        if not unit or unit == "pt" then
+            return "0pt"
+        elseif fmt then
+            return formatters[fmt](0,unit)
         else
-            unit = unit or 'pt'
-            if not fmt then
-                fmt = "%s%s"
-            elseif fmt == true then
-                fmt = "%0.5f%s"
-            end
+            return 0 .. unit
+        end
+    elseif fmt then
+        if not unit then
+            unit = "pt"
         end
-        local str = formatters[fmt](d*dimenfactors[unit],unit)
-        return strip and lpegmatch(stripper,str) or str
+        return formatters[fmt](d*dimenfactors[unit],unit)
+    elseif not unit or unit == "pt" then
+        return f_pt(d)
     else
-        return nodetodimen(d,unit,fmt,strip) -- real node
+        return f_un(d*dimenfactors[unit],unit)
     end
 end
 
diff --git a/tex/context/base/pack-lyr.mkiv b/tex/context/base/pack-lyr.mkiv
index a891c998d..e7954931c 100644
--- a/tex/context/base/pack-lyr.mkiv
+++ b/tex/context/base/pack-lyr.mkiv
@@ -101,9 +101,6 @@
 
 \def\layeranchor{\currentlayer:\the\realpageno}
 
-\unexpanded\def\anch_mark_anchor_box#1%
-  {\ctxcommand{markregionbox(\number#1,"\layeranchor")}} % needs an hbox
-
 \let\p_pack_layers_doublesided\empty
 \let\p_pack_layers_state      \empty
 \let\p_pack_layers_option     \empty
@@ -687,7 +684,7 @@
    \ifx\p_pack_layers_position\v!yes
      \edef\p_pack_layers_region{\layerparameter\c!region}%
      \ifx\p_pack_layers_region\empty \else
-       \anch_mark_anchor_box\nextbox
+       \anch_mark_tagged_box\nextbox\layeranchor
      \fi
    \fi
    \box\nextbox
diff --git a/tex/context/base/page-ini.mkiv b/tex/context/base/page-ini.mkiv
index fdffa552d..08fc6b33a 100644
--- a/tex/context/base/page-ini.mkiv
+++ b/tex/context/base/page-ini.mkiv
@@ -143,9 +143,15 @@
 
 \newconstant\pageornamentstate % 0=on 1=one-off 2=always-off
 
+% \appendtoks
+%     \ifcase\pageornamentstate \or
+%         \pageornamentstate\zerocount
+%     \fi
+% \to \everyaftershipout
+
 \appendtoks
     \ifcase\pageornamentstate \or
-        \pageornamentstate\zerocount
+        \global\pageornamentstate\zerocount
     \fi
 \to \everyaftershipout
 
diff --git a/tex/context/base/page-lay.mkiv b/tex/context/base/page-lay.mkiv
index 716967f27..fc864719b 100644
--- a/tex/context/base/page-lay.mkiv
+++ b/tex/context/base/page-lay.mkiv
@@ -1,4 +1,4 @@
-    %D \module
+%D \module
 %D   [       file=page-lay,
 %D        version=2000.10.20, % copied from main-001
 %D          title=\CONTEXT\ Page Macros,
@@ -1377,6 +1377,9 @@
 \definepapersize [A9]  [\c!width=37mm,\c!height=52mm]
 \definepapersize [A10] [\c!width=26mm,\c!height=37mm]
 
+\definepapersize [A4/2][\c!width=\dimexpr297mm/2\relax,\c!height=210mm] % 148.5mm
+%definepapersize [2A5] [\c!width=296mm,\c!height=210mm] % doublewide
+
 \definepapersize [B0]  [\c!width=1000mm,\c!height=1414mm]
 \definepapersize [B1]  [\c!width=707mm,\c!height=1000mm]
 \definepapersize [B2]  [\c!width=500mm,\c!height=707mm]
@@ -1534,6 +1537,11 @@
   [ \c!width=\dimexpr \paperheight+\layouttargetparameter\c!distance\relax,
    \c!height=\dimexpr2\paperwidth +\layouttargetparameter\c!distance\relax]
 
+\definepapersize
+  [doublewide]
+  [ \c!width=\dimexpr2\paperwidth \relax,
+   \c!height=\dimexpr \paperheight\relax]
+
 % \setuppapersize
 %   [A4][A4]
 
diff --git a/tex/context/base/page-mak.mkvi b/tex/context/base/page-mak.mkvi
index c910f281d..9b596b9e5 100644
--- a/tex/context/base/page-mak.mkvi
+++ b/tex/context/base/page-mak.mkvi
@@ -126,8 +126,7 @@
      % nothing
      \endgroup
    \else
-     \endgroup
-     \page[\p_page]%
+     \normalexpanded{\endgroup\page[\p_page]}%
    \fi\fi
    % some dirty trickery (sorry) for determining if we have
    %  - a layout definition at all
diff --git a/tex/context/base/page-run.mkiv b/tex/context/base/page-run.mkiv
index 1f2551ebc..7affedcbe 100644
--- a/tex/context/base/page-run.mkiv
+++ b/tex/context/base/page-run.mkiv
@@ -74,9 +74,11 @@
 
 \startluacode
 local format, concat = string.format, table.concat
+local todimen = number.todimen
+local texdimen = tex.dimen
 
-local function todimen(name,unit,fmt)
-    return number.todimen(tex.dimen[name],unit,fmt)
+local function asdimen(name,unit)
+    return todimen(texdimen[name],unit,"%0.4f") -- 4 is more than enough, even 3 would be okay
 end
 
 local function checkedoptions(options)
@@ -122,7 +124,7 @@ function commands.showlayoutvariables(options)
         for i=1,#dimensions do
             local d = dimensions[i]
             if options[d] then
-                context("%s%s",todimen(name,d,"%0.4f"),d)
+                context("%s%s",asdimen(name,d),d)
                 context.NC()
             end
         end
@@ -143,7 +145,7 @@ function commands.showlayoutvariables(options)
         for i=1,#dimensions do
             local d = dimensions[i]
             if options[d] then
-                result[#result+1] = format("%12s%s",todimen(name,d,"%0.4f"),d)
+                result[#result+1] = format("%12s%s",asdimen(name,d),d)
             end
         end
         commands.writestatus("layout",format("%-24s %s",interfaces.interfacedcommand(name),concat(result," ")))
diff --git a/tex/context/base/publ-aut.lua b/tex/context/base/publ-aut.lua
index 764550998..f91ba0039 100644
--- a/tex/context/base/publ-aut.lua
+++ b/tex/context/base/publ-aut.lua
@@ -56,7 +56,7 @@ local period         = P(".")
 local dash           = P("-")
 local firstcharacter = lpegpatterns.utf8byte
 local utf8character  = lpegpatterns.utf8character
-local p_and          = space^1 * "and" * space^1
+local p_and          = space^1 * (P("and") + P("&&") + P("++")) * space^1
 local p_comma        = space^0 * comma * space^0
 local p_space        = space^1
 local p_shortone     = C((utf8character      -dash-period)^1)
@@ -93,10 +93,14 @@ local function is_upper(str)
     return okay and okay.category == "lu"
 end
 
+-- local cleaner = Cs( ( P("{}")/"" + P(1) )^1 )
+
 local cache   = { } -- 33% reuse on tugboat.bib
 local nofhits = 0
 local nofused = 0
 
+publications.authorcache = cache
+
 local function makeinitials(firstnames)
     if firstnames and #firstnames > 0 then
         local initials = { }
@@ -108,7 +112,9 @@ local function makeinitials(firstnames)
 end
 
 local function splitauthorstring(str)
-    if not str then
+    if str then
+     -- str = lpegmatch(cleaner,str)
+    else
         return
     end
     nofused = nofused + 1
diff --git a/tex/context/base/publ-dat.lua b/tex/context/base/publ-dat.lua
index bfb38645b..be5f1eca8 100644
--- a/tex/context/base/publ-dat.lua
+++ b/tex/context/base/publ-dat.lua
@@ -33,7 +33,7 @@ local lpegmatch, lpegpatterns = lpeg.match, lpeg.patterns
 local textoutf = characters and characters.tex.toutf
 local settings_to_hash, settings_to_array = utilities.parsers.settings_to_hash, utilities.parsers.settings_to_array
 local formatters = string.formatters
-local sortedkeys, sortedhash = table.sortedkeys, table.sortedhash
+local sortedkeys, sortedhash, keys = table.sortedkeys, table.sortedhash, table.keys
 local xmlcollected, xmltext, xmlconvert = xml.collected, xml.text, xml.convert
 local setmetatableindex = table.setmetatableindex
 
@@ -42,6 +42,7 @@ local setmetatableindex = table.setmetatableindex
 local P, R, S, V, C, Cc, Cs, Ct, Carg, Cmt, Cp = lpeg.P, lpeg.R, lpeg.S, lpeg.V, lpeg.C, lpeg.Cc, lpeg.Cs, lpeg.Ct, lpeg.Carg, lpeg.Cmt, lpeg.Cp
 
 local p_whitespace      = lpegpatterns.whitespace
+local p_utf8character   = lpegpatterns.utf8character
 
 local trace             = false  trackers.register("publications",            function(v) trace = v end)
 local trace_duplicates  = true   trackers.register("publications.duplicates", function(v) trace = v end)
@@ -145,17 +146,22 @@ local defaulttypes = allocate {
     url       = "url",
 }
 
+local defaultsets = allocate {
+    page = { "page", "pages" },
+}
+
 tables.implicits = implicits
 tables.origins   = origins
 tables.virtuals  = virtuals
 tables.types     = defaulttypes
+tables.sets      = defaultsets
 tables.privates  = privates
 tables.specials  = specials
 
 local variables  = interfaces and interfaces.variables or setmetatableindex("self")
 
 local v_all      = variables.all
-local v_standard = variables.standard
+local v_default  = variables.default
 
 if not publications.usedentries then
     function publications.usedentries()
@@ -196,8 +202,9 @@ local unknowncategory = function(t,k)
         required = false,
         optional = false,
         virtual  = false,
-        fields   = setmetatableindex(unknownfield),
-        types    = defaulttypes,
+        fields   = setmetatableindex(unknownfield), -- this will remember them
+        types    = unknowntypes,
+        sets     = setmetatableindex(defaultsets),  -- new, but rather small
     }
     t[k] = v
     return v
@@ -219,7 +226,7 @@ local default = {
     types      = setmetatableindex(defaulttypes,unknowntype),
 }
 
--- maybe at some point we can han da handlers table with per field
+-- maybe at some point we can have a handlers table with per field
 -- a found, fetch, ... method
 
 local function checkfield(specification,category,data)
@@ -279,10 +286,10 @@ local specifications = setmetatableindex(function(t,name)
     end
     setmetatableindex(types,unknowntype)
     --
-    local fields         = setmetatableindex(unknownfield)
+    local fields = setmetatableindex(unknownfield)
     specification.fields = fields
     --
-    local virtual         = specification.virtual
+    local virtual = specification.virtual
     if virtual == nil then -- so false is valid
         virtual = virtuals
         specification.virtual = virtual
@@ -405,7 +412,10 @@ do
 
     ----- command   = P("\\") * Cc("btxcmd{") * (R("az","AZ")^1) * Cc("}")
     ----- command   = P("\\") * (Carg(1) * C(R("az","AZ")^1) / function(list,c) list[c] = (list[c] or 0) + 1 return "btxcmd{" .. c .. "}" end)
+    ----- command   = P("\\") * (Carg(1) * C(R("az","AZ")^1) * space^0 / function(list,c) list[c] = (list[c] or 0) + 1 return "btxcmd{" .. c .. "}" end)
     local command   = P("\\") * (Carg(1) * C(R("az","AZ")^1) * space^0 / function(list,c) list[c] = (list[c] or 0) + 1 return "btxcmd{" .. c .. "}" end)
+    local whatever  = P("\\") * P(" ")^1 / " "
+                    + P("\\") * ( P("hbox") + P("raise") ) -- bah
     local somemath  = P("$") * ((1-P("$"))^1) * P("$") -- let's not assume nested math
     ----- character = lpegpatterns.utf8character
     local any       = P(1)
@@ -414,15 +424,24 @@ do
     local one_r     = P("}")  / ""
     local two_l     = P("{{") / ""
     local two_r     = P("}}") / ""
-    local special   = P("#")  / "\\letterhash"
+    local zero_l_r  = P("{}") / "" * #P(1)
+    local special   = P("#")  / "\\letterhash "
 
-    local filter_0  = S('\\{}')
+    local filter_0  = S('\\{}#')
     local filter_1  = (1-filter_0)^0 * filter_0
     local filter_2  = Cs(
     -- {{...}} ... {{...}}
     --     two_l * (command + special + any - two_r - done)^0 * two_r * done +
     --     one_l * (command + special + any - one_r - done)^0 * one_r * done +
-                (somemath + command + special + collapsed + any)^0
+                (
+                    somemath +
+                    whatever +
+                    command +
+                    special +
+                    collapsed +
+                    zero_l_r +
+                    any
+                )^0
     )
 
     -- Currently we expand shortcuts and for large ones (like the acknowledgements
@@ -443,57 +462,57 @@ do
         publicationsstats.nofdefinitions = publicationsstats.nofdefinitions + 1
         local fields  = dataset.fields
         local luadata = dataset.luadata
+        local hashtag = tag
         if luadata[tag] then
             local t = tags[tag]
             local d = dataset.name
             local n = (t[n] or 0) + 1
             t[d] = n
+            hashtag = tag .. "-" .. n
             if trace_duplicates then
                 local p = { }
                 for k, v in sortedhash(t) do
                     p[#p+1] = formatters["%s:%s"](k,v)
                 end
-                report_duplicates("tag %a is present multiple times: % t",tag,p)
+                report_duplicates("tag %a is present multiple times: % t, assigning hashtag %a",tag,p,hashtag)
             end
-        else
-            local found   = luadata[tag]
-            local index   = getindex(dataset,luadata,tag)
-            local entries = {
-                category = lower(category),
-                tag      = tag,
-                index    = index,
-            }
-            for i=1,#tab,2 do
-                local original   = tab[i]
-                local normalized = fields[original]
-                if not normalized then
-                    normalized = lower(original) -- we assume ascii fields
-                    fields[original] = normalized
+        end
+        local index  = getindex(dataset,luadata,hashtag)
+        local entries = {
+            category = lower(category),
+            tag      = tag,
+            index    = index,
+        }
+        for i=1,#tab,2 do
+            local original   = tab[i]
+            local normalized = fields[original]
+            if not normalized then
+                normalized = lower(original) -- we assume ascii fields
+                fields[original] = normalized
+            end
+         -- if entries[normalized] then
+            if rawget(entries,normalized) then
+                if trace_duplicates then
+                    report_duplicates("redundant field %a is ignored for tag %a in dataset %a",normalized,tag,dataset.name)
                 end
-             -- if entries[normalized] then
-                if rawget(entries,normalized) then
-                    if trace_duplicates then
-                        report_duplicates("redundant field %a is ignored for tag %a in dataset %a",normalized,tag,dataset.name)
-                    end
-                else
-                    local value = tab[i+1]
-                    value = textoutf(value)
-                    if lpegmatch(filter_1,value) then
-                        value = lpegmatch(filter_2,value,1,dataset.commands) -- we need to start at 1 for { }
-                    end
-                    if normalized == "crossref" then
-                        local parent = luadata[value]
-                        if parent then
-                            setmetatableindex(entries,parent)
-                        else
-                            -- warning
-                        end
+            else
+                local value = tab[i+1]
+                value = textoutf(value)
+                if lpegmatch(filter_1,value) then
+                    value = lpegmatch(filter_2,value,1,dataset.commands) -- we need to start at 1 for { }
+                end
+                if normalized == "crossref" then
+                    local parent = luadata[value]
+                    if parent then
+                        setmetatableindex(entries,parent)
+                    else
+                        -- warning
                     end
-                    entries[normalized] = value
                 end
+                entries[normalized] = value
             end
-            luadata[tag] = entries
         end
+        luadata[hashtag] = entries
     end
 
     local function resolve(s,dataset)
@@ -534,17 +553,17 @@ do
     local collapsed  = p_whitespace^1/" "
     local nospaces   = p_whitespace^1/""
 
-    local p_left     = (p_whitespace^0 * left  * p_whitespace^0) / ""
-    local p_right    = (p_whitespace^0 * right * p_whitespace^0) / ""
+    local p_left     = (p_whitespace^0 * left) / ""
+    local p_right    = (right * p_whitespace^0) / ""
 
     local balanced   = P {
-        [1] = ((escape * (left+right)) + collapsed + (1 - (left+right))^1 + V(2))^0,
+        [1] = ((escape * (left+right)) + (collapsed + 1 - (left+right))^1 + V(2))^0,
         [2] = left * V(1) * right,
     }
 
     local unbalanced = P {
         [1] = left * V(2) * right,
-        [2] = ((escape * (left+right)) + collapsed + (1 - (left+right))^1 + V(1))^0,
+        [2] = ((escape * (left+right)) + (collapsed + 1 - (left+right))^1 + V(1))^0,
     }
 
     local keyword    = C((R("az","AZ","09") + S("@_:-"))^1)
@@ -555,20 +574,7 @@ do
     local s_quoted   = ((escape*single) + collapsed + (1-single))^0
     local d_quoted   = ((escape*double) + collapsed + (1-double))^0
 
- -- local p_strip    = C((1-(p_whitespace * P(-1)))^1)
- --
- -- local function stripendspace(s)
- --     return lpegmatch(p_strip,s) or s
- -- end
-
-    local p_strip    = (Cp() * p_whitespace^1 * P(-1) + 1)^1
-
-    local function stripendspace(s)
-        local p = lpegmatch(p_strip,s)
-        return p and sub(s,1,p-1) or s
-    end
-
-    local b_value    = p_left * (Cs(balanced)/stripendspace) * p_right
+    local b_value    = p_left * balanced * p_right
     local u_value    = p_left * unbalanced * p_right -- get rid of outer { }
     local s_value    = (single/"") * (u_value + s_quoted) * (single/"")
     local d_value    = (double/"") * (u_value + d_quoted) * (double/"")
@@ -577,6 +583,8 @@ do
     local somevalue  = d_value + b_value + s_value + r_value
     local value      = Cs((somevalue * ((spacing * hash * spacing)/"" * somevalue)^0))
 
+    value = value / function(s) return lpegmatch(lpegpatterns.stripper,s) end
+
     local forget     = percent^1 * (1-lineending)^0
     local spacing    = spacing * forget^0 * spacing
     local assignment = spacing * key * spacing * equal * spacing * value * spacing
@@ -618,14 +626,7 @@ do
             current.loaded[source] = kind or true
         end
         current.newtags = #current.luadata > 0 and { } or current.newtags
-        local before = #current.luadata
         lpegmatch(bibtotable,content or "",1,current)
-        local after = #current.luadata
-        if before == after then
-            report("no entries added")
-        else
-            report("%s entries added",after-before)
-        end
         statistics.stoptiming(publications)
     end
 
@@ -751,6 +752,36 @@ do
 
     publications.resolvedname = resolvedname
 
+    local cleaner = false
+    local cleaned = false
+
+    function loaders.registercleaner(what,fullname)
+        if not fullname or fullname == "" then
+            report("no %s file %a",what,fullname)
+            return
+        end
+        local list = table.load(fullname)
+        if not list then
+            report("invalid %s file %a",what,fullname)
+            return
+        end
+        list = list.replacements
+        if not list then
+            report("no replacement table in %a",fullname)
+            return
+        end
+        if cleaned then
+            report("adding replacements from %a",fullname)
+            for k, v in next, list do
+                cleaned[k] = v
+            end
+        else
+            report("using replacements from %a",fullname)
+            cleaned = list
+        end
+        cleaner = true
+    end
+
     function loaders.bib(dataset,filename,kind)
         local dataset, fullname = resolvedname(dataset,filename)
         if not fullname then
@@ -761,6 +792,12 @@ do
             report("empty file %a, nothing loaded",fullname)
             return
         end
+        if cleaner == true then
+            cleaner = Cs((lpeg.utfchartabletopattern(keys(cleaned)) / cleaned + p_utf8character)^1)
+        end
+        if cleaner ~= false then
+            data = lpegmatch(cleaner,data)
+        end
         if trace then
             report("loading file %a",fullname)
         end
@@ -840,7 +877,7 @@ do
     end)
 
     function publications.load(specification)
-        local current  = datasets[specification.dataset or v_standard]
+        local current  = datasets[specification.dataset or v_default]
         local files    = settings_to_array(specification.filename)
         local kind     = specification.kind
         local dataspec = specification.specification
@@ -931,6 +968,14 @@ do
 
 end
 
+function publications.tags(dataset)
+    return sortedkeys(datasets[dataset].luadata)
+end
+
+function publications.sortedentries(dataset)
+    return sortedhash(datasets[dataset].luadata)
+end
+
 -- a helper:
 
 function publications.concatstate(i,n)
@@ -954,17 +999,17 @@ do
     local savers = { }
 
     local s_preamble = [[
-    % this is an export from context mkiv
-
-    @preamble{
-        \ifdefined\btxcmd
-            % we're probably in context
-        \else
-            \def\btxcmd#1{\csname#1\endcsname}
-        \fi
-    }
+% this is an export from context mkiv
+
+@preamble{
+    \ifdefined\btxcmd
+        % we're probably in context
+    \else
+        \def\btxcmd#1{\csname#1\endcsname}
+    \fi
+}
 
-    ]]
+]]
 
     function savers.bib(dataset,filename,usedonly)
         local current  = datasets[dataset]
@@ -1074,12 +1119,12 @@ do
 
     local pagessplitter = lpeg.splitat(P("-")^1)
 
-    casters.pagenumber = function(str)
+    casters.range = function(str)
         local first, last = lpegmatch(pagessplitter,str)
         return first and last and { first, last } or str
     end
 
-    writers.pagenumber = function(p)
+    writers.range = function(p)
         if type(p) == "table" then
             return concat(p,"-")
         else
@@ -1087,4 +1132,7 @@ do
         end
     end
 
+    casters.pagenumber = casters.range
+    writers.pagenumber = writers.range
+
 end
diff --git a/tex/context/base/publ-fnd.lua b/tex/context/base/publ-fnd.lua
index 780ce039e..2457709ff 100644
--- a/tex/context/base/publ-fnd.lua
+++ b/tex/context/base/publ-fnd.lua
@@ -19,12 +19,15 @@ local publications = publications
 
 local tonumber, next, type = tonumber, next, type
 local find = string.find
-local P, R, C, Cs, Cp, Cc, Carg = lpeg.P, lpeg.R, lpeg.C, lpeg.Cs, lpeg.Cp, lpeg.Cc, lpeg.Carg
+local P, R, S, C, Cs, Cp, Cc, Carg, V = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cs, lpeg.Cp, lpeg.Cc, lpeg.Carg, lpeg.V
 local lpegmatch, lpegpatterns = lpeg.match, lpeg.patterns
 local concat = table.concat
 
 local formatters = string.formatters
 local lowercase  = characters.lower
+local topattern  = string.topattern
+
+publications = publications or { } -- for testing
 
 local report     = logs.reporter("publications","match")
 
@@ -42,68 +45,182 @@ local word     = Cs(lpegpatterns.unquoted + lpegpatterns.argument + valid^1)
 local simple   = C(valid^1)
 local number   = C(valid^1)
 
------ f_string_key = formatters["  local s_%s = entry[%q]"]
-local f_string_key = formatters["  local s_%s = entry[%q] if s_%s then s_%s = lower(s_%s) end "]
-local f_number_key = formatters["  local n_%s = tonumber(entry[%q]) or 0"]
-local f_field_key  = formatters["  local f_%s = entry[%q] or ''"]
+----- f_string_key = formatters["  local s_%s = entry[%q] if s_%s then s_%s = lower(s_%s) end "]
+----- f_number_key = formatters["  local n_%s = tonumber(entry[%q]) or 0"]
+----- f_field_key  = formatters["  local f_%s = entry[%q] or ''"]
 
------ f_string_match = formatters["(s_%s and find(lower(s_%s),%q))"]
-local f_string_match = formatters["(s_%s and find(s_%s,%q))"]
-local f_number_match = formatters["(n_%s and n_%s >= %s and n_%s <= %s)"]
-local f_field_match  = formatters["f_%s"]
+-- getfuzzy(entry,%q,categories)
 
-local f_all_match = formatters["anywhere(entry,%q)"]
+-- local f_string_key    = formatters["  local s_%s = get(entry,%q)\n  if s_%s then s_%s = lower(s_%s) end"]
+-- local f_field_key     = formatters["  local f_%s = get(entry,%q) or ''"]
+-- local f_field_key_c   = formatters["  local c_%s = get(entry,%q,categories) or ''"]
+-- local f_number_key    = formatters["  local n_%s = tonumber(get(entry,%q)) or 0"]
+--
+-- local f_string_match  = formatters["(s_%s and find(s_%s,%q))"]
+-- local f_number_match  = formatters["(n_%s and n_%s >= %s and n_%s <= %s)"]
+-- local f_field_match   = formatters["f_%s"]
+-- local f_field_match_c = formatters["c_%s"]
+--
+-- local f_all_match     = formatters["anywhere(entry,%q)"]
+
+-- topattern(lowercase(word)) : utflowercase + only *?
+
+-- local match = ( (key + wildcard) * (colon/"") ) * word * Carg(1) / function(key,_,word,keys)
+--     if key == "*" or key == "any" then
+--         keys.anywhere = true
+--         if word == "" or word == "*" then
+--             return "true"
+--         else
+--             return f_all_match(topattern(lowercase(word)))
+--         end
+--     else
+--         keys[key] = f_string_key(key,key,key,key,key)
+--         return f_string_match(key,key,topattern(lowercase(word)))
+--     end
+-- end
+--
+-- local default = simple * Carg(1) / function(word,keys)
+--     keys.anywhere = true
+--     if word == "" or word == "*" then
+--         return "true"
+--     else
+--         return f_all_match(topattern(lowercase(word)))
+--     end
+-- end
+--
+-- local range  = key * (colon/"") * number * (dash/"") * number * Carg(1) / function(key,_,first,_,last,keys)
+--     keys[key] = f_number_key(key,key)
+--     return f_number_match(key,key,tonumber(first) or 0,key,tonumber(last) or 0)
+-- end
+--
+-- local field  = (P("field:")/"") * key * Carg(1) / function(_,key,keys)
+--     keys[key] = f_field_key(key,key)
+--     return f_field_match(key)
+-- end
+--
+-- local cast  = (P("cast:")/"") * key * Carg(1) / function(_,key,keys)
+--     keys[key] = f_field_key_c(key,key)
+--     return f_field_match_c(key)
+-- end
+--
+-- local compare = C("==") + P("=")/"==" + P("!=")/"~=" + P("<>")/"~="
+--
+-- local b_match = lparent
+-- local e_match = rparent * space^0 * (#P(-1) + P(",")/" or ") -- maybe also + -> and
+-- local f_match = ((field + cast + range + match + space + compare + P(1))-e_match)^1
+-- local p_match = b_match * default * e_match
+--               + b_match * f_match * e_match
+--
+-- local pattern = Cs(Cc("(") * (P("match")/"" * space^0 * p_match)^1 * Cc(")"))
 
-local match  = ( (key + wildcard) * (colon/"") ) * word * Carg(1) / function(key,_,word,keys)
-    if key == "*" or key == "any" then
-        keys.anywhere = true
-        return f_all_match(lowercase(word))
+-- field contains   fieldname:nonspaces|"whatever"|'whatever'|{whatever}
+-- field exact      fieldname=nonspaces|"whatever"|'whatever'|{whatever}
+-- set   contains   [fieldname]:nonspaces|"whatever"|'whatever'|{whatever}
+-- set   exact      [fieldname]=nonspaces|"whatever"|'whatever'|{whatever}
+--
+-- with * : any sequence
+--      ? : one character
+--
+-- and match(),match() ... equivalent to () and ()
+--
+-- <123 444> : range
+--
+-- unquoted = field
+-- [..]     = set
+--
+-- () and or not
+--
+-- spaces are mandate (at least for now)
+
+local key      = C(R("az","AZ")^1)
+local contains = S(":~")
+local exact    = P("=")
+local valid    = (1 - space - lparent -rparent)^1
+local wildcard = P("*") / ".*"
+local single   = P("?") / "."
+local dash     = P("-") / "%."
+local percent  = P("-") / "%%"
+local word     = Cs(lpegpatterns.unquoted + lpegpatterns.argument + valid)
+local range    = P("<") * space^0 * C((1-space)^1) * space^1 * C((1-space- P(">"))^1) * space^0 * P(">")
+
+local f_key_fld     = formatters["  local kf_%s = get(entry,%q)           \n  if kf_%s then kf_%s = lower(kf_%s) end"]
+local f_key_set     = formatters["  local ks_%s = get(entry,%q,categories)\n  if ks_%s then ks_%s = lower(ks_%s) end"]
+local f_number_fld  = formatters["  local nf_%s = tonumber(get(entry,%q))"]
+local f_number_set  = formatters["  local ns_%s = tonumber(get(entry,%q,categories))"]
+
+local f_fld_exact    = formatters["(kf_%s == %q)"]
+local f_set_exact    = formatters["(ks_%s == %q)"]
+local f_fld_contains = formatters["(kf_%s and find(kf_%s,%q))"]
+local f_set_contains = formatters["(ks_%s and find(ks_%s,%q))"]
+local f_fld_between  = formatters["(nf_%s and nf_%s >= %s and nf_%s <= %s)"]
+local f_set_between  = formatters["(ns_%s and ns_%s >= %s and ns_%s <= %s)"]
+
+local f_all_match    = formatters["anywhere(entry,%q)"]
+
+local function test_key_value(keys,where,key,first,last)
+    if not key or key == "" then
+        return "(false)"
+    elseif key == "*" then
+        last = "^.*" .. topattern(lowercase(last)) .. ".*$"
+        return f_all_match(last)
+    elseif first == false then
+        -- exact
+        last = lowercase(last)
+        if where == "set" then
+            keys[key] = f_key_set(key,key,key,key,key)
+            return f_set_exact(key,last)
+        else
+            keys[key] = f_key_fld(key,key,key,key,key)
+            return f_fld_exact(key,last)
+        end
+    elseif first == true then
+        -- contains
+        last = "^.*" .. topattern(lowercase(last)) .. ".*$"
+        if where == "set" then
+            keys[key] = f_key_set(key,key,key,key,key)
+            return f_set_contains(key,key,last)
+        else
+            keys[key] = f_key_fld(key,key,key,key,key)
+            return f_fld_contains(key,key,last)
+        end
     else
-        keys[key] = f_string_key(key,key,key,key,key)
-        return f_string_match(key,key,lowercase(word))
+        -- range
+        if where == "set" then
+            keys[key] = f_number_set(key,key)
+            return f_set_between(key,key,tonumber(first),key,tonumber(last))
+        else
+            keys[key] = f_number_fld(key,key)
+            return f_fld_between(key,key,tonumber(first),key,tonumber(last))
+        end
     end
 end
 
-local default = simple * Carg(1) / function(word,keys)
-    keys.anywhere = true
-    return f_all_match(lowercase(word))
-end
-
-local range  = key * (colon/"") * number * (dash/"") * number * Carg(1)  / function(key,_,first,_,last,keys)
-    keys[key] = f_number_key(key,key)
-    return f_number_match(key,key,tonumber(first) or 0,key,tonumber(last) or 0)
-end
-
-local field  = (P("field:")/"") * key * Carg(1) / function(_,key,keys)
-    keys[key] = f_field_key(key,key)
-    return f_field_match(key)
-end
-
------ b_match = lparent
------ e_match = rparent * space^0 * P(-1)
------ pattern = Cs(b_match * ((field + range + match + space + P(1))-e_match)^1 * e_match)
+local p_compare = P { "all",
+    all      = (V("one") + V("operator") + V("nested") + C(" "))^1,
+    nested   = C("(") * V("all") * C(")"),
+    operator = C("and")
+             + C("or")
+             + C("not"),
+    one      = Carg(1)
+             * V("where")
+             * V("key")
+             * (V("how") * V("word") + V("range"))
+             / test_key_value,
+    key      = key
+             + C("*"),
+    where    = C("set") * P(":")
+             + Cc(""),
+    how      = contains * Cc(true)
+             + exact * Cc(false),
+    word     = word,
+    range    = range,
+}
 
-local b_match = lparent
-local e_match = rparent * space^0 * (#P(-1) + P(",")/" or ") -- maybe also + -> and
-local f_match = ((field + range + match + space + P(1))-e_match)^1
-local p_match = b_match * default * e_match +
-b_match * f_match * e_match
+local p_combine = space^0
+                * (P(",")/" or ")
+                * space^0
 
-local pattern = Cs(Cc("(") * (P("match")/"" * space^0 * p_match)^1 * Cc(")"))
-
--- -- -- -- -- -- -- -- -- -- -- -- --
--- -- -- -- -- -- -- -- -- -- -- -- --
-
--- no longer faster
---
--- local tolower  = lpegpatterns.tolower
--- local lower    = string.lower
---
--- local allascii = R("\000\127")^1 * P(-1)
---
--- function characters.checkedlower(str)
---     return lpegmatch(allascii,str) and lower(str) or lpegmatch(tolower,str) or str
--- end
+local pattern = Cs((P("match")/"" * space^0 * p_compare + p_combine)^1)
 
 -- -- -- -- -- -- -- -- -- -- -- -- --
 -- -- -- -- -- -- -- -- -- -- -- -- --
@@ -120,6 +237,9 @@ local f_template = string.formatters[ [[
 local find = string.find
 local lower = characters.lower
 local anywhere = publications.anywhere
+local get = publications.getfuzzy
+local specification = publications.currentspecification
+local categories = specification and specification.categories
 return function(entry)
 %s
   return %s and true or false
@@ -127,7 +247,46 @@ end
 ]] ]
 
 ----- function compile(expr,start)
-local function compile(expr)
+-- local function compile(dataset,expr)
+--     local keys        = { }
+--  -- local expression  = lpegmatch(pattern,expr,start,keys)
+--     local expression  = lpegmatch(pattern,expr,1,keys)
+--     if trace_match then
+--         report("compiling expression: %s",expr)
+--     end
+--     local definitions = { }
+--     local anywhere    = false
+--     for k, v in next, keys do
+--         if k == "anywhere" then
+--             anywhere = true
+--         else
+--             definitions[#definitions+1] = v
+--         end
+--     end
+--     if not anywhere or #definitions == 0 then
+--         report("invalid expression: %s",expr)
+--     elseif trace_match then
+--         for i=1,#definitions do
+--             report("% 3i : %s",i,definitions[i])
+--         end
+--     end
+--     definitions = concat(definitions,"\n")
+--     local code = f_template(definitions,expression)
+--     if trace_match then
+--         report("generated code: %s",code)
+--     end
+--     code = loadstring(code)
+--     if type(code) == "function" then
+--         code = code()
+--         if type(code) == "function" then
+--             return code
+--         end
+--     end
+--     report("invalid expression: %s",expr)
+--     return false
+-- end
+
+local function compile(dataset,expr)
     local keys        = { }
  -- local expression  = lpegmatch(pattern,expr,start,keys)
     local expression  = lpegmatch(pattern,expr,1,keys)
@@ -135,15 +294,10 @@ local function compile(expr)
         report("compiling expression: %s",expr)
     end
     local definitions = { }
-    local anywhere    = false
     for k, v in next, keys do
-        if k == "anywhere" then
-            anywhere = true
-        else
-            definitions[#definitions+1] = v
-        end
+        definitions[#definitions+1] = v
     end
-    if not anywhere and #definitions == 0 then
+    if #definitions == 0 then
         report("invalid expression: %s",expr)
     elseif trace_match then
         for i=1,#definitions do
@@ -166,30 +320,40 @@ local function compile(expr)
     return false
 end
 
--- print(lpegmatch(pattern,"match ( author:cleveland and year:1993 ) "),1,{})
-
--- compile([[match(key:"foo bar")]])
--- compile([[match(key:'foo bar')]])
--- compile([[match(key:{foo bar})]])
+-- local function test(str)
+--     local keys        = { }
+--     local definitions = { }
+--     local expression  = lpegmatch(pattern,str,1,keys)
+--     for k, v in next, keys do
+--         definitions[#definitions+1] = v
+--     end
+--     definitions = concat(definitions,"\n")
+--     print(f_template(definitions,expression))
+-- end
 
-local cache = { } -- todo: make weak, or just remember the last one (trial typesetting)
+-- test("match(foo:bar and (foo:bar or foo:bar))")
+-- test("match(foo=bar and (foo=bar or foo=bar))")
+-- test("match(set:foo:bar),match(set:foo:bar)")
+-- test("match(set:foo=bar)")
+-- test("match(foo:{bar bar})")
+-- test("match(foo={bar bar})")
+-- test("match(set:foo:'bar bar')")
+-- test("match(set:foo='bar bar')")
+-- test("match(set:foo<1000 2000>)")
+-- test("match(set:foo<1000 2000>)")
+-- test("match(*:foo)")
+-- test("match(*:*)")
 
 local check = P("match") -- * space^0 * Cp()
 
-local function finder(expression)
-    local found = cache[expression]
-    if found == nil then
-     -- local e = lpegmatch(check,expression)
-     -- found = e and compile(expression,e) or false
-        found = lpegmatch(check,expression) and compile(expression) or false
-        if found then
-            local okay, message = pcall(found,{})
-            if not okay then
-                found = false
-                report("error in match: %s",message)
-            end
+local function finder(dataset,expression)
+    local found = lpegmatch(check,expression) and compile(dataset,expression) or false
+    if found then
+        local okay, message = pcall(found,{})
+        if not okay then
+            found = false
+            report("error in match: %s",message)
         end
-        cache[expression] = found
     end
     return found
 end
@@ -202,7 +366,7 @@ end
 publications.finder = finder
 
 function publications.search(dataset,expression)
-    local find = finder(expression)
+    local find = finder(dataset,expression)
     if find then
         local ordered = dataset.ordered
         local target  = { }
@@ -218,37 +382,15 @@ function publications.search(dataset,expression)
     end
 end
 
--- local dataset = publications.new()
--- publications.load(dataset,"t:/manuals/hybrid/tugboat.bib")
---
--- local n = 500
+-- local d = publications.datasets.default
 --
--- local function test(dataset,str)
---     local found
---     local start = os.clock()
---     for i=1,n do
---         found = search(dataset,str)
---     end
---     local elapsed = os.clock() - start
---     print(elapsed,elapsed/500,#table.keys(dataset.luadata),str)
---     print(table.concat(table.sortedkeys(found)," "))
---     return found
--- end
+-- local d = publications.load {
+--     dataset   = "default",
+--     filename = "t:/manuals/mkiv/hybrid/tugboat.bib"
+-- }
 --
--- local found = test(dataset,[[match(author:hagen)]])
--- local found = test(dataset,[[match(author:hagen and author:hoekwater and year:1990-2010)]])
--- local found = test(dataset,[[match(author:"Bogusław Jackowski")]])
--- local found = test(dataset,[[match(author:"Bogusław Jackowski" and (tonumber(field:year) or 0) > 2000)]])
--- local found = test(dataset,[[Hagen:TB19-3-304]])
-
--- 1.328	0.002656	2710	author:hagen
--- Berdnikov:TB21-2-129 Guenther:TB5-1-24 Hagen:TB17-1-54 Hagen:TB19-3-304 Hagen:TB19-3-311 Hagen:TB19-3-317 Hagen:TB22-1-58 Hagen:TB22-3-118 Hagen:TB22-3-136 Hagen:TB22-3-160 Hagen:TB23-1-49 Hagen:TB25-1-108 Hagen:TB25-1-48 Hagen:TB26-2-152
-
--- 1.812	0.003624	2710	author:hagen and author:hoekwater and year:1990-2010
--- Berdnikov:TB21-2-129
-
--- 1.344	0.002688	2710	author:"Bogusław Jackowski"
--- Berdnikov:TB21-2-129 Jackowski:TB16-4-388 Jackowski:TB19-3-267 Jackowski:TB19-3-272 Jackowski:TB20-2-104 Jackowski:TB24-1-64 Jackowski:TB24-3-575 Nowacki:TB19-3-242 Rycko:TB14-3-171
-
--- 1.391	0.002782	2710	author:"Bogusław Jackowski" and (tonumber(field:year) or 0) > 2000
--- Jackowski:TB24-1-64 Jackowski:TB24-3-575
+-- inspect(publications.search(d,[[match(author:hagen)]]))
+-- inspect(publications.search(d,[[match(author:hagen and author:hoekwater and year:1990-2010)]]))
+-- inspect(publications.search(d,[[match(author:"Bogusław Jackowski")]]))
+-- inspect(publications.search(d,[[match(author:"Bogusław Jackowski" and (tonumber(field:year) or 0) > 2000)]]))
+-- inspect(publications.search(d,[[Hagen:TB19-3-304]]))
diff --git a/tex/context/base/publ-imp-apa.lua b/tex/context/base/publ-imp-apa.lua
index d26e32ac4..5182e016d 100644
--- a/tex/context/base/publ-imp-apa.lua
+++ b/tex/context/base/publ-imp-apa.lua
@@ -30,43 +30,27 @@ local specification = {
         -- vons Last, Jrs, First
         -- Vons, Last, Jrs, First
         --
-        author      = "author",
+        author      = "author", -- interpreted as name(s)
         editor      = "author",
         artist      = "author",
         interpreter = "author",
         composer    = "author",
         producer    = "author",
-        doi         = "url",
+        doi         = "url",        -- an external link
         url         = "url",
-        page        = "pagenumber",
+        page        = "pagenumber", -- number or range: f--t
         pages       = "pagenumber",
-        keywords    = "keyword",
+        volume      = "range",
+        number      = "range",
+        keywords    = "keyword",    -- comma|-|separated list
+        year        = "number",
     },
     --
     -- categories with their specific fields
     --
     categories = {
         --
-        -- the following fields are for documentation and testing purposes
-        --
-        ["demo-a"] = {
-            sets     = {
-                author  = { "author", "institution", "organization" },
-                doi     = { "doi", "url" },
-            },
-            required = { "author", "title", "year", "note", "doi" },
-            optional = { "subtitle", "file" },
-        },
-        ["demo-b"] = {
-            sets     = {
-                authors = { "author", "institution", "organization" },
-                doi     = { "doi", "url" },
-            },
-            required = { "authors", "title", "year", "note", "doi" },
-            optional = { "subtitle", "file" },
-        },
-        --
-        -- more categories are added below
+        -- categories are added below
         --
     },
 }
@@ -78,7 +62,8 @@ local generic = {
     -- allows the substitution of an alternate field.
     --
     -- note that anything can get assigned a doi or be available online.
-    doi = { "doi", "url" },
+    doi        = { "doi", "url" },
+    editionset = { "edition", "volume", "number", "pages" },
 }
 
 -- Definition of recognized categories and the fields that they contain.
@@ -98,7 +83,6 @@ local categories = specification.categories
 categories.article = {
     sets = {
         author = { "author", "editor", "title" },
-	    volume = { "volume", "number", "pages" },
         doi    = generic.doi,
         isbn   = { "issn" },
     },
@@ -108,7 +92,7 @@ categories.article = {
     optional = {
         "year",
         "subtitle", "type", "file",
-        "journal", "volume",
+        "journal", "volume", "number", "pages",
         "doi", "note", "isbn"
     },
 }
@@ -124,7 +108,7 @@ categories.magazine = {
     },
     optional = {
         "subtitle", "type", "file",
-        "volume",
+        "number",
         "month", "day",
         "doi", "note", "isbn"
     },
@@ -174,15 +158,15 @@ categories.standard = {
 
 categories.book = {
     sets = {
-        author  = { "author", "editor", "publisher", "title" },
-        edition = { "edition", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author     = { "author", "editor", "publisher", "title" },
+        editionset = generic.editionset,
+        doi        = generic.doi,
     },
     required = { "author" },
     optional = {
         "year", "month", "day",
         "subtitle", "type",  "file",
-        "edition", "series",
+        "editionset", "series",
         "address",
         "doi", "note", "isbn"
     },
@@ -192,9 +176,9 @@ categories.book = {
 
 categories.inbook = {
     sets = {
-        author  = { "author", "editor", "publisher", "title", "chapter" },
-        edition = { "edition", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author     = { "author", "editor", "publisher", "title", },
+        editionset = generic.editionset,
+        doi        = generic.doi,
     },
     required = {
         "author",
@@ -202,72 +186,78 @@ categories.inbook = {
     },
     optional = {
         "subtitle", "type", "file",
-        "edition", "series",
+        "booktitle",
+        -- APA ignores this: "chapter",
+        "editionset", "series",
         "month",
         "address",
         "doi", "note", "isbn"
     },
 }
 
--- a work that is printed and bound, but without a named publisher or sponsoring institution.
+-- a book having its own title as part of a collection.
+-- (like inbook, but we here make booktitle required)
 
-categories.booklet = {
+categories.incollection = {
     sets = {
-        author = { "author", "title" },
-        doi    = generic.doi,
+        author     = { "author", "editor", "publisher", "title", },
+        editionset = generic.editionset,
+        doi        = generic.doi,
     },
     required = {
-        "author"
+        "author",
+        "booktitle",
+        "year",
     },
     optional = {
-        "year", "month",
         "subtitle", "type", "file",
+        "editionset", "series",
+        -- APA ignores this: "chapter",
+        "month",
         "address",
-        "howpublished",
         "doi", "note", "isbn"
-     },
+    },
 }
 
--- a part of a book having its own title.
+-- a work that is printed and bound, but without a named publisher or sponsoring institution.
 
-categories.incollection = {
+categories.booklet = {
     sets = {
-        author  = { "author", "editor", "publisher", "title" },
-        edition = { "edition", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author = { "author", "title", },
+        publisher = { "howpublished" }, -- no "publisher"!
+        doi    = generic.doi,
     },
     required = {
-        "author",
-        "booktitle",
-        "year",
+        "author"
     },
     optional = {
+        "publisher",
+        "year", "month",
         "subtitle", "type", "file",
-        "month",
-        "edition", "series",
-        "chapter",
         "address",
         "doi", "note", "isbn"
-    },
+     },
 }
 
 -- the proceedings of a conference.
 
 categories.proceedings = {
     sets = {
-        author  = { "editor", "publisher", "title" },
-        edition = { "edition", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author     = { "editor", "organization", "publisher", "title" }, -- no "author"!
+        publisher  = { "publisher", "organization" },
+        editionset = generic.editionset,
+        doi        = generic.doi,
     },
     required = {
         "author",
         "year"
     },
     optional = {
+        "publisher",
         "subtitle", "file",
-        "edition", "series",
+        "editionset", "series",
         "month",
-        "address", "organization",
+        "address",
         "doi", "note", "isbn"
     },
 }
@@ -331,9 +321,10 @@ categories.phdthesis = categories.mastersthesis
 
 categories.techreport = {
     sets = {
-        -- no "edition"!
-        edition = { "type", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author     = { "author", "institution", "publisher", "title" },
+        publisher  = { "publisher", "institution", },
+        editionset = { "type", "volume", "number", "pages" }, -- no "edition"!
+        doi        = generic.doi,
     },
     required = {
         "author",
@@ -342,10 +333,11 @@ categories.techreport = {
         "year"
     },
     optional = {
+        "publisher",
+        "address",
         "subtitle", "file",
-        "edition", -- set, not field!
+        "editionset",
         "month",
-        "address",
         "doi", "note", "isbn"
     },
 }
@@ -354,16 +346,19 @@ categories.techreport = {
 
 categories.manual = {
     sets = {
-        edition = { "edition", "volume", "number", "pages" },
-        doi     = generic.doi,
+        author     = { "author", "organization", "publisher", "title" },
+        publisher  = { "publisher", "organization", },
+        editionset = generic.editionset,
+        doi        = generic.doi,
     },
     required = {
         "title"
     },
     optional = {
+        "author", "publisher",
+        "address",
         "subtitle", "file",
-        "author", "address", "organization",
-        "edition", "month", "year",
+        "editionset", "month", "year",
         "doi", "note", "isbn"
     },
 }
@@ -372,20 +367,25 @@ categories.manual = {
 
 categories.patent = {
     sets = {
+        author = { "author", "assignee", },
+        publisher = { "publisher", "assignee", },
+        year = { "year", "yearfiled", },
+        month = { "month", "monthfiled", },
+        day = { "day", "dayfiled", },
         doi = generic.doi,
     },
     required = {
         "nationality",
         "number",
-        "year", "yearfiled"
+        "year",
     },
     optional = {
         "type",
         --check this: "language",
-        "author", "assignee",
+        "author", "publisher",
         "title", "subtitle", "file",
         "address",
-        "day", "dayfiled", "month", "monthfiled",
+        "day", "month",
         "doi", "note"
     },
 }
diff --git a/tex/context/base/publ-imp-apa.mkvi b/tex/context/base/publ-imp-apa.mkvi
index d7dc4db9a..256636325 100644
--- a/tex/context/base/publ-imp-apa.mkvi
+++ b/tex/context/base/publ-imp-apa.mkvi
@@ -10,10 +10,10 @@
 %C This module is part of the \CONTEXT\ macro||package and is therefore copyrighted
 %D by \PRAGMA. See mreadme.pdf for details.
 
-% \loadbtxdefinitionfile[def]
-
 \startbtxrenderingdefinitions[apa]
 
+\ifdefined\c!translate \else \def\c!translate{translate} \fi
+
 %D Reference:
 %D \startTEX
 %D @Book{APA2010,
@@ -27,68 +27,261 @@
 %D }
 %D \stopTEX
 
-% set all APA compliant values (may be redundant but we do not count on defaults.)
+% The APA style sorts the unnumbered rendered list by authoryear
+
+% Hans: should we be using or not using \c!, \s! and \v! ??
+
+% Sure: not using \c! and v! would mean that only the english interface is
+% supported and \s! saves some bytes (only within the setups). I'll deal with
+% that in the end.
+
+\definebtxrendering
+  [apa]
+  [\c!specification=apa,
+   \c!sorttype=authoryear,
+   \c!numbering=\v!no]
 
 \setupbtxlist
-  [alternative=hanging,
-   margin=3em]
+  [apa]
+  [\c!alternative=\v!paragraph,
+   \c!width=\v!fit,
+   \c!distance=.5\emwidth,
+   \c!margin=3\emwidth]
+
+% The sameauthor feature may not be APA compliant
+% (there is nothing in the manual cited above).
+% It can be removed using the command:
+% \resetsetups [apa:list:sameauthor]
+
+% Or texdefinition?
+
+\startsetups [apa:list:sameauthor]
+    \fastsetup{apa:list:sameauthor:rule}
+\stopsetups
+
+\startsetups [apa:list:sameauthor:rule]
+    \blackrule
+      [\c!width=\dimexpr\listparameter\c!margin-\interwordspace\relax,
+       \c!height=1.5\linewidth]% are you sure you want to inconsistent with the rest? happens nowhere!
+\stopsetups
 
-\setupbtxlistvariant
-  [\c!namesep={,\space},
-   \c!lastnamesep={,\nobreakspace\textampersand\space},
-   \c!finalnamesep={,\nobreakspace\textampersand\space},
+\startsetups [apa:list:sameauthor:\v!empty]% it's not a space
+    \kern\dimexpr\listparameter\c!margin-\interwordspace\relax
+\stopsetups
+
+\startsetups [apa:list:sameauthor:ditto] % horrible !
+    \inframed
+      [\c!width=\dimexpr\listparameter\c!margin-\interwordspace\relax,
+       \c!frame=\v!off,
+       \c!align=\v!middle]
+      {\doubleprime}
+\stopsetups
+
+% set ALL specific APA compliant values
+% Note that fallback is apa, default, then root
+
+\definebtx
+  [apa]
+  [\c!default=, % no fallback on default rendering
+   \c!namesep={,\space},
+   \c!lastnamesep={,\nobreakspace\textampersand\space}, % comma separated list
+   \c!finalnamesep={\nobreakspace\textampersand\space}, % last of two, no comma!
    \c!firstnamesep=\space,
-   \c!otherstext={,\space\btxlabeltext{\currentbtxspecification:others}},
-   \c!juniorsep=\space,
-   \c!vonsep=\space,
-   \c!initialsep=\space,  % between initials and lastname
-  %\c!initialssep=\space, % between multiple initials  % todo
-  %\c!initialsterminator={.},                          % todo
+   \c!otherstext={\space\btxlabeltext{apa:others}},
+   \c!juniorsep={\space},
+   \c!vonsep={\space},
+   \c!initialsep={\space},
    \c!surnamesep={,\space},
    \c!surnameinitialsep={,\space},
    \c!surnamefirstnamesep={,\space},
-   \c!etallimit=5,
-   \c!etaldisplay=\btxlistvariantparameter\c!etallimit,
-  %\c!journalconversion=\v!normal,
+   \c!pubsep={,\space},
+   \c!lastpubsep={,\space\btxlabeltext{apa:and}\space},% not btxcomma?
+   \c!finalpubsep={\space\btxlabeltext{apa:and}\space}]
+
+\definebtx
+  [apa:list]
+  [apa]
+  [\c!otherstext={,\nobreakspace\textellipsis\space},
+   \c!etallimit=7,
+   \c!etaldisplay=6,
+   %c!journalconversion=\v!normal,
    \c!monthconversion=\v!month,
    \c!authorconversion=invertedshort]
 
-\definebtxlistvariant
-  [author]
+% The following are similar to default, but inherit from apa:list
+
+\definebtx
+  [apa:list:author]
+  [apa:list]
+
+\definebtx
+  [apa:list:editor]
+  [apa:list:author]
+
+\definebtx
+  [apa:list:suffix]
+  [apa:list]
+
+\definebtx
+  [apa:list:url]
+  [apa:list]
+
+\definebtx
+  [apa:list:doi]
+  [apa:list]
+
+\definebtx
+  [apa:list:invertedshort]
+  [apa:list]
+
+\definebtx
+  [apa:list:short]
+  [apa:list]
+
+%D In order to be able to get journals expanded (or normalized or abbreviated) you need
+%D to load a list:
+%D
+%D \starttyping
+%D \btxloadjournallist[journals.txt] % the jabref list
+%D \stoptyping
+
+% TODO
+
+\definebtx
+  [apa:list:journal]
+  [\c!style=\v!italic]
+  %command=\btxexpandedjournal] % btxabbreviatedjournal
+
+\definebtx
+  [apa:list:title]
+  [\c!style=\v!italic,
+   \c!command=\Word,
+   \c!translate=\v!yes]
+
+\definebtx
+  [apa:list:title:article]
+  [apa:list:title]
+  [\c!style=] % journal is set in italics
+
+\definebtx
+  [apa:list:title:magazine]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:newspaper]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:periodical]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:standard]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:book]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:inbook]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:incollection]
+  [apa:list:title]
+  [\c!style=] % booktitle is set in italics
+
+\definebtx
+  [apa:list:title:proceedings]
+  [apa:list:title]
 
-\definebtxlistvariant
-  [editor]
-  [author]
+\definebtx
+  [apa:list:title:inproceedings]
+  [apa:list:title]
+  [\c!style=] % booktitle is set in italics
 
-% like \setupbtxlistvariant above but not exactly...
+\definebtx
+  [apa:list:title:conference]
+  [apa:list:title]
+  [\c!style=] % booktitle is set in italics
+
+\definebtx
+  [apa:list:title:thesis]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:phdthesis]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:mastersthesis]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:booklet]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:manual]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:techreport]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:unpublished]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:patent]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:electronic]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:other]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:misc]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:title:literal]
+  [apa:list:title]
+
+\definebtx
+  [apa:list:type]
+  [\c!command=\Word]
+
+% We define [page] settings in the apa namespace, inheriting the root
+% settings, in order to eventually allow for modifications without touching
+% root.
+
+\definebtx
+  [apa:page]
+  [\s!page]
+
+\definebtx
+  [apa:page:list]
+  [apa:page]
+  [\c!command={\wordright}]
 
 % The APA style defines authoryear citations.
 
-\setupbtxcitevariant
+\definebtx
+  [apa:cite]
+  [apa:list]
   [\c!alternative=authoryear,
-   \c!namesep=\btxlistvariantparameter\c!namesep,
-   \c!lastnamesep=\btxlistvariantparameter\c!lastnamesep,
-   \c!finalnamesep={\nobreakspace\textampersand\space}, % no comma!
-   \c!firstnamesep=\btxlistvariantparameter\c!firstnamesep,
-   \c!otherstext=\btxlistvariantparameter\c!otherstext,
-   \c!juniorsep=\btxlistvariantparameter\c!juniorsep,
-   \c!vonsep=\btxlistvariantparameter\c!vonsep,
-   \c!initialsep=\btxlistvariantparameter\c!initialsep,
-  %\c!initialssep=\btxlistvariantparameter\c!initialssep,
-  %\c!initialsterminator=\btxlistvariantparameter\c!initialsterminator,
-   \c!surnamesep=\btxlistvariantparameter\c!surnamesep,
-   \c!surnameinitialsep=\btxlistvariantparameter\c!surnameinitialsep,
-   \c!surnamefirstnamesep=\btxlistvariantparameter\c!surnamefirstnamesep,
-   \c!etallimit=5, % when 2-4, show all first time, etaldisplay subsequently...
-   \c!etaldisplay=1,
- % \c!monthconversion=\btxlistvariantparameter\c!monthconversion,
+   \c!otherstext={,\space\btxlabeltext{apa:others}},
+   \c!etallimit=5,
+   \c!etaldisplay=1, % TODO: when 2-4, show all first time, etaldisplay subsequently...
    \c!authorconversion=\v!name,
-   \c!interaction=\v!start,
- % \c!setups=btx:cite:initialize,
-   \c!pubsep={,\space},
-   \c!lastpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!finalpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!sorttype=,
+   \c!sorttype=authoryear,
    \c!compress=\v!no,
    \c!inbetween=\space,
    \c!range=\endash,
@@ -96,51 +289,170 @@
    \c!middle=,
    \c!right=]
 
-\definebtxcitevariant
-   [author]
-   [\c!lastnamesep={,\nobreakspace\textampersand\space},
-    \c!finalnamesep={\nobreakspace\textampersand\space}, % no comma!
-    \c!authorconversion=\v!name]
-
-\definebtxcitevariant
-   [authoryear]
-   [\c!compress=\v!yes,
-    \c!inbetween={,\space},
-    \c!left={(},
-    \c!right={)},
-    \c!pubsep={;\space},
-    \c!lastpubsep={;\space},
-    \c!finalpubsep={;\space},
-    \c!lastnamesep={,\space\btxlabeltext{\currentbtxspecification:and}\space},
-    \c!finalnamesep={\space\btxlabeltext{\currentbtxspecification:and}\space}, % no comma!
-    \c!authorconversion=\v!name]
-
-\definebtxcitevariant
-   [authoryears]
-   [authoryear]
-   [\c!left=,
-    \c!inbetween={\space(},
-    \c!pubsep={);\space},
-    \c!lastpubsep={);\space},
-    \c!finalpubsep={);\space},
-    \c!lastnamesep={,\space\btxlabeltext{\currentbtxspecification:and}\space},
-    \c!finalnamesep={\space\btxlabeltext{\currentbtxspecification:and}\space}, % no comma!
-    \c!authorconversion=\v!name]
-
-% The APA style also sorts the rendered list by authoryear
-
-\setupbtxrendering
-    [sorttype=authoryear,
-     numbering=no]
-
-% Should the following be loaded by default?
+\definebtx
+  [apa:cite:author]
+  [apa:cite]
+  [\c!lastnamesep={,\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!finalnamesep={\space\btxlabeltext{apa:and}\space}] % not \textampersand
+
+% The following are similar to default, but inherit from apa:cite
+
+\definebtx
+  [apa:cite:authoryear]
+  [apa:cite:author]
+  [\c!compress=\v!yes,
+   \c!left={(},
+   \c!right={)},
+   \c!inbetween={,\space},
+   \c!pubsep={;\space},
+   \c!lastpubsep={;\space},
+   \c!finalpubsep={;\space}]
+
+\definebtx
+  [apa:cite:authoryears]
+  [apa:cite:authoryear]
+  [\c!left=,
+   \c!right=,
+   \c!inbetween={\space},
+   \c!pubsep={;\space},
+   \c!lastpubsep={;\space},
+   \c!finalpubsep={;\space}]
+
+\definebtx
+  [apa:cite:authornum]
+  [apa:cite:author]
+  [\c!left={(},
+   \c!right={)},
+   \c!sorttype=authornum]
+
+\definebtx
+  [apa:cite:authorref]
+  [apa:cite:authornum]
+
+\definebtx
+  [apa:cite:author:num] % todo
+  [apa:cite:authornum]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:author:year] % todo
+  [apa:cite:authoryear]
+  [\c!left=,
+   \c!right=]
 
-%D In order to be able to get journals expanded (or normalized or abbreviated) you need
-%D to load a list:
-%D
-%D \starttyping
-%D \btxloadjournallist[journals.txt] % the jabref list
-%D \stoptyping
+\definebtx
+  [apa:cite:author:years] % todo
+  [apa:cite:authoryears]
+  [\c!inbetween=,
+   \c!left=(,
+   \c!right=)]
+
+\definebtx
+  [apa:cite:year]
+  [apa:cite]
+  [\c!pubsep={,\space},
+   \c!lastpubsep={,\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!finalpubsep={\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!compress=\v!yes,
+   \c!sorttype=\v!default]
+
+\definebtx
+  [apa:cite:title]
+  [apa:cite]
+  [\c!pubsep={,\space},
+   \c!lastpubsep={,\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!finalpubsep={\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!command={\language[\currentbtxlanguage]}, % BAH
+   \c!style=\v!italic]
+
+\definebtx
+  [apa:cite:booktitle]
+  [apa:cite:title]
+
+\definebtx
+  [apa:cite:tag]
+  [apa:cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:key]
+  [apa:cite:tag]
+
+\definebtx
+  [apa:cite:serial]
+  [apa:cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:page]
+  [apa:cite]
+  [\c!left=,
+   \c!right=,
+   \c!pubsep={,\space},
+   \c!lastpubsep={,\space\btxlabeltext{apa:and}\space}, % not \textampersand
+   \c!finalpubsep={\space\btxlabeltext{apa:and}\space}] % not \textampersand
+
+\definebtx
+  [apa:cite:pages]
+  [apa:cite:page]
+
+\definebtx
+  [apa:cite:keywords]
+  [apa:cite]
+  [\c!left={(},
+   \c!right={)}]
+
+\definebtx
+  [apa:cite:invertedshort]
+  [apa:cite]
+
+\definebtx
+  [apa:cite:short]
+  [apa:cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:category]
+  [apa:cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:type]
+  [apa:cite:category]
+
+\definebtx
+  [apa:cite:url]
+  [apa:cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [apa:cite:doi]
+  [apa:cite:url]
+
+\definebtx
+  [apa:cite:num]
+  [apa:cite]
+  [\c!compress=\v!yes,
+   \c!left={[},
+   \c!right={]},
+   \c!pubsep={,},
+   \c!lastpubsep={,},
+   \c!finalpubsep={,}]
+
+\definebtx
+  [apa:cite:textnum]
+  [apa:cite:num]
+  [\c!left={Ref.\nbsp},
+   \c!right=,
+   \c!pubsep={,},
+   \c!lastpubsep={\space\btxlabeltext{apa:and}\space},
+   \c!finalpubsep={\space\btxlabeltext{apa:and}\space}]
 
 %D Sometimes we have verbose injections in an entry and these can be language
 %D dependent, so we use labels.
@@ -148,357 +460,477 @@
 %D Because we want to mix rendering (in the manual) we need a namespace in label
 %D texts:
 
-% TODO: The APA guide calls for abbreviations, but this should be a tunable option.
-% We need then to define both and create a mechanism to select.
-
 \setupbtxlabeltext
   [en]
-  [apa:mastersthesis={Master's thesis},
-   apa:phdthesis={PhD thesis},
+  [apa:and=and,
+   apa:number={no.},
+   apa:edition={ed.},
+   apa:Editor={Ed.},
+   apa:Editors={Eds.},
+   apa:Volume={Vol.},
+   apa:Volumes={Vols.},
+   apa:others={et al.},
+   apa:page={p.},
+   apa:pages={pp.},
+   apa:nd={n.d.},     % no date
+   apa:mastersthesis={Master's thesis},
+   apa:phdthesis={Doctoral dissertation},
    apa:technicalreport={Tech. Rep.},  % Technical report
    apa:supplement={Suppl.},           % Supplement
    apa:patent=Patent,
-   apa:Translator={Trans.},           % Translator(s)
-   apa:Editor={Ed.},                  % Editor
-   apa:Editors={Eds.},                % Editors
-   apa:edition={ed.},                 % edition
-   apa:volume=volume, % used?
-   apa:Volume={Vol.},                 % Volume
-   apa:Volumes={Vols.},               % Volumes
-   apa:number=number,
-   apa:Number={No.},                  % Number
-   apa:nd={n.d.},                     % no date
-   apa:in=in,
-   apa:of=of,
-   apa:In=In,
-   apa:Part={Pt.},                    % Part
-   apa:p={p.},
-   apa:pp={pp.},
-   apa:pages=pages,
-   apa:and=and,
-   apa:period={. },
    apa:Author=Author,
-   apa:Reference={Ref.},
-   apa:References={Refs.},
+   apa:Translator={Trans.},           % Translator(s)
    apa:Advanced={Advanced online publication},
    apa:Retrieved={Available from},    % {Retrieved from},
-   apa:others={et al.}]
+   apa:In=In]
+
+% Check this (google translate!!):
+
+\setupbtxlabeltext
+  [nl]
+  [apa:and=en,
+   apa:number={nr.},
+   apa:edition={ed.}, % editie
+   apa:Editor=Editor, % Ed./Eds.
+   apa:Editors=Editors,
+   apa:Volume={Vol.},
+   apa:Volumes={Vols.},
+   apa:others={et al.},
+   apa:page={p.},
+   apa:pages={pp.},
+   apa:nd={g.d.}      % geen datum
+   apa:mastersthesis=Masterproef,
+   apa:phdthesis=Proefschrift,
+   apa:technicalreport={Technisch rapport},  % Technical report
+   apa:supplement=Supplement,
+   apa:patent=Octrooi,
+   apa:Author=Auteur,
+   apa:Translator=Vertaler,
+   apa:Advanced={Geavanceerde online publicatie},
+   apa:Retrieved={Beschikbaar vanaf},    % {Ontvangen van},
+   apa:In=In]
 
 \setupbtxlabeltext
   [fr]
-  [apa:mastersthesis={Thèse de master (DEA, DESS, master)},
-   apa:phdthesis={Thèse de doctorat},
-   apa:technicalreport={Rapport technique},
-   apa:supplement=Supplément,
-   apa:patent=Brevet,
-   apa:Translator=Traducteur,
+  [apa:and=et,
+   apa:others={et al.},
+   apa:number={n\high{o}},
+   apa:edition={édition},
    apa:Editor=Éditeur,
    apa:Editors=Éditeurs,
-   apa:edition=édition,
-   apa:volume=volume,
    apa:Volume=Volume,
    apa:Volumes=Volumes,
-   apa:number=numéro,
-   apa:Number=Numéro,
-   apa:nd={s.d.}                      % sans date
-   apa:in=dans,
-   apa:of=de,
-   apa:In=Dans,
-   apa:Part=Partie,
-   apa:p={p.},
-   apa:pp={pp.},
-   apa:pages=pages,
-   apa:and=et,
-   apa:period={. },
+   apa:others={et al.},
+   apa:page={p.},
+   apa:pages={pp.},
+   apa:nd={s.d.}      % sans date
+   apa:mastersthesis={Thèse de master (DEA, DESS, master)},
+   apa:phdthesis={Thèse de doctorat},
+   apa:technicalreport={Rapport technique},
+   apa:supplement=Supplément,
+   apa:patent=Brevet,
    apa:Author=Auteur,
-   apa:Reference={Réf.},
-   apa:References={Réfs.},
+   apa:Translator=Traducteur,
    apa:Advanced={Publication en ligne anticipée},
    apa:Retrieved={Disponible à},      % {Téléchargé de},
-   apa:others={et al.}]
+   apa:In=Dans]
 
 \setupbtxlabeltext
   [de]
-  [apa:mastersthesis={Masterarbeit},
+  [apa:and=und,
+   apa:number={nr.},
+   apa:edition=Auf\/lage,
+   apa:Editor=Herausgeber, % Hrsg./Hg.
+   apa:Editors=Herausgeber,
+   apa:Volume=Band,        % Bd.
+   apa:Volumes={Bände},
+   apa:others={et al.},
+   apa:page={S.},
+   apa:pages={S.},
+   apa:nd={o.D.},          % ohne Datum (mostly: o.J. / ohne Jahr)
+   apa:mastersthesis={Masterarbeit},
    apa:phdthesis={Dissertation},
    apa:technicalreport={Technischer Bericht},
    apa:supplement={Beilage},          % Supplement
    apa:patent=Patent,
-   apa:Translator={Übersetzer},       % Übers.
-   apa:Editor=Herausgeber,            % Hrsg./Hg.
-   apa:Editors=Herausgeber,
-   apa:edition=Auf\/lage,
-   apa:volume=Band,                   % Bd.
-   apa:Volume=Band,
-   apa:Volumes={Bände},
-   apa:number=Nummer,
-   apa:Number={Nr.},
-   apa:nd={o.D.},                     % ohne Datum (mostly: o.J. / ohne Jahr)
-   apa:in=in,
-   apa:of=von,
-   apa:In=In,
-   apa:Part=Teil,
-   apa:p={S.},
-   apa:pp={S.},
-   apa:pages=Seiten,
-   apa:and=und,
-   apa:period={. },
    apa:Author=Autor,
-   apa:Reference={Ref.},
-   apa:References={Ref.},
+   apa:Translator={Übersetzer},       % Übers.
    apa:Advanced={Erweiterte Online-Publikation},
    apa:Retrieved={heruntergeladen von},
-   apa:others={et al.}]
+   apa:In=In]
 
 % thanks: Andrea Valle
 
 \setupbtxlabeltext
   [it]
-  [apa:mastersthesis={Tesi di laurea},
+  [apa:and=e,
+   apa:number={nº},
+   apa:edition={ed.}, % edizione
+   apa:Editor={A cura di},
+   apa:Editors={A cura di},
+   apa:Volume={Vol.},  % Volume
+   apa:Volumes={Vol.}, % Volumi
+   apa:others={et al.},
+   apa:page={p.},
+   apa:pages={pp.},
+   apa:nd={s.d.},     % senza data
+   apa:mastersthesis={Tesi di laurea},
    apa:phdthesis={Tesi di dottorato},
    apa:technicalreport={Relazione tecnica},
    apa:supplement={Supplemento},
    apa:patent=Brevetto,
-   apa:Translator={Trad.},                        % Translator(s)
-   apa:Editor={A cura di},
-   apa:Editors={A cura di},
-   apa:edition={ed.},
-   apa:volume=volume,
-   apa:Volume={Vol.},
-   apa:Volumes={Vol.},
-   apa:number=numero,
-   apa:Number=Numero,
-   apa:nd={s.d.},
-   apa:in=in,
-   apa:of=di,
-   apa:In=In,
-   apa:Part=Parte,
-   apa:p={p.},
-   apa:pp={pp.},
-   apa:pages=pagine,
-   apa:and=e,
-   apa:period={. },
    apa:Author=Autore,
-   apa:Reference={Rif.},
-   apa:References={Rif.},
+   apa:Translator={Trad.},                        % Translator(s)
    apa:Advanced={Pre-pubblicazione on line},
    apa:Retrieved={Accessible online},
-   apa:others={et al.}]
+   apa:In=In]
 
-%D Instead of texdefinitions without arguments, we could have used setups but in my
-%D editor (hh, scite) the commands stand out better. It also saves an additional
-%D component in the name (e.g. common:) because commands and setups have a different
-%D namespace, so similar calls don't clash. Performance of definitions is somewhat
-%D better.
+\setupbtxlabeltext
+  [es]
+  [apa:and=y,
+   apa:number={nº},
+   apa:edition={ed.}, % edición
+   apa:Editor=Editor, % Ed./Eds.
+   apa:Editors=Editores,
+   apa:Volume={Vol.},   % Volumen
+   apa:Volumes={Vols.}, % Volúmenes
+   apa:others={et al.},
+   apa:page={p.},
+   apa:pages={pp.},
+   apa:nd={s.f.},     % sin fecha
+   apa:mastersthesis={Tesis de maestría},
+   apa:phdthesis={Tesis doctoral},
+   apa:technicalreport={Informe técnico},
+   apa:supplement=Suplemento,
+   apa:patent=Patente,
+   apa:Author=Autor,
+   apa:Translator=Traductor,
+   apa:Advanced={Publicación en línea avanzada},
+   apa:Retrieved={Disponible desde},    % {Obtenido de},
+   apa:In=En]
+
+% cite setups
+
+% as we don't fallback on default (no sane person will render the titles
+% differently so it's a bit over the top):
 
-%D \btxdoif... and \btxflush rely on the definitions in publ-imp-apa.lua:
-%D fields that are not listed as required nor optional are IGNORED.
+\startsetups btx:apa:cite:empty
+    \fastsetup{\s!btx:\s!cite:\s!empty}
+\stopsetups
+\startsetups btx:apa:cite:unknown
+    \fastsetup{\s!btx:\s!cite:\s!unknown}
+\stopsetups
+\startsetups btx:apa:cite:author
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups btx:apa:cite:authoryear
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups btx:apa:cite:authoryears
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups btx:apa:cite:authornum
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups btx:apa:cite:title
+    \fastsetup{\s!btx:\s!cite:\s!normal}
+\stopsetups
+\startsetups btx:apa:cite:booktitle
+    \fastsetup{btx:apa:cite:title}
+\stopsetups
+\startsetups btx:apa:cite:entry
+    \fastsetup{\s!btx:\s!cite:\s!normal}
+\stopsetups
+\startsetups btx:apa:cite:num
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups btx:apa:cite:textnum
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups btx:apa:cite:year
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+
+\startsetups btx:apa:cite:author:year
+    \texdefinition{\s!btx:\s!cite:concat}
+    \ifx\currentbtxfirst\empty
+        \btxlabeltext{apa:nd}
+    \else
+        \texdefinition {\s!btx:\s!cite:inject} {
+            \btxcitereference
+            \currentbtxfirst
+        }
+        \ifx\currentbtxsecond\empty \else
+            \btxparameter\v!inbetween
+            \texdefinition {\s!btx:\s!cite:inject} {
+                \currentbtxsecond
+            }
+        \fi
+        \ifx\currentbtxthird\empty \else
+            \texdefinition {\s!btx:\s!cite:inject} {
+                \currentbtxthird
+            }
+        \fi
+    \fi
+\stopsetups
 
-% First some helpers:
+\startsetups btx:apa:cite:author:years
+    \fastsetup{btx:apa:cite:author:year}
+\stopsetups
 
-\starttexdefinition btx:apa:inject #link #content
+\startsetups [btx:apa:page:list]
+    \fastsetup{\s!btx:\s!page:concat}
+    \ifx\currentbtxlastpage\empty
+        \btxlabeltext{apa:page}
+    \else
+        \btxlabeltext{apa:pages}
+    \fi
+    \btxnbsp
     \ifconditional\btxinteractive
-        \ifx\currentbtxinternal\empty
-            #content
-        \else
+        \goto {
+            \currentbtxfirstpage
+        } [
+            internal(\currentbtxfirstinternal)
+        ]
+        \ifx\currentbtxlastpage\empty \else
+            \btxparameter\c!pageconnector
             \goto {
-                #content
+                \currentbtxlastpage
             } [
-                #link
+                internal(\currentbtxlastinternal)
             ]
         \fi
     \else
-        #content
+        \currentbtxfirstpage
+        \ifx\currentbtxlastpage\empty \else
+            \btxparameter\c!pageconnector
+            \currentbtxlastpage
+        \fi
     \fi
+\stopsetups
+
+%D Instead of texdefinitions without arguments, we could have used setups but in my
+%D editor (hh, scite) the commands stand out better. It also saves an additional
+%D component in the name (e.g. common:) because commands and setups have a different
+%D namespace, so similar calls don't clash. Performance of definitions is somewhat
+%D better.
+
+%D We use "texdefinitions" (with eventual arguments) for helpers that are used
+%D in the rendering "setups" defined for each category below.
+
+%D Note that \btxdoif... and \btxflush rely on the definitions in
+%D publ-imp-apa.lua: fields that are not listed as required nor optional are
+%D IGNORED. We also make heavy use of the notion of sets - comma-separated lists
+%D of alternative fields to be used in hierarchal order. For example:
+%D author = { "author", "editor", "publisher", "title" }, will return the
+%D author field if it exists; if not, the editor field will be returned, if it
+%D exists; if not, the publisher field will be returned, if it exists; if not,
+%D the title field will be returned, it it exists; if not, nothing will be
+%D returned. In lua syntax, it can be understood as
+%D author or editor or publisher or title or ""
+
+
+\starttexdefinition btx:apa:translated-title #title
+    \ifx\currentbtxlanguage\empty
+        % no need for an extra
+    \else\ifx\mainbtxlanguage\currentbtxlanguage
+        % no need for an extra
+    \else
+        \btxdoif {#title:\mainbtxlanguage} {
+            \begingroup
+                \language[\mainbtxlanguage]
+                \btxleftbracket
+                \btxusecommand[apa:list:title:\currentbtxcategory] {
+                    \btxflush{#title:\mainbtxlanguage}
+                }
+                \btxrightbracket
+            \endgroup
+        }
+    \fi\fi
+\stoptexdefinition
+
+\starttexdefinition btx:apa:composed-title #title
+    \begingroup
+        \language[\currentbtxlanguage]
+        \btxusecommand[apa:list:title:\currentbtxcategory] {
+            \btxflush{#title}
+            \btxdoif {sub#title} {
+                \btxcolon
+                \btxflush{sub#title}
+            }
+        }
+    \endgroup
+    \doif{\btxparameter{translate}}\v!yes {
+        \texdefinition{btx:apa:translated-title}{#title}
+    }
 \stoptexdefinition
 
 \starttexdefinition btx:apa:title
     \setmode{btx:apa:title-placed}
-    \btxdoif {file} {
-         % we make the title active, opening file
-         \texdefinition{btx:apa:inject} {url(file:\btxflush{file})}
-    }
-    {
-        \btxflush{Word -> title}
-        \btxdoif {subtitle} {
-            \btxcolon
-            \btxflush{Word -> subtitle}
-        }
-        \doifnot {\currentbtxcategory} {techreport} {
-            \doifnotmode {btx:apa:thesis} {
-                \btxdoif{type} {
-                    \btxleftbracket
-                    \btxflush{Word -> type}
-                    \btxrightbracket
-                }
+    % we make the title active, opening file
+    \btxdoifelse {file} {
+        \texdefinition{btx:format:inject}
+            {url(file:\btxflush{file})}
+            {
+                \btxstartstyleandcolor [apa:list:title:\currentbtxcategory]
+                    \texdefinition{btx:apa:composed-title}{title}
+                \btxstopstyleandcolor
             }
-        }
+    } {
+        \btxstartstyleandcolor [apa:list:title:\currentbtxcategory]
+            \texdefinition{btx:apa:composed-title}{title}
+        \btxstopstyleandcolor
+    }
+    \btxdoif {title} {
         \btxperiod
     }
 \stoptexdefinition
 
-\starttexdefinition btx:apa:title-if-not-placed #it
-    \doifnotmode {btx:apa:title-placed} {
+\starttexdefinition btx:apa:title-if-not-placed
+    \doifmodeelse {btx:apa:title-placed} {
+        \resetmode{btx:apa:title-placed}
+    } {
         \btxdoif {title} {
             \btxspace
-            \doifelse {#it} {it} {
-                \begingroup
-                    \it
-                    \texdefinition{btx:apa:title}
-                    \italiccorrection
-                \endgroup
-            } {
-                \texdefinition{btx:apa:title}
-            }
+            \texdefinition {btx:apa:title}
         }
     }
 \stoptexdefinition
 
-\starttexdefinition btx:apa:editor
-    \btxflush{editor}
-    \btxleftparenthesis
-    \btxsingularorplural {editor} {
-        \btxlabeltext{apa:Editor}
+\starttexdefinition btx:apa:suffixedyear
+    \btxdoifelse {year} {
+        \btxflush{year}
+        \btxflush{suffix}
     } {
-        \btxlabeltext{apa:Editors}
+        \btxlabeltext{apa:nd}
     }
-    \btxrightparenthesisperiod
 \stoptexdefinition
 
-\starttexdefinition btx:apa:author
-    \btxflush{author}
+\starttexdefinition btx:apa:author-or-editor #author
+    \btxdoif {#author} {
+        \btxflush{#author}
+        \doif {\btxfoundname{#author}} {editor} {
+            \btxleftparenthesis
+            \btxsingularorplural {editor} {
+                \btxlabeltext{apa:Editor}
+            } {
+                \btxlabeltext{apa:Editors}
+            }
+            \btxrightparenthesisperiod
+        }
+    }
 \stoptexdefinition
 
 \starttexdefinition btx:apa:authoryear
     % we make the authoryear active, pointing to the citation
-    \texdefinition{btx:apa:inject} {internal(\currentbtxinternal)}
-    {
-        % author is a set, e.g.
-        % author  = { "author", "editor", "publisher", "title" },
-        \executeifdefined
-            {btx:apa:\btxfoundname{author}}
-            {\texdefinition{btx:apa:author}}
-        \btxleftparenthesis
-        \btxdoifelse {year} {
-            \btxflush{year}
-            %\btxflush{suffix}
-            \btxflush{suffixedyear}
-            \btxdoif {month} {
-                \btxcomma
-                \btxflush{month}
-                \btxdoif {day} {
-                    \btxspace
-                    \btxflush{day}
+    \texdefinition{btx:format:inject}
+        {internal(\currentbtxinternal)}
+        {
+            \doifsetupselse{apa:list:sameauthor} {
+                \btxdoifsameaspreviouselse {author} {
+                    \fastsetup{apa:list:sameauthor}
+                } {
+                    \texdefinition{btx:apa:author-or-editor} {author}
                 }
+            } {
+                \texdefinition{btx:apa:author-or-editor} {author}
             }
-        } {
-            \btxlabeltext{apa:nd}
-            \btxdoif {suffix} {% check this!
-                \btxspace
-                \btxflush{suffix}
-            }
+            \btxleftparenthesis
+            \texdefinition{btx:apa:suffixedyear}
+            \btxrightparenthesis
         }
-        \btxrightparenthesis
-    }
     \btxperiod % outside of interaction
+    \doif {\btxfoundname{author}} {title} {
+        \setmode{btx:apa:title-placed}
+    }
 \stoptexdefinition
 
-\starttexdefinition btx:apa:italic #field
-    \begingroup
-        \it
-        \btxflush{#field}
-        \italiccorrection
-    \endgroup
-\stoptexdefinition
-
-\starttexdefinition btx:apa:editor-in- #title
-    \btxdoifelse {editor} {
+\starttexdefinition btx:apa:editor-in
+    \btxdoif {booktitle} {
         \btxlabeltext{apa:In}
-        \btxspace
-        \texdefinition{btx:apa:editor}
-        \btxdoif {#title} {
-            \texdefinition{btx:apa:italic}{Word -> #title}
-        }
-    } {
-        \btxdoif {#title} {
-            \btxlabeltext{apa:In}
+        \doifnot {\btxfoundname{author}} {editor} {
             \btxspace
-            \texdefinition{btx:apa:italic}{Word -> #title}
+            \texdefinition{btx:apa:author-or-editor} {editor}
         }
+        \btxspace
+        \btxstartstyleandcolor[apa:list:title] % NOT :\currentbtxcategory !
+            \texdefinition{btx:apa:composed-title} {booktitle}
+        \btxstopstyleandcolor
+        \btxperiod
     }
 \stoptexdefinition
 
 \starttexdefinition btx:apa:editionset
-    \btxdoifelse {edition} {
-        \btxleftparenthesis
-        \doif {\currentbtxcategory} {techreport} {
-            \btxdoifelse {type} {
-                \btxflush{Word -> type}
-            } {
-                \btxlabeltext{apa:technicalreport}
-            }
-            \setmode{btx:apa:comma}
-        }
-        \doif {\btxfoundname{edition}} {edition} {
-            \doifmode {btx:apa:comma}
-                {\btxcomma}
-            \btxflush{edition}
-            \btxspace
-            \btxlabeltext{apa:edition}
-            \setmode{btx:apa:comma}
-        }
-        \btxdoif {volume} {
-            \doifmode {btx:apa:comma}
-                {\btxcomma}
-            \btxoneorrange {volume} {
-                \btxlabeltext{apa:Volume}
-            } {
-                \btxlabeltext{apa:Volumes}
+    \btxleftparenthesis
+    \setmode{btx:apa:editionset-empty}
+    \doif {\currentbtxcategory} {techreport} {
+        \resetmode{btx:apa:editionset-empty}
+        \btxdoifelse {type} {
+            \btxusecommand[apa:list:type] {
+                \btxflush{type}
             }
-            \btxspace
-            \btxflush{volume}
-            \setmode{btx:apa:comma}
+        } {
+            \btxlabeltext{apa:technicalreport}
         }
-        \btxdoif {number} {
-            \doifmode {btx:apa:comma}
-                {\btxcomma}
-            \btxlabeltext{apa:Number}
-            \btxspace
-            \btxflush{number}
-            \setmode{btx:apa:comma}
+        \btxcomma
+    }
+    \btxdoif {volume} {
+        \resetmode{btx:apa:editionset-empty}
+        \btxoneorrange {volume} {
+            \btxlabeltext{apa:Volume}
+        } {
+            \btxlabeltext{apa:Volumes}
         }
-        \btxdoif {pages} {
-            \doifmode {btx:apa:comma}
-                {\btxcomma}
-            \btxoneorrange {pages} {
-                \btxlabeltext{apa:p}
-            } {
-                \btxlabeltext{apa:pp}
-            }
-            \btxspace
-            \btxflush{pages}
+        \btxspace
+        \btxflush{volume}
+        \btxcomma
+    }
+    \btxdoif {number} {
+        \resetmode{btx:apa:editionset-empty}
+        \btxlabeltext{apa:number}
+        \btxspace
+        \btxflush{number}
+        \btxcomma
+    }
+    \btxdoif {edition} {
+        \resetmode{btx:apa:editionset-empty}
+        \btxflush{edition}
+        \btxspace
+        \btxlabeltext{apa:edition}
+        \btxcomma
+    }
+    \btxdoif {pages} {
+        \resetmode{btx:apa:editionset-empty}
+        \btxoneorrange {pages} {
+            \btxlabeltext{apa:page}
+        } {
+            \btxlabeltext{apa:pages}
         }
+        \btxnbsp
+        \btxflush{pages}
+        \btxcomma
+    }
+    \removeunwantedspaces
+    \removepunctuation
+    \doifnotmode {btx:apa:editionset-empty} {
         \btxrightparenthesisperiod
-    } {
-        \doif {\currentbtxcategory} {techreport} {
-            \btxleftparenthesis
-            \btxlabeltext{apa:technicalreport}
-            \btxrightparenthesisperiod
-        }
     }
 \stoptexdefinition
 
-\starttexdefinition btx:apa:journal-volumeset
+\starttexdefinition btx:apa:journal-volume-number-pages
+    % this could be simplified!
     \btxdoif {journal} {
         \btxspace
-        % expandedjournal abbreviatedjournal
-        \texdefinition{btx:apa:italic}{expandedjournal -> journal}
-        % A newspaper may not have a volume but may have a number!
+        \btxstartstyleandcolor[apa:list:journal]
+            \btxusecommand[apa:list:journal] {
+                \btxflush{journal}
+            }
+        \btxstopstyleandcolor
         \btxdoif {volume} {
             \btxcomma
-            \doif {\btxfoundname{volume}} {volume} {
-                \texdefinition{btx:apa:italic}{volume}
-            }
+            \btxstartstyleandcolor[apa:list:journal]
+                \btxflush{volume}
+            \btxstopstyleandcolor
             \btxdoifnot {number} {
                 \btxdoifelse {pages}
                     {\btxcomma}
@@ -525,11 +957,11 @@
             }
             \doif {\currentbtxcategory} {newspaper} {
                 \btxoneorrange {pages} {
-                    \btxlabeltext{apa:p}
+                    \btxlabeltext{apa:page}
                 } {
-                    \btxlabeltext{apa:pp}
+                    \btxlabeltext{apa:pages}
                 }
-                \btxspace
+                \btxnbsp
             }
             \btxflush{pages}
             \btxperiod
@@ -556,6 +988,32 @@
     }
 \stoptexdefinition
 
+\starttexdefinition btx:apa:wherefrom-publisher
+    \btxdoifelse {address} {
+        \btxflush{address}
+        \btxdoif {country} {
+            \btxcomma
+            \btxflush{country}
+        }
+        \btxcolon
+    } {
+        \btxdoif {country} {
+            \btxflush{country}
+            \btxcolon
+        }
+    }
+    \doifelse {\btxfoundname{author}} {\btxfoundname{publisher}} {
+        \btxlabeltext{apa:Author}
+    } {
+        \btxdoifelse {publisher} {
+            \btxflush{publisher}
+        } {
+            \btxlabeltext{apa:Author}
+        }
+    }
+    \btxperiod
+\stoptexdefinition
+
 \definebreakpoints[doi]
 \definebreakpoint [doi][:][nleft=3,type=1]
 \definebreakpoint [doi][/][nleft=3,type=1]
@@ -569,15 +1027,15 @@
     \btxspace
     \begingroup
         \setbreakpoints[doi]
-        \btxdoifelseinteractive {url} {
+        \ifconditional\btxinteractive
             \goto {
                 \btxflush{url}
             } [
                 url(\btxflush{url})
             ]
-        } {
+        \else
             \btxflush{url}
-        }
+        \fi
     \endgroup
 \stoptexdefinition
 
@@ -586,15 +1044,15 @@
     \btxspace
     \begingroup
         \setbreakpoints[doi]
-        \btxdoifelseinteractive {doi} {
+        \ifconditional\btxinteractive
             \goto {
                 doi:\btxflush{doi}
             } [
                 url(http://dx.doi.org/\btxflush{doi})
             ]
-        } {
+        \else
             doi:\btxflush{doi}
-        }
+        \fi
     \endgroup
 \stoptexdefinition
 
@@ -603,148 +1061,78 @@
     \btxdoif {isbn} {
         \btxleftparenthesis
         \WORD{\btxfoundname{isbn}}:\btxspace
+        \setbreakpoints[doi]
         \btxflush{isbn}
         \btxrightparenthesis
     }
 \stoptexdefinition
 
 \starttexdefinition btx:apa:note
-    % grouping could indeed be useful for note.
     \btxdoif {note} {
         \btxleftparenthesis
-        {\btxflush{note}}
+        \btxflush{note}
         \btxrightparenthesis
     }
 \stoptexdefinition
 
-\starttexdefinition btx:apa:url-note-doi
+\starttexdefinition btx:apa:url-doi-note
     \doif {\btxfoundname{doi}} {url} {
         \texdefinition{btx:apa:url}
     }
     \texdefinition{btx:apa:isbn}
-    \texdefinition{btx:apa:note}
     \doif {\btxfoundname{doi}} {doi} {
         \texdefinition{btx:apa:doi}
     }
+    \texdefinition{btx:apa:note}
     \removeunwantedspaces
 \stoptexdefinition
 
-\starttexdefinition btx:apa:doifelse-publisher-or-author-or-editor #author #if #else
-    \btxdoifelse {publisher} {
-        \btxdoifelse {#author} {
-            #if
-        } {
-            \btxdoifelse {editor} {
-                #if
-            } {
-                #else
-            }
-        }
-    } {
-       \btxdoifelse {#author} {
-           #if
-       } {
-           \doifelse {editor} {
-               #if
-           } {
-               #else
-           }
-       }
-    }
-\stoptexdefinition
-
-% #author is author, editor, organization, howpublished or assignee
-\starttexdefinition btx:apa:wherefrom-publisher-author-is- #author
-    \btxdoifelse {country} {
-        \btxspace
-        \btxdoif {address} {
-            \btxflush{address}
-            \btxcomma
-        }
-        \btxflush{country}
-        \doifelse {#author} {howpublished}
-            {\btxdoifelse {howpublished}}
-            {\texdefinition{btx:apa:doifelse-publisher-or-author-or-editor}{#author}}
-                {\btxcolon} {\btxperiod}
-    } {
-        \btxdoifelse {address} {
-            \btxspace
-            \btxflush{address}
-            \doifelse {#author} {howpublished}
-                {\btxdoifelse {howpublished}}
-                {\texdefinition{btx:apa:doifelse-publisher-or-author-or-editor}{#author}}
-                    {\btxcolon} {\btxperiod}
-        } {
-            \doifelse {#author} {howpublished}
-                {\btxdoifelse {howpublished}}
-                {\texdefinition{btx:apa:doifelse-publisher-or-author-or-editor}{#author}}
-                {\btxspace} {}
-        }
-    }
-    \doifelse {#author} {howpublished} {
-        \btxdoif {howpublished} {
-            \btxflush{howpublished}
-            \btxperiod
-        }
-    } {
-        \btxdoifelse {publisher} {
-             \btxdoifelse {#author} {
-                 \btxflush{publisher}
-                 \btxperiod
-             } {
-                 \btxdoif {editor} {
-                     \btxflush{publisher}
-                     \btxperiod
-                 }
-             }
-        } {
-            \btxdoifelse {#author} {
-                \btxlabeltext{apa:Author}
-                \btxperiod
-            } {
-                \btxdoif {editor} {
-                    \btxlabeltext{apa:Author}
-                    \btxperiod
-                }
-            }
-        }
-    }
-\stoptexdefinition
-
-% Then by category
+% Then setups, by category
 
 % An article from a journal
 % Required fields: author or editor or title, journal, (year).
 % Optional fields: volume, number, pages, type, doi, url, note.
 % Note that bibtex (and tools) do not include editor (e.g. special issue or section)
 
-\startsetups btx:apa:article
+\startsetups btx:apa:list:article
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:journal-volumeset}
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:title-if-not-placed}
+    \texdefinition{btx:apa:journal-volume-number-pages}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
 % An article from a magazine.
 % Required fields: author or title, journal, (year).
-% Optional fields: volume, number, pages, type, month, day, doi, url, note.
+% Optional fields: number, pages, type, month, day, doi, url, note.
 
-\startsetups btx:apa:magazine
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:journal-volumeset}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:magazine
+    \fastsetup{btx:apa:list:article}
 \stopsetups
 
 % An article from a newspaper.
 % Required fields: author or title, journal, (year).
 % Optional fields: volume, number, pages, type, month, day, doi, url, note.
 
-\startsetups btx:apa:newspaper
+\startsetups btx:apa:list:newspaper
+    \fastsetup{btx:apa:list:article}
+\stopsetups
+
+% A complete issue of a periodical, such as a special issue of a journal.
+% Required fields: title, year
+% Optional fields: editor, publisher, subtitle, series, volume, number, month, organization, doi, url, issn, note
+
+\startsetups btx:apa:list:periodical
+    \fastsetup{btx:apa:list:article} % needs to be tuned...
+\stopsetups
+
+% National and international standards issued by a standards body
+% Required fields: author, institution, or organization, year, title
+% Optional fields: subtitle, doi, url, note
+
+\startsetups btx:apa:list:standard
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:journal-volumeset}
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:title-if-not-placed}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
 % A book with an explicit publisher.
@@ -754,47 +1142,39 @@
 
 % todo: series?
 
-\startsetups btx:apa:book
+\startsetups btx:apa:list:book
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
+    \texdefinition{btx:apa:title-if-not-placed}
     \texdefinition{btx:apa:editionset}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{author}
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:wherefrom-publisher}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
+% There is some debate about how inbook should differ from incollection
+
 % A part of a book, which may be a chapter (or section or whatever) and/or a range of pages.
+% (note that inbook is handled differently by bibtex and biblatex)
 % Required fields: author or editor, title, chapter and/or pages, publisher, year.
 % Optional fields: volume or number, series, type, address, edition, month, note.
-% APA ignores: month
-
-% todo: series?
+% We add optional: booktitle.
+% APA ignores: chapter, month
 
-\startsetups btx:apa:inbook
+\startsetups btx:apa:list:inbook
     \texdefinition{btx:apa:authoryear}
-    \btxdoif {chapter} {
-        \btxflush{Word -> chapter}
-        \btxspace
-    }
-    \texdefinition{btx:apa:editor-in-}{title}
+    \texdefinition{btx:apa:title-if-not-placed}
+    \texdefinition{btx:apa:editor-in}
     \texdefinition{btx:apa:editionset}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{author}
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:wherefrom-publisher}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
 % A part of a book having its own title.
 % Required fields: author, title, booktitle, publisher, year.
 % Optional fields: editor, volume or number, series, type, chapter, pages, address, edition, month, note.
-% APA ignores: month
+% APA ignores: chapter, month
 
-% todo: series?
-
-\startsetups btx:apa:incollection
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:editor-in-}{booktitle}
-    \texdefinition{btx:apa:editionset}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{author}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:incollection
+    \fastsetup{btx:apa:list:inbook}
 \stopsetups
 
 % The proceedings of a conference.
@@ -802,59 +1182,46 @@
 % Optional fields: editor, volume or number, series, address, month, organization, publisher, note.
 % todo: series?
 
-\startsetups btx:apa:proceedings
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:editionset}
-    \btxdoifelse {editor} {
-        \btxdoif {organization} {
-            \btxspace
-            \btxflush{organization}
-            \btxcomma
-        }
-        \texdefinition{btx:apa:wherefrom-publisher-author-is-}{editor}
-    } {
-        \texdefinition{btx:apa:wherefrom-publisher-author-is-}{organization}
-    }
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:proceedings
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % An article in a conference proceedings.
 % Required fields: author, title, booktitle, year.
 % Optional fields: editor, volume or number, series, pages, address, month, organization, publisher, note.
-% todo: series?
 
-\startsetups btx:apa:inproceedings
+\startsetups btx:apa:list:inproceedings
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{}
-    \texdefinition{btx:apa:editor-in-}{booktitle}
+    \texdefinition{btx:apa:title-if-not-placed}
+    \texdefinition{btx:apa:editor-in}
     \texdefinition{btx:apa:editionset}
     \btxdoif {organization} {
         \btxspace
         \btxflush{organization}
         \btxcomma
     }
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{author}
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:wherefrom-publisher}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
-\startsetups btx:apa:conference
-    \fastsetup{btx:apa:inproceedings}
+\startsetups btx:apa:list:conference
+    \fastsetup{btx:apa:list:inproceedings}
 \stopsetups
 
 % A thesis.
 % Required fields: author, title, school, year.
 % Optional fields: type, address, month, note.
 
-\startsetups btx:apa:thesis
-    \setmode{btx:apa:thesis}
+\startsetups btx:apa:list:thesis
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
+    \texdefinition{btx:apa:title-if-not-placed}
     \btxleftparenthesis
     \btxdoifelse {type} {
-        \btxflush{Word -> type}
+        \btxusecommand[apa:list:type] {
+            \btxflush{type}
+        }
     } {
-        \Word{\btxlabeltext{apa:\currentbtxcategory}}
+        \btxlabeltext{apa:\currentbtxcategory}
     }
     \btxrightparenthesis
     \btxdoif {school} {
@@ -874,60 +1241,47 @@
         }
     }
     \btxperiod
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
-\startsetups btx:apa:phdthesis
-    \fastsetup{btx:apa:thesis}
+\startsetups btx:apa:list:phdthesis
+    \fastsetup{btx:apa:list:thesis}
 \stopsetups
 
-\startsetups btx:apa:mastersthesis
-    \fastsetup{btx:apa:thesis}
+\startsetups btx:apa:list:mastersthesis
+    \fastsetup{btx:apa:list:thesis}
 \stopsetups
 
 % A work that is printed and bound, but without a named publisher or sponsoring institution.
 % Required field: title.
 % Optional fields: author, howpublished, address, month, year, note.
 
-\startsetups btx:apa:booklet
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{howpublished}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:booklet
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % Technical documentation.
 % Required field: title.
 % Optional fields: author, organization, address, edition, month, year, note.
 
-\startsetups btx:apa:manual
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
-    \texdefinition{btx:apa:editionset}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{organization}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:manual
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % A report published by a school or other institution, usually numbered within a series.
 % Required fields: author, title, institution, year.
 % Optional fields: type, number, address, month, note.
 
-\startsetups btx:apa:techreport
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
-    \texdefinition{btx:apa:editionset}
-    \texdefinition{btx:apa:wherefrom-publisher-author-is-}{institution}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:techreport
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % A document having an author and title, but not formally published.
 % Required fields: author, title, note.
 % Optional fields: month, year.
 
-\startsetups btx:apa:unpublished
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:unpublished
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % A patent. Note that this category was not defined with BIBTEX. Below from JabRef:
@@ -937,9 +1291,9 @@
 
 % todo: yearfiled, monthfiled, dayfiled
 
-\startsetups btx:apa:patent
+\startsetups btx:apa:list:patent
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
+    \texdefinition{btx:apa:title-if-not-placed}
     \begingroup
         \it
         \btxdoif {nationality} {
@@ -950,41 +1304,14 @@
         \btxlabeltext{apa:patent}
         \btxdoif {number} {
             \btxspace
-            \btxlabeltext{apa:Number}
+            \btxlabeltext{apa:number}
             \btxspace
             \btxflush{number}
         }
         \btxperiod
         \italiccorrection
     \endgroup
-    \btxdoifelse {author} {
-        \btxdoifelse {country} {
-            \btxspace
-            \btxdoif {address} {
-                \btxflush{address}
-                \btxcomma
-            }
-            \btxflush{country}
-            \btxdoifelse {assignee}
-                {\btxcolon} {\btxperiod}
-        } {
-            \btxdoifelse {address} {
-                \btxspace
-                \btxflush{address}
-                \btxdoifelse {assignee}
-                    {\btxcolon} {\btxperiod}
-            } {
-                \btxdoifelse {assignee}
-                    {\btxspace} {}
-            }
-        }
-        \btxdoif {assignee} {
-            \btxflush{assignee}
-            \btxperiod
-        }
-    } {
-        \texdefinition{btx:apa:wherefrom-publisher-author-is-}{assignee}
-    }
+    \texdefinition{btx:apa:wherefrom-publisher}
     \texdefinition{btx:apa:url}
     \texdefinition{btx:apa:note}
 \stopsetups
@@ -996,9 +1323,9 @@
 
 % Like Misc below but includes organization.
 
-\startsetups btx:apa:electronic
+\startsetups btx:apa:list:electronic
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
+    \texdefinition{btx:apa:title-if-not-placed}
     \btxdoif {organization} {
         \btxspace
         \btxflush{organization}
@@ -1009,37 +1336,35 @@
         \btxflush{howpublished}
         \btxperiod
     }
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
 % Other. Note that this category was not defined with BIBTEX. Below from JabRef:
 % Required fields: author or title, year
 % Optional fields: note, doi, url
 
-\startsetups btx:apa:other
-    \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
-    \texdefinition{btx:apa:url-note-doi}
+\startsetups btx:apa:list:other
+    \fastsetup{btx:apa:list:book}
 \stopsetups
 
 % Use this type when nothing else fits.
 % Required fields: none.
 % Optional fields: author, title, howpublished, month, year, note.
 
-\startsetups btx:apa:misc
+\startsetups btx:apa:list:misc
     \texdefinition{btx:apa:authoryear}
-    \texdefinition{btx:apa:title-if-not-placed}{it}
+    \texdefinition{btx:apa:title-if-not-placed}
     \btxdoif {howpublished} {
         \btxspace
         \btxflush{howpublished}
         \btxperiod
     }
-    \texdefinition{btx:apa:url-note-doi}
+    \texdefinition{btx:apa:url-doi-note}
 \stopsetups
 
 % If all else fails to match:
 
-\startsetups btx:apa:literal
+\startsetups btx:apa:list:literal
     %\btxleftparenthesis
     \removeunwantedspaces(
     \btxflush{key}
@@ -1049,14 +1374,35 @@
     }
 \stopsetups
 
-%D Experiment:
-
-\startsetups btx:apa:lefttext
-    \currentbtxlefttext
-\stopsetups
-
-\startsetups btx:apa:righttext
-    \currentbtxrighttext
-\stopsetups
+% HH: an example of setting up translations using a sub rendering. Keep it here
+% till we find another spot as otherwise I forget about it and I don't want to
+% waste hours reinventing a wheel when something like this is needed.
+%
+% \definebtx
+%   [apa:cite:title:translated]
+%   [apa:cite:title]
+%   [left=\btxleftbracket,
+%    right=\btxrightbracket,
+%    style=\v!bolditalic]
+%
+% \startsetups btx:apa:cite:title
+%     % need to add concat, etc.
+%     \btxcitereference
+%     \currentbtxfirst
+%     \doifmode {btx:apa:translatedtitles} {
+%         \ifx\currentbtxlanguage\empty
+%             % no need for an extra
+%         \else\ifx\mainbtxlanguage\currentbtxlanguage
+%             % no need for an extra
+%         \else
+%             \btxdoif {title:\mainbtxlanguage} {
+%                 \btxstartciterendering[title:translated]
+%                     \language[\mainbtxlanguage]
+%                     \btxflush{title:\mainbtxlanguage}
+%                 \btxstopciterendering
+%             }
+%         \fi\fi
+%     }
+% \stopsetups
 
 \stopbtxrenderingdefinitions
diff --git a/tex/context/base/publ-imp-aps.mkvi b/tex/context/base/publ-imp-aps.mkvi
index bd07a9a55..dde6a289a 100644
--- a/tex/context/base/publ-imp-aps.mkvi
+++ b/tex/context/base/publ-imp-aps.mkvi
@@ -1,3 +1,7 @@
+\endinput
+
+% todo
+
 %D \module
 %D   [       file=publ-imp-aps,
 %D        version=2013.12.12,
@@ -10,8 +14,6 @@
 %C This module is part of the \CONTEXT\ macro||package and is therefore copyrighted
 %D by \PRAGMA. See mreadme.pdf for details.
 
-% \loadbtxdefinitionfile[def]
-
 \startbtxrenderingdefinitions[aps]
 
 %D Reference:
@@ -31,7 +33,12 @@
 
 % set all APS compliant values (may be redundant but we do not count on defaults.)
 
-\setupbtxlistvariant
+\setupbtxrendering
+  [sorttype=, % num ?
+   numbering=yes]
+
+\definebtxlistvariant
+  [aps]
   [\c!namesep={,\space},
    \c!lastnamesep={,\space and\space},
    \c!finalnamesep={,\space and\space},
@@ -123,11 +130,6 @@
     \c!finalnamesep={\space\btxlabeltext{\currentbtxspecification:and}\space}, % no comma!
     \c!authorconversion=\v!name]
 
-\setupbtxrendering
-    [sorttype=, % num ?
-     numbering=yes]
-
-% Should the following be loaded by default?
 
 %D In order to be able to get journals expanded (or normalized or abbreviated) you need
 %D to load a list:
@@ -513,15 +515,15 @@
     \btxspace
     \begingroup
         \setbreakpoints[doi]
-        \btxdoifelseinteractive {url} {
+        \ifconditional\btxinteractive
             \goto {
                 \btxflush{url}
             } [
                 url(\btxflush{url})
             ]
-        } {
+        \else
             \btxflush{url}
-        }
+        \fi
     \endgroup
 \stoptexdefinition
 
@@ -530,15 +532,15 @@
     \btxspace
     \begingroup
         \setbreakpoints[doi]
-        \btxdoifelseinteractive {doi} {
+        \ifconditional\btxinteractive
             \goto {
                 doi:\btxflush{doi}
             } [
                 url(http://dx.doi.org/\btxflush{doi})
             ]
-        } {
+        \else
             doi:\btxflush{doi}
-        }
+        \fi
     \endgroup
 \stoptexdefinition
 
diff --git a/tex/context/base/publ-imp-author.mkvi b/tex/context/base/publ-imp-author.mkvi
index d852e325e..6547573cf 100644
--- a/tex/context/base/publ-imp-author.mkvi
+++ b/tex/context/base/publ-imp-author.mkvi
@@ -1,3 +1,5 @@
+% TODO: MAKE default
+
 %D \module
 %D   [       file=publ-imp-author,
 %D        version=2014.06.23,
@@ -13,17 +15,6 @@
 
 \unprotect
 
-% We can do a better check for pre-sep-post at the lua end but by keeping it at the
-% tex end users can easier mess with it. So, we just assume sane names.
-%
-% maybe cite will just inherit from list (only \current.. alias)
-%
-% \startsetups \s!btx:\s!cite:\s!author:normal
-%     \fastsetup{\s!btx:\s!list:\s!author:normal}
-% \stopsetups
-
-% You can adapt these setups to your liking, for instance as:
-
 % these can be used instead of the macros and they accept manipulator prefixes
 %
 % \currentbtxinitials   : \btxauthorfield{initials}
@@ -32,24 +23,29 @@
 % \currentbtxsurnames   : \btxauthorfield{surnames}
 % \currentbtxjuniors    : \btxauthorfield{juniors}
 
+\starttexdefinition \s!btx:\s!cite:\s!author:\s!de
+    \ifx\currentbtxlanguage\s!de
+      \setmode{\s!btx:\s!de}
+    \fi
+\stoptexdefinition
+
 \startsetups \s!btx:\s!cite:\s!author:concat
     \ifcase\currentbtxoverflow
         \ifcase\currentbtxconcat \or \or
-            \btxcitevariantparameter\c!namesep
+            \btxparameter\c!namesep
         \or
-            \btxcitevariantparameter\c!lastnamesep
+            \btxparameter\c!lastnamesep
         \or
-            \btxcitevariantparameter\c!finalnamesep
+            \btxparameter\c!finalnamesep
         \fi
     \else
-        % \btxcitevariantparameter\c!namesep
+        % \btxparameter\c!namesep
     \fi
 \stopsetups
 
 \startsetups \s!btx:\s!cite:\s!author:others
     \ifcase\currentbtxoverflow \else
-        \btxspace
-        \btxcitevariantparameter\c!otherstext
+        \btxparameter\c!otherstext
     \fi
 \stopsetups
 
@@ -57,18 +53,18 @@
     \fastsetup{\s!btx:\s!cite:\s!author:concat}
     \ifx\currentbtxfirstnames\empty \else
         \currentbtxfirstnames
-        \btxcitevariantparameter\c!firstnamesep
+        \btxparameter\c!firstnamesep
     \fi
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
         \ifx\currentbtxsurnames\empty \else
-            \btxcitevariantparameter\c!vonsep
+            \btxparameter\c!vonsep
         \fi
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxcitevariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
@@ -79,18 +75,18 @@
     \fastsetup{\s!btx:\s!cite:\s!author:concat}
     \ifx\currentbtxinitials\empty \else
         \currentbtxinitials
-        \btxcitevariantparameter\c!initialsep
+        \btxparameter\c!initialsep
     \fi
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
         \ifx\currentbtxsurnames\empty \else
-            \btxcitevariantparameter\c!vonsep
+            \btxparameter\c!vonsep
         \fi
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxcitevariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
@@ -100,58 +96,77 @@
 \startsetups \s!btx:\s!cite:\s!author:inverted
     \fastsetup{\s!btx:\s!cite:\s!author:concat}
     \ifx\currentbtxvons\empty \else
-        \currentbtxvons
-        \btxcitevariantparameter\c!vonsep
+        \texdefinition{\s!btx:\s!cite:\s!author:\s!de}
+        \doifmode {\s!btx:\s!de} {
+            \currentbtxvons
+            \btxparameter\c!vonsep
+        }
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxcitevariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
     \ifx\currentbtxfirstnames\empty
         % firstnames are optional
     \else
-        \btxcitevariantparameter\c!surnamefirstnamesep
+        \btxparameter\c!surnamefirstnamesep
         \currentbtxfirstnames
     \fi
+    \ifx\currentbtxvons\empty \else
+        \doifnotmode {\s!btx:\s!de} {
+            \btxparameter\c!vonsep
+            \currentbtxvons
+        }
+    \fi
     \fastsetup{\s!btx:\s!cite:\s!author:others}
 \stopsetups
 
 \startsetups \s!btx:\s!cite:\s!author:invertedshort
     \fastsetup{\s!btx:\s!cite:\s!author:concat}
     \ifx\currentbtxvons\empty \else
-        \currentbtxvons
-        \btxcitevariantparameter\c!vonsep
+        \texdefinition{\s!btx:\s!cite:\s!author:\s!de}
+        \doifnotmode {\s!btx:\s!de} {
+            \currentbtxvons
+            \btxparameter\c!vonsep
+        }
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxcitevariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
     \ifx\currentbtxinitials\empty
         % initials are optional
     \else
-        \btxcitevariantparameter\c!surnameinitialsep
+        \btxparameter\c!surnameinitialsep
         \currentbtxinitials
     \fi
+    \ifx\currentbtxvons\empty \else
+        \doifmode {\s!btx:\s!de} {
+            \btxparameter\c!vonsep
+            \currentbtxvons
+        }
+    \fi
     \fastsetup{\s!btx:\s!cite:\s!author:others}
 \stopsetups
 
 \startsetups \s!btx:\s!cite:\s!author:name
     \fastsetup{\s!btx:\s!cite:\s!author:concat}
+    % is this treated differently in german?
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
-        \btxcitevariantparameter\c!vonsep
+        \btxparameter\c!vonsep
     \fi
     \currentbtxsurnames
     \ifcase\currentbtxauthorstate \else
         % potential clash of names so we force initials
         \ifx\currentbtxinitials\empty \else
-            \btxcitevariantparameter\c!surnameinitialsep
+            \btxparameter\c!surnameinitialsep
             \currentbtxinitials
         \fi
     \fi
@@ -163,20 +178,20 @@
 \startsetups \s!btx:\s!list:\s!author:concat
     \ifcase\currentbtxoverflow
         \ifcase\currentbtxconcat \or \or
-            \btxlistvariantparameter\c!namesep
+            \btxparameter\c!namesep
         \or
-            \btxlistvariantparameter\c!lastnamesep
+            \btxparameter\c!lastnamesep
         \or
-            \btxlistvariantparameter\c!finalnamesep
+            \btxparameter\c!finalnamesep
         \fi
     \else
-        \btxlistvariantparameter\c!namesep
+        \btxparameter\c!namesep
     \fi
 \stopsetups
 
 \startsetups \s!btx:\s!list:\s!author:others
     \ifcase\currentbtxoverflow \else
-        \btxlistvariantparameter\c!otherstext
+        \btxparameter\c!otherstext
     \fi
 \stopsetups
 
@@ -184,18 +199,18 @@
     \fastsetup{\s!btx:\s!list:\s!author:concat}
     \ifx\currentbtxfirstnames\empty \else
         \currentbtxfirstnames
-        \btxlistvariantparameter\c!firstnamesep
+        \btxparameter\c!firstnamesep
     \fi
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
         \ifx\currentbtxsurnames\empty \else
-            \btxlistvariantparameter\c!vonsep
+            \btxparameter\c!vonsep
         \fi
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxlistvariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
@@ -206,18 +221,18 @@
     \fastsetup{\s!btx:\s!list:\s!author:concat}
     \ifx\currentbtxinitials\empty \else
         \currentbtxinitials
-        \btxlistvariantparameter\c!initialsep
+        \btxparameter\c!initialsep
     \fi
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
         \ifx\currentbtxsurnames\empty \else
-            \btxlistvariantparameter\c!vonsep
+            \btxparameter\c!vonsep
         \fi
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxlistvariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
@@ -227,52 +242,71 @@
 \startsetups \s!btx:\s!list:\s!author:inverted
     \fastsetup{\s!btx:\s!list:\s!author:concat}
     \ifx\currentbtxvons\empty \else
-        \currentbtxvons
-        \btxlistvariantparameter\c!vonsep
+        \texdefinition{\s!btx:\s!cite:\s!author:\s!de}
+        \doifnotmode {\s!btx:\s!de} {
+            \currentbtxvons
+            \btxparameter\c!vonsep
+        }
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxlistvariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
     \ifx\currentbtxfirstnames\empty
         % firstnames are optional
     \else
-        \btxlistvariantparameter\c!surnamefirstnamesep
+        \btxparameter\c!surnamefirstnamesep
         \currentbtxfirstnames
     \fi
+    \ifx\currentbtxvons\empty \else
+        \doifmode {\s!btx:\s!de} {
+            \btxparameter\c!vonsep
+            \currentbtxvons
+        }
+    \fi
     \fastsetup{\s!btx:\s!list:\s!author:others}
 \stopsetups
 
 \startsetups \s!btx:\s!list:\s!author:invertedshort
     \fastsetup{\s!btx:\s!list:\s!author:concat}
     \ifx\currentbtxvons\empty \else
-        \currentbtxvons
-        \btxlistvariantparameter\c!vonsep
+        \texdefinition{\s!btx:\s!cite:\s!author:\s!de}
+        \doifnotmode {\s!btx:\s!de} {
+            \currentbtxvons
+            \btxparameter\c!vonsep
+        }
     \fi
     \ifx\currentbtxsurnames\empty \else
         \currentbtxsurnames
         \ifx\currentbtxjuniors\empty \else
-            \btxlistvariantparameter\c!juniorsep
+            \btxparameter\c!juniorsep
             \currentbtxjuniors
         \fi
     \fi
     \ifx\currentbtxinitials\empty
         % initials are optional
     \else
-        \btxlistvariantparameter\c!surnameinitialsep
+        \btxparameter\c!surnameinitialsep
         \currentbtxinitials
     \fi
+    \ifx\currentbtxvons\empty \else
+        \doifmode {\s!btx:\s!de} {
+            \btxparameter\c!vonsep
+            \currentbtxvons
+        }
+    \fi
     \fastsetup{\s!btx:\s!list:\s!author:others}
 \stopsetups
 
 \startsetups \s!btx:\s!list:\s!author:name
     \fastsetup{\s!btx:\s!list:\s!author:concat}
+    % is this treated differently in german?
     \ifx\currentbtxvons\empty \else
         \currentbtxvons
-        \btxlistvariantparameter\c!vonsep
+        \btxparameter\c!vonsep
     \fi
     \currentbtxsurnames
     \fastsetup{\s!btx:\s!list:\s!author:others}
diff --git a/tex/context/base/publ-imp-cite.mkvi b/tex/context/base/publ-imp-cite.mkvi
index b49e8339d..869384969 100644
--- a/tex/context/base/publ-imp-cite.mkvi
+++ b/tex/context/base/publ-imp-cite.mkvi
@@ -13,11 +13,6 @@
 
 \unprotect
 
-\startsetups \s!btx:\s!cite:nocite
-    \dontleavehmode
-    \btxcitereference
-\stopsetups
-
 \starttexdefinition btx:cite:inject #content
     \ifconditional\btxinteractive
         \ifx\currentbtxinternal\empty
@@ -43,103 +38,117 @@
 
 % The null case:
 
-\startsetups \s!btx:\s!cite:none
+\startsetups btx:cite:none
+    \btxcitereference
     % dummy
 \stopsetups
 
-% This saves keying:
-
-\startsetups [\s!btx:\s!cite:\s!unknown]
-    \begingroup
-        \showmessage\m!publications{13}{\currentbtxcitevariant,\currentbtxtag,\currentbtxdataset}
-        \tttf
-        <\currentbtxcitevariant:\currentbtxtag>
-    \endgroup
-\stopsetups
-
-\startsetups \s!btx:\s!cite:common:normal
-    \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
-    \else\ifx\currentbtxsecond\empty
-        \btxcitereference
-        \currentbtxfirst
-        \ifx\currentbtxthird\empty \else
-            \currentbtxthird
-        \fi
-    \else
-        \btxcitereference
-        \currentbtxfirst
-        \btxcitevariantparameter\v!inbetween
-        \currentbtxsecond
-        \ifx\currentbtxthird\empty \else
-            \currentbtxthird
-        \fi
-    \fi\fi
+\startsetups btx:cite:nocite
+    \dontleavehmode
+    \btxcitereference
 \stopsetups
 
-\startsetups \s!btx:\s!cite:common:range
-    \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
-    \else\ifx\currentbtxsecond\empty
-        \btxcitereference
-        \currentbtxfirst
-        \ifx\currentbtxthird\empty \else
-            \currentbtxthird
-        \fi
-    \else
+\startsetups btx:cite:unknown
+    \begingroup
         \btxcitereference
         \currentbtxfirst
-        \btxcitevariantparameter\c!range
-        \currentbtxsecond
-        \ifx\currentbtxthird\empty \else
-            \currentbtxthird
-        \fi
-    \fi\fi
+    \endgroup
 \stopsetups
 
-\startsetups \s!btx:\s!cite:concat
+\startsetups btx:cite:empty
+    \btxcitereference
+    <empty>
+\stopsetups
+
+% \startsetups btx:cite:normal
+%     \ifx\currentbtxfirst\empty
+%         \fastsetup{\s!btx:\s!cite:\s!empty}
+%     \else\ifx\currentbtxsecond\empty
+%         \btxcitereference
+%         \currentbtxfirst
+%         \ifx\currentbtxthird\empty \else
+%             \currentbtxthird
+%         \fi
+%     \else
+%         \btxcitereference
+%         \currentbtxfirst
+%         \btxparameter\v!inbetween
+%         \currentbtxsecond
+%         \ifx\currentbtxthird\empty \else
+%             \currentbtxthird
+%         \fi
+%     \fi\fi
+% \stopsetups
+
+%\startsetups btx:cite:range
+%    \ifx\currentbtxfirst\empty
+%        \fastsetup{\s!btx:\s!cite:\s!empty}
+%    \else\ifx\currentbtxsecond\empty
+%        \btxcitereference
+%        \currentbtxfirst
+%        \ifx\currentbtxthird\empty \else
+%            \currentbtxthird
+%        \fi
+%    \else
+%        \btxcitereference
+%        \currentbtxfirst
+%        \btxparameter\c!range
+%        \currentbtxsecond
+%        \ifx\currentbtxthird\empty \else
+%            \currentbtxthird
+%        \fi
+%    \fi\fi
+%\stopsetups
+
+\starttexdefinition btx:cite:concat
     \ifcase\currentbtxconcat \or \or
-        \btxcitevariantparameter\c!pubsep
+        \btxparameter\c!pubsep
     \or
-        \btxcitevariantparameter\c!finalpubsep
+        \btxparameter\c!lastpubsep
     \or
-        \btxcitevariantparameter\c!lastpubsep
+        \btxparameter\c!finalpubsep
     \fi
-\stopsetups
+\stoptexdefinition
 
-\startsetups \s!btx:\s!cite:render:normal
-    \fastsetup{\s!btx:\s!cite:concat}
+\startsetups btx:cite:normal
+    \texdefinition{\s!btx:\s!cite:concat}
     \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
+        \fastsetup{\s!btx:\s!cite:\s!empty}
     \else
-        \texdefinition {btx:cite:inject} {
+        \texdefinition {\s!btx:\s!cite:inject} {
             \btxcitereference
-            \currentbtxfirst
+            \btxusecommand[\currentbtxspecification:cite:\currentbtxcitevariant] {
+                \currentbtxfirst
+            }
         }
         \ifx\currentbtxsecond\empty \else
-            \btxcitevariantparameter\v!inbetween
-            \texdefinition {btx:cite:inject} {
-                \currentbtxsecond
+            \btxparameter\v!inbetween
+            \texdefinition {\s!btx:\s!cite:inject} {
+                \btxusecommand[\currentbtxspecification:cite:\currentbtxcitevariant] {
+                    \currentbtxsecond
+                 }
             }
         \fi
         \ifx\currentbtxthird\empty \else
-            \texdefinition {btx:cite:inject} {
-                \currentbtxthird
+            \texdefinition {\s!btx:\s!cite:inject} {
+                \btxusecommand[\currentbtxspecification:cite:\currentbtxvariant] {
+                    \currentbtxthird
+                 }
             }
         \fi
     \fi
 \stopsetups
 
-\startsetups \s!btx:\s!cite:render:range
-    \fastsetup{\s!btx:\s!cite:concat}
+\startsetups btx:cite:range
+    \texdefinition{\s!btx:\s!cite:concat}
     \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:missing}
+        \fastsetup{\s!btx:\s!cite:\s!empty}
     \else
-        \texdefinition {btx:cite:inject} {
+        \texdefinition {\s!btx:\s!cite:inject} {
             \btxcitereference
             \currentbtxfirst
             \ifx\currentbtxsecond\empty \else
-                \btxcitevariantparameter\c!range
+                \btxparameter\c!range
                 \currentbtxsecond
             \fi
             \ifx\currentbtxthird\empty \else
@@ -149,120 +158,76 @@
     \fi
 \stopsetups
 
-\startsetups \s!btx:\s!cite:render:variant
-    \fastsetup{\s!btx:\s!cite:concat}
-    \fastsetup{\s!btx:\s!cite:render:\currentbtxcitevariant}
+\startsetups btx:cite:listelement
+    \texdefinition{\s!btx:\s!cite:concat}
+    \ifx\currentbtxfirst\empty
+        \fastsetup{\s!btx:\s!cite:\s!empty}
+    \else
+       \texdefinition {\s!btx:\s!cite:inject} {
+           \btxcitereference
+           \currentbtxfirst
+       }
+    \fi
 \stopsetups
 
-\startsetups \s!btx:\s!cite:common:author
+\startsetups btx:cite:author
+    \texdefinition{\s!btx:\s!cite:concat}
     \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
+        \fastsetup{\s!btx:\s!cite:\s!empty}
     \else
-        \texdefinition {btx:cite:inject} {
+        \texdefinition {\s!btx:\s!cite:inject} {
             \btxcitereference
             \currentbtxfirst
          }
     \fi
     \ifx\currentbtxsecond\empty \else
         \relax % keeps a following space
-        \btxcitevariantparameter\v!inbetween
-        \texdefinition {btx:cite:inject} {
+        \btxparameter\v!inbetween
+        \texdefinition {\s!btx:\s!cite:inject} {
             \currentbtxsecond
         }
     \fi
     \ifx\currentbtxthird\empty \else
-        \texdefinition {btx:cite:inject} {
+        \texdefinition {\s!btx:\s!cite:inject} {
             \currentbtxthird
         }
     \fi
 \stopsetups
 
-% one level will be removed
-% yes, isn't there one too many?
-
-\startsetups \s!btx:\s!cite:render:author
-    \fastsetup{\s!btx:\s!cite:common:author}
-\stopsetups
-\startsetups \s!btx:\s!cite:render:authoryear
-    \fastsetup{\s!btx:\s!cite:common:author}
-\stopsetups
-\startsetups \s!btx:\s!cite:render:authoryears
-    \fastsetup{\s!btx:\s!cite:common:author}
-\stopsetups
-\startsetups \s!btx:\s!cite:render:authornum
-    \fastsetup{\s!btx:\s!cite:common:author}
-\stopsetups
-
-\startsetups \s!btx:\s!cite:author:num
-    \fastsetup{\s!btx:\s!cite:render:range}
-\stopsetups
-\startsetups \s!btx:\s!cite:author:year
-    \fastsetup{\s!btx:\s!cite:render:range}
-\stopsetups
-\startsetups \s!btx:\s!cite:author:years
-    \fastsetup{\s!btx:\s!cite:render:range}
-\stopsetups
+% these three are goodies to get something bit are not set up as it makes no
+% sense to have something root for combinations like this (esp not because one
+% gets default anyway
 
-\startsetups \s!btx:\s!cite:author
-    \fastsetup{\s!btx:\s!cite:render:variant}
-\stopsetups
-\startsetups \s!btx:\s!cite:authoryear
-    \fastsetup{\s!btx:\s!cite:render:variant}
-\stopsetups
-\startsetups \s!btx:\s!cite:authoryears
-    \fastsetup{\s!btx:\s!cite:render:variant}
-\stopsetups
-\startsetups \s!btx:\s!cite:authornum
-    \fastsetup{\s!btx:\s!cite:render:variant}
-\stopsetups
-
-\startsetups \s!btx:\s!cite:year
-    \fastsetup{\s!btx:\s!cite:render:range}
-\stopsetups
-\startsetups \s!btx:\s!cite:short
-    \fastsetup{\s!btx:\s!cite:render:normal}
+\startsetups btx:cite:authoryear
+    \fastsetup{btx:cite:author}
 \stopsetups
-\startsetups \s!btx:\s!cite:serial
-    \fastsetup{\s!btx:\s!cite:render:range}
+\startsetups btx:cite:authoryears
+    \fastsetup{btx:cite:author}
 \stopsetups
-\startsetups \s!btx:\s!cite:tag
-    \fastsetup{\s!btx:\s!cite:render:normal}
+\startsetups btx:cite:authornum
+    \fastsetup{btx:cite:author}
 \stopsetups
-\startsetups \s!btx:\s!cite:key
-    \fastsetup{\s!btx:\s!cite:render:normal}
-\stopsetups
-%startsetups \s!btx:\s!cite:doi
-%   \fastsetup{\s!btx:\s!cite:render:normal}
-%stopsetups
-%startsetups \s!btx:\s!cite:url
-%   \fastsetup{\s!btx:\s!cite:render:normal}
-%stopsetups
-\startsetups \s!btx:\s!cite:category
-    \fastsetup{\s!btx:\s!cite:render:normal}
-\stopsetups
-\startsetups \s!btx:\s!cite:type
-    \fastsetup{\s!btx:\s!cite:render:normal}
-\stopsetups
-\startsetups \s!btx:\s!cite:num
-    \fastsetup{\s!btx:\s!cite:render:range}
-\stopsetups
-\startsetups \s!btx:\s!cite:textnum
-    \fastsetup{\s!btx:\s!cite:render:range}
+\startsetups btx:cite:authorref
+    \ifx{\btxparameter\c!alternative}{authoryear}
+        \fastsetup{btx:cite:authoryears}
+    \else\ifx{\btxparameter\c!alternative}{num}
+        \fastsetup{btx:cite:authornum}
+    \else
+        \fastsetup{btx:cite:author}
+    \fi\fi
 \stopsetups
-\startsetups \s!btx:\s!cite:title
-    \fastsetup{\s!btx:\s!cite:render:normal}
+\startsetups btx:cite:num
+    \fastsetup{btx:cite:range}
 \stopsetups
-\startsetups \s!btx:\s!cite:pages
-    \fastsetup{\s!btx:\s!cite:render:range}
+\startsetups btx:cite:year
+    \fastsetup{btx:cite:range}
 \stopsetups
 
-\startsetups \s!btx:\s!cite:page
-    \fastsetup{\s!btx:\s!cite:render:normal}
-\stopsetups
+% the following is kind of specific, but can be used in many renderings
 
-\startsetups \s!btx:\s!cite:doi
+\startsetups btx:cite:url
     \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
+        \fastsetup{\s!btx:\s!cite:\s!empty}
     \else\ifconditional\btxinteractive
         \goto {
             \btxcitereference
@@ -272,12 +237,8 @@
         ]
     \else
         \btxcitereference
-        \hyphenatedurl{doi:\currentbtxfirst}
+        \hyphenatedurl{\doif{\currentbtxcitevariant}{doi}{doi:}\currentbtxfirst}
     \fi\fi
 \stopsetups
 
-\startsetups \s!btx:\s!cite:url
-    \fastsetup{\s!btx:\s!cite:\s!doi}
-\stopsetups
-
 \protect
diff --git a/tex/context/base/publ-imp-commands.mkiv b/tex/context/base/publ-imp-commands.mkvi
index 14e2dbae1..14e2dbae1 100644
--- a/tex/context/base/publ-imp-commands.mkiv
+++ b/tex/context/base/publ-imp-commands.mkvi
diff --git a/tex/context/base/publ-imp-default.lua b/tex/context/base/publ-imp-default.lua
new file mode 100644
index 000000000..61b08f30c
--- /dev/null
+++ b/tex/context/base/publ-imp-default.lua
@@ -0,0 +1,124 @@
+-- For the moment I put this here as example. When writing the publication modules we
+-- explored several approached: pure tex, pure lua, a mix with xml, etc. In the end
+-- each has advantages and drawbacks so we ended up with readable tex plus helpers in
+-- lua. Anyway here is a lua variant of a setup ... it doesn't look nicer. An alternative
+-- can be to build a table with characters but then we need to pass left, right and
+-- other separators so again no real gain.
+
+-- function publications.maybe.default.journal(currentdataset,currenttag)
+--     if publications.okay(currentdataset,currenttag,"journal") then
+--         context.btxspace()
+--         context.startbtxstyle("italic")
+--             commands.btxflush(currentdataset,currenttag,"expandedjournal -> journal")
+--         context.stopbtxstyle()
+--         if publications.okay(currentdataset,currenttag,"volume") then
+--             context.btxspace()
+--             commands.btxflush(currentdataset,currenttag,"volume")
+--             if publications.okay(currentdataset,currenttag,"number") then
+--                 context.ignorespaces()
+--                 context.btxleftparenthesis()
+--                 commands.btxflush(currentdataset,currenttag,"number")
+--                 context.btxrightparenthesis()
+--             end
+--         elseif publications.okay(currentdataset,currenttag,"number") then
+--             context.btxlabeltext("default:number")
+--             context.btxspace()
+--             commands.btxflush(currentdataset,currenttag,"number")
+--         end
+--         if publications.okay(currentdataset,currenttag,"pages") then
+--             context.btxcomma()
+--             commands.btxflush(currentdataset,currenttag,"pages")
+--         end
+--         context.btxcomma()
+--     end
+-- end
+
+return {
+    --
+    -- metadata
+    --
+    name      = "default",
+    version   = "1.00",
+    comment   = "DEFAULT specification",
+    author    = "Alan Braslau and Hans Hagen",
+    copyright = "ConTeXt development team",
+    --
+    -- derived (combinations of) fields (all share the same default set)
+    --
+    virtual = {
+        "authoryear",
+        "authoryears",
+        "authornum",
+        "num",
+        "suffix",
+    },
+    --
+    -- special datatypes
+    --
+    types = {
+        author   = "author",     -- interpreted as name(s)
+        editor   = "author",     -- interpreted as name(s)
+        page     = "pagenumber", -- number or range: f--t -- maybe just range
+        pages    = "pagenumber", -- number or range: f--t -- maybe just range
+        volume   = "range",      -- number or range: f--t
+        number   = "range",      -- number or range: f--t
+        keywords = "keyword",    -- comma|-|separated list
+    },
+    --
+    -- categories with their specific fields
+    --
+    categories = {
+        --
+        -- the following fields are for documentation and testing purposes
+        --
+        ["demo-a"] = {
+            sets     = {
+                author  = { "author", "institution", "organization" },
+            },
+            required = { "author", "title", "year" },
+            optional = { "subtitle" },
+        },
+        ["demo-b"] = {
+            sets     = {
+                authors = { "author", "institution", "organization" },
+            },
+            required = { "authors", "title", "year" },
+            optional = { "subtitle" },
+        },
+        --
+        -- we only provide article and book (maybe a few more later) and we keep it
+        -- real simple. See the apa and aps definitions for more extensive examples
+        --
+        article = {
+            sets = {
+                author = { "author", "editor" },
+            },
+            required = {
+                "author", -- a set
+                "year",
+            },
+            optional = {
+                "title",
+                "keywords",
+                "journal", "volume", "number", "pages",
+            },
+        },
+        book = {
+            sets = {
+                author     = { "author", "editor", },
+                editionset = { "edition", "volume", "number" },
+            },
+            required = {
+                "author", -- a set
+                "title",
+                "year",
+            },
+            optional = {
+                "subtitle",
+                "keywords",
+                "publisher", "address",
+                "editionset",
+            },
+        },
+    },
+}
diff --git a/tex/context/base/publ-imp-default.mkvi b/tex/context/base/publ-imp-default.mkvi
new file mode 100644
index 000000000..e3e032d12
--- /dev/null
+++ b/tex/context/base/publ-imp-default.mkvi
@@ -0,0 +1,597 @@
+%D \module
+%D   [       file=publ-imp-default,
+%D        version=2014.02.06,
+%D          title=Default bibliography style,
+%D       subtitle=Publications,
+%D         author=Alan Braslau and Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is therefore copyrighted
+%D by \PRAGMA. See mreadme.pdf for details.
+
+%D This default style defines only a few categories: book and article.
+%D If you want more, you need to load a more complete style such as \type {apa},
+%D \type {aps}, etc. The default style is used in the manuals that ship with
+%D \CONTEXT. This file is always loaded.
+
+\startbtxrenderingdefinitions[\s!default]
+
+% \definebtx [\s!default:\s!page  ] [\s!page]
+% \definebtx [\s!default:\s!cite  ] [\s!cite]
+% \definebtx [\s!default:\s!list  ] [\s!list]
+% \definebtx [\s!default:\s!author] [\s!author]
+
+\definebtxrendering % no need to set \c!default ! ... also confusing 
+  [\s!default]
+  [\c!specification=\s!default]
+
+\definebtx
+  [\s!default]
+  [\c!namesep={,\space},
+   \c!lastnamesep={\space\btxlabeltext{default:and}\space},
+   \c!finalnamesep={\space\btxlabeltext{default:and}\space},
+   \c!firstnamesep=\space,
+   \c!otherstext={\space\btxlabeltext{default:others}},
+   \c!juniorsep=\space,
+   \c!vonsep=\space,
+   \c!initialsep=\space,
+   \c!surnamesep={,\space},
+   \c!surnameinitialsep={,\space},
+   \c!surnamefirstnamesep={,\space},
+   \c!pubsep={,\space},
+   \c!lastpubsep={,\space\btxlabeltext{default:and}\space},
+   \c!finalpubsep={\space\btxlabeltext{default:and}\space}]
+
+\definebtx
+  [\s!default:\s!list]
+  [\s!default]
+  [%c!journalconversion=\v!normal,
+   \c!monthconversion=\v!number,
+   \c!authorconversion=normalshort]
+
+\definebtx
+  [\s!default:\s!cite]
+  [\s!default:\s!list]
+  [\c!alternative=num,
+   \c!authorconversion=\v!name,
+   \c!sorttype=,
+   \c!compress=\v!no,
+   \c!inbetween=\space,
+   \c!range=\endash,
+   \c!left=,
+   \c!middle=,
+   \c!right=]
+
+% We define [page] settings in the default namespace, inheriting the root
+% settings, in order to eventually allow for modifications without touching
+% root.
+
+\definebtx
+  [\s!default:\s!page]
+  [\s!page]
+
+% List variants, some having specific settings:
+
+\definebtx
+  [\s!default:\s!list:author]
+  [\s!default:\s!list]
+
+\definebtx
+  [\s!default:\s!list:editor]
+  [\s!default:\s!list:author]
+
+\definebtx
+  [\s!default:\s!list:url]
+  [\s!default:\s!list]
+
+\definebtx
+  [\s!default:\s!list:doi]
+  [\s!default:\s!list]
+
+\definebtx
+  [\s!default:\s!list:invertedshort]
+  [\s!default:\s!list]
+
+% normalshort?
+
+\definebtx
+  [\s!default:\s!list:short]
+  [\s!default:\s!list]
+
+\definebtx
+  [\s!default:\s!list:journal]
+  [\s!default:\s!list]
+  [\c!style=\v!italic]
+
+\definebtx
+  [\s!default:\s!list:title]
+  [\s!default:\s!list]
+  [\c!style=\v!italic,
+   \c!command=\Word]
+
+\definebtx
+  [\s!default:\s!list:title:article]
+  [\s!default:\s!list:title]
+  [\c!style=, % journal is set in italics
+   \c!command={\quotation\Word}]
+
+\definebtx
+  [\s!default:\s!list:title:book]
+  [\s!default:\s!list:title]
+
+% Citation variants, some having specific settings :
+
+\definebtx
+  [\s!default:\s!cite:author]
+  [\s!default:\s!cite]
+
+\definebtx
+  [\s!default:\s!cite:authornum]
+  [\s!default:\s!cite:author]
+  [\c!left={(},
+   \c!right={)},
+   \c!pubsep={;\space},
+   \c!lastpubsep={;\space},
+   \c!finalpubsep={;\space}]
+
+\definebtx
+  [\s!default:\s!cite:authoryear]
+  [\s!default:\s!cite:author]
+  [\c!compress=\v!yes,
+   \c!left={(},
+   \c!right={)},
+   \c!inbetween={,\space},
+   \c!pubsep={;\space},
+   \c!lastpubsep={;\space},
+   \c!finalpubsep={;\space}]
+
+\definebtx
+  [\s!default:\s!cite:authorref]
+  [\s!default:\s!cite:authornum]
+
+\definebtx
+  [\s!default:\s!cite:authoryears]
+  [\s!default:\s!cite:author]
+
+\definebtx
+  [\s!default:\s!cite:author:num] % todo
+  [\s!default:\s!cite:authornum]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:author:year] % todo
+  [\s!default:\s!cite:authoryear]
+  [\c!left=,
+   \c!right=]
+
+\definebtx
+  [\s!default:\s!cite:author:years] % todo
+  [\s!default:\s!cite:authoryears]
+  [\c!inbetween=,
+   \c!left=(,
+   \c!right=)]
+
+\definebtx
+  [\s!default:\s!cite:year]
+  [\s!default:\s!cite]
+  [\c!compress=\v!yes,
+   \c!sorttype=year]
+
+\definebtx
+  [\s!default:\s!cite:title]
+  [\s!default:\s!cite]
+  [command={\language[\currentbtxlanguage]}, % BAH
+   \c!style=\v!italic]
+
+\definebtx
+  [\s!default:\s!cite:tag]
+  [\s!default:\s!cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:key]
+  [\s!default:\s!cite:tag]
+
+\definebtx
+  [\s!default:\s!cite:serial]
+  [\s!default:\s!cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:page]
+  [\s!default:\s!cite]
+  [\c!left=,
+   \c!right=]
+
+\definebtx
+  [\s!default:\s!cite:pages]
+  [\s!default:\s!cite:page]
+
+\definebtx
+  [\s!default:\s!cite:keywords]
+  [\s!default:\s!cite]
+  [\c!left={(},
+   \c!right={)}]
+
+\definebtx
+  [\s!default:\s!cite:invertedshort]
+  [\s!default:\s!cite]
+
+\definebtx
+  [\s!default:\s!cite:short]
+  [\s!default:\s!cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:category]
+  [\s!default:\s!cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:type]
+  [\s!default:\s!cite:category]
+
+\definebtx
+  [\s!default:\s!cite:url]
+  [\s!default:\s!cite]
+  [\c!left={[},
+   \c!right={]}]
+
+\definebtx
+  [\s!default:\s!cite:doi]
+  [\s!default:\s!cite:url]
+
+\definebtx
+  [\s!default:\s!cite:num]
+  [\s!default:\s!cite]
+  [\c!compress=\v!yes,
+   \c!left={[},
+   \c!right={]},
+   \c!pubsep={,},
+   \c!lastpubsep={,},
+   \c!finalpubsep={,}]
+
+\definebtx
+  [\s!default:\s!cite:textnum]
+  [\s!default:\s!cite:num]
+  [\c!left=, % in apa: {Ref.\nbsp} or so
+   \c!right=,
+   \c!pubsep={,},
+   \c!lastpubsep={,\space\btxlabeltext{default:and}\space},
+   \c!finalpubsep={\space\btxlabeltext{default:and}\space}]
+
+% Multilingual text strings
+
+\setupbtxlabeltext
+  [en]
+  [\s!default:and=and,
+   \s!default:number={no.},
+   \s!default:edition={ed.},
+   \s!default:Editor=Editor, % Ed./Eds.
+   \s!default:Editors=Editors,
+   \s!default:Volume={Vol.},
+   \s!default:Volumes={Vols.},
+   \s!default:others={et al.}]
+
+\setupbtxlabeltext
+  [nl]
+  [\s!default:and=en,
+   \s!default:number={nr.},
+   \s!default:edition={ed.}, % editie
+   \s!default:Editor=Editor, % Ed./Eds.
+   \s!default:Editors=Editors,
+   \s!default:Volume={Vol.},
+   \s!default:Volumes={Vols.},
+   \s!default:others={et al.}]
+
+\setupbtxlabeltext
+  [fr]
+  [\s!default:and=et,
+   \s!default:others={et al.},
+   \s!default:number={n\high{o}},
+   \s!default:edition={édition},
+   \s!default:Editor=Éditeur,
+   \s!default:Editors=Éditeurs,
+   \s!default:Volume=Volume,
+   \s!default:Volumes=Volumes,
+   \s!default:others={et al.}]
+
+\setupbtxlabeltext
+  [de]
+  [\s!default:and=und,
+   \s!default:number={nr.},
+   \s!default:edition=Auf\/lage,
+   \s!default:Editor=Herausgeber, % Hrsg./Hg.
+   \s!default:Editors=Herausgeber,
+   \s!default:Volume=Band,        % Bd.
+   \s!default:Volumes={Bände},
+   \s!default:others={et al.}]
+
+\setupbtxlabeltext
+  [it]
+  [\s!default:and=e,
+   \s!default:number={nº},
+   \s!default:edition={ed.}, % edizione
+   \s!default:Editor={A cura di},
+   \s!default:Editors={A cura di},
+   \s!default:Volume={Vol.},  % Volume
+   \s!default:Volumes={Vol.}, % Volumi
+   \s!default:others={et al.}]
+
+\setupbtxlabeltext
+  [es]
+  [\s!default:and=y,
+   \s!default:number={nº},
+   \s!default:edition={ed.}, % edición
+   \s!default:Editor=Editor, % Ed./Eds.
+   \s!default:Editors=Editores,
+   \s!default:Volume={Vol.},   % Volumen
+   \s!default:Volumes={Vols.}, % Volúmenes
+   \s!default:others={et al.}]
+
+% First some helpers:
+
+\starttexdefinition btx:default:composed-title
+    \begingroup
+        \language[\currentbtxlanguage]
+        \btxflush{title}
+        \btxdoif {subtitle} {
+            \btxcolon
+            \btxflush{subtitle}
+        }
+    \endgroup
+\stoptexdefinition
+
+\starttexdefinition btx:default:title
+    \btxdoif {title} {
+        \btxspace
+        \btxstartstyleandcolor [default:list:title:\currentbtxcategory]
+            \btxusecommand[default:list:title:\currentbtxcategory] {
+                \texdefinition{btx:default:composed-title}
+            }
+        \btxstopstyleandcolor
+        \btxcomma
+    }
+\stoptexdefinition
+
+\starttexdefinition btx:default:author
+    \btxdoif {author} {
+        \btxflush{author}
+        \doif {\btxfoundname{author}} {editor} {
+            \btxcomma
+            \btxsingularorplural {editor} {
+                \btxlabeltext{default:Editor}
+            } {
+                \btxlabeltext{default:Editors}
+            }
+        }
+        \btxcomma
+    }
+\stoptexdefinition
+
+\starttexdefinition btx:default:year
+    \btxflush{year}
+    \btxflush{suffix}
+\stoptexdefinition
+
+\starttexdefinition btx:default:journal
+    \btxdoif {journal} {
+        \btxspace
+        \btxstartstyleandcolor [default:list:journal]
+            \btxusecommand[default:list:journal] {
+                \btxflush{journal}
+            }
+        \btxstopstyleandcolor
+        \btxdoifelse {volume} {
+            \btxspace
+            \btxflush{volume}
+            \btxdoif {number} {
+                \ignorespaces % brrr
+                \btxleftparenthesis
+                \btxflush{number}
+                \btxrightparenthesis
+            }
+
+        } {
+            \btxdoif {number} {
+                \btxlabeltext{default:number}
+                \btxspace
+                \btxflush{number}
+            }
+        }
+        \btxdoif {pages} {
+            \btxcomma
+            \btxflush{pages}
+        }
+        \btxcomma
+    }
+\stoptexdefinition
+
+\starttexdefinition btx:default:editionset
+    \btxdoif {editionset} {
+        \removeunwantedspaces
+        \removepunctuation
+        \btxleftparenthesis
+        \doif {\btxfoundname{editionset}} {edition} {
+            \btxflush{edition}
+            \btxspace
+            \btxlabeltext{default:edition}
+            \btxcomma
+        }
+        \btxdoif {volume} {
+            \btxoneorrange {volume} {
+                \btxlabeltext{default:Volume}
+            } {
+                \btxlabeltext{default:Volumes}
+            }
+            \btxspace
+            \btxflush{volume}
+            \btxcomma
+        }
+        \btxdoifelse {number} {
+            \btxlabeltext{default:number}
+            \btxspace
+            \btxflush{number}
+        } {
+            \removeunwantedspaces
+            \removepunctuation
+        }
+        \btxrightparenthesiscomma
+    }
+\stoptexdefinition
+
+\starttexdefinition btx:default:publisher
+    \btxdoif {publisher} {
+        \btxflush{publisher}
+        \btxcomma
+    }
+    \btxdoif {address} {
+        \btxflush{address}
+        \btxcomma
+    }
+\stoptexdefinition
+
+% Then a minimal number of setups:
+
+\startsetups btx:default:list:article
+    \texdefinition{btx:default:author}
+    \texdefinition{btx:default:title}
+    \texdefinition{btx:default:journal}
+    \texdefinition{btx:default:year}
+    \removeunwantedspaces
+    \removepunctuation
+    \btxperiod
+\stopsetups
+
+\startsetups btx:default:list:book
+    \texdefinition{btx:default:author}
+    \texdefinition{btx:default:title}
+    \texdefinition{btx:default:editionset}
+    \texdefinition{btx:default:publisher}
+    \texdefinition{btx:default:year}
+    \removeunwantedspaces
+    \removepunctuation
+    \btxperiod
+\stopsetups
+
+\startsetups btx:default:list:unknown
+    \currentbtxcategory\btxcolon
+    \btxshowentryinline
+\stopsetups
+
+%D Experiment:
+
+\startsetups btx:default:lefttext
+    \currentbtxlefttext
+\stopsetups
+
+\startsetups btx:default:righttext
+    \currentbtxrighttext
+\stopsetups
+
+%D Citations:
+
+\startsetups \s!btx:\s!default:\s!cite:author
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:authoryear
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:authoryears
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:authornum
+    \fastsetup{\s!btx:\s!cite:author}
+\stopsetups
+
+\startsetups \s!btx:\s!default:\s!cite:author:num
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:author:year
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:author:years
+    \fastsetup{\s!btx:\s!cite:concat}
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+
+\startsetups \s!btx:\s!default:\s!cite:keywords
+    \fastsetup{\s!btx:\s!cite:list}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:year
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:short
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:serial
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:tag
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:key
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:category
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:type
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:num
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:textnum
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:title
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:pages
+    \fastsetup{\s!btx:\s!cite:range}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:page
+    \fastsetup{\s!btx:\s!cite:normal}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:doi
+    \fastsetup{\s!btx:\s!cite:url}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:url
+    \fastsetup{\s!btx:\s!cite:url}
+\stopsetups
+
+\startsetups \s!btx:\s!default:\s!cite:unknown
+    \fastsetup{\s!btx:\s!cite:unknown}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!cite:none
+    \fastsetup{\s!btx:\s!cite:none}
+\stopsetups
+
+\startsetups \s!btx:\s!default:\s!cite:nocite
+    \fastsetup{\s!btx:\s!cite:nocite}
+\stopsetups
+
+\startsetups \s!btx:\s!default:\s!list:page
+    \fastsetup{\s!btx:\s!list:page}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!list:yes
+    \fastsetup{\s!btx:\s!list:yes}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!list:num
+    \fastsetup{\s!btx:\s!list:num}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!list:bib
+    \fastsetup{\s!btx:\s!list:bib}
+\stopsetups
+\startsetups \s!btx:\s!default:\s!list:short
+    \fastsetup{\s!btx:\s!list:short}
+\stopsetups
+
+\stopbtxrenderingdefinitions
diff --git a/tex/context/base/publ-imp-definitions.mkiv b/tex/context/base/publ-imp-definitions.mkvi
index a3196cc37..9485335ce 100644
--- a/tex/context/base/publ-imp-definitions.mkiv
+++ b/tex/context/base/publ-imp-definitions.mkvi
@@ -27,6 +27,16 @@
     \btxfield{short}
 \stopxmlsetups
 
+\starttexdefinition btx:format:inject #link #content
+    \ifx\currentbtxinternal\empty
+        #content
+    \else\ifconditional\btxinteractive
+        \goto {#content} [#link]
+    \else
+        #content
+    \fi\fi
+\stoptexdefinition
+
 \startxmlsetups btx:format:doi
     \edef\currentbtxfielddoi{\btxfield{doi}}
     \ifx\currentbtxfielddoi\empty
@@ -61,7 +71,7 @@
     \ifx\currentbtxfieldmonth\empty
         {\tttf no-month}
     \else
-        \edef\p_monthconversion{\btxlistvariantparameter\c!monthconversion}
+        \edef\p_monthconversion{\btxparameter\c!monthconversion}
         \ifx\p_monthconversion\empty % month month:mnem
             \currentbtxfieldmonth
         \else
@@ -74,4 +84,40 @@
     \fi
 \stopxmlsetups
 
+% macros:
+
+\starttexdefinition btx:style:italic #content
+    \dontleavehmode
+    \begingroup
+        \it
+        #content
+        \italiccorrection
+    \endgroup
+\stoptexdefinition
+
+\starttexdefinition btx:style:bold #content
+    \dontleavehmode
+    \begingroup
+        \bf
+        #content
+    \endgroup
+\stoptexdefinition
+
+\starttexdefinition btx:style:quote #content
+    \dontleavehmode
+    \startquote
+        #content
+    \stopquote
+\stoptexdefinition
+
+\starttexdefinition btx:style #style #content
+    \doifdefinedelse {btx:style:#style} {
+        \texdefinition{btx:style:#style} {
+            #content
+        }
+    } {
+        #content
+    }
+\stoptexdefinition
+
 \protect
diff --git a/tex/context/base/publ-imp-list.mkvi b/tex/context/base/publ-imp-list.mkvi
index 52e5694e2..815bb2038 100644
--- a/tex/context/base/publ-imp-list.mkvi
+++ b/tex/context/base/publ-imp-list.mkvi
@@ -29,20 +29,20 @@
     \fi
 \stoptexdefinition
 
-\startsetups \s!btx:\s!list:concat
-%     \ifcase\currentbtxconcat \or \or
-%         \btxcitevariantparameter\c!pubsep
-%     \or
-%         \btxcitevariantparameter\c!finalpubsep
-%     \or
-%         \btxcitevariantparameter\c!lastpubsep
-%     \fi
+\starttexdefinition btx:list:helpers:concat
+  % \ifcase\currentbtxconcat \or \or
+  %     \btxparameter\c!pubsep
+  % \or
+  %     \btxparameter\c!finalpubsep
+  % \or
+  %     \btxparameter\c!lastpubsep
+  % \fi
     \space
-\stopsetups
+\stoptexdefinition
 
 \startsetups \s!btx:\s!list:page
-    \directsetup{\s!btx:\s!list:concat}
-    \texdefinition {\s!btx:\s!list:inject} {
+    \texdefinition{\s!btx:\s!list:concat}
+    \texdefinition{\s!btx:\s!list:inject} {
         % real pagenumber: todo, userpage
         \currentbtxfirst
         % order
diff --git a/tex/context/base/publ-imp-page.mkvi b/tex/context/base/publ-imp-page.mkvi
index 3f8fb96be..19673c829 100644
--- a/tex/context/base/publ-imp-page.mkvi
+++ b/tex/context/base/publ-imp-page.mkvi
@@ -13,57 +13,66 @@
 
 \unprotect
 
-\setupbtxlist
-  [\c!pageleft={\space (p.\nobreakspace},
-   \c!pageright={)},
+\definebtx
+  [\s!page] % or just outer level
+  [\c!pagestate=\v!stop,
+   \c!pageleft=\btxleftparenthesis, % see below!!
+   \c!pageright=\btxrightparenthesis,
    \c!pagesep={,\space},
-   \c!lastpagesep={\space and\space},
-   \c!finalpagesep={,\space and\space},
+   \c!lastpagesep={,\space\btxlabeltext{\currentbtxspecification:and}\space},
+   \c!finalpagesep={\space\btxlabeltext{\currentbtxspecification:and}\space},
    \c!pageconnector=\endash]
 
-\setupbtxrendering
-  [\c!pagestate=\v!stop]
+\definebtx
+  [\s!page:\s!list]
+  [\s!page]
+  [\c!command={\wordright}]
 
-\definebtxlistvariant
-  [\v!page]
-
-\startsetups \s!btx:\s!list:\s!page:concat
+\startsetups \s!btx:\s!page:concat
     \ifcase\currentbtxoverflow
         \ifcase\currentbtxconcat
         \or % first
         \or % second
-            \btxlistparameter\c!pagesep
+            \btxparameter\c!pagesep
         \or % second of two
-            \btxlistparameter\c!lastpagesep
+            \btxparameter\c!lastpagesep
         \or % last
-            \btxlistparameter\c!finalpagesep
+            \btxparameter\c!finalpagesep
         \fi
     \fi
 \stopsetups
 
-\startsetups \s!btx:\s!list:\s!page:normal
-    \fastsetup{\s!btx:\s!list:\s!page:concat}
-    \btxdoifelseinteractive {page} {
+% for the moment we have only one variant
+
+\startsetups [\s!btx:\s!page:\s!list]
+    \fastsetup{\s!btx:\s!page:concat}
+  % \ifx\currentbtxlastpage\empty
+  %     p.
+  % \else
+  %     pp.
+  % \fi
+  % \btxnbsp
+    \ifconditional\btxinteractive
         \goto {
             \currentbtxfirstpage
         } [
             internal(\currentbtxfirstinternal)
         ]
         \ifx\currentbtxlastpage\empty \else
-            \btxlistvariantparameter\c!pageconnector
+            \btxparameter\c!pageconnector
             \goto {
                 \currentbtxlastpage
             } [
                 internal(\currentbtxlastinternal)
             ]
         \fi
-    } {
+    \else
         \currentbtxfirstpage
         \ifx\currentbtxlastpage\empty \else
-            \btxlistvariantparameter\c!pageconnector
+            \btxparameter\c!pageconnector
             \currentbtxlastpage
         \fi
-    }
+    \fi
 \stopsetups
 
 \protect
diff --git a/tex/context/base/publ-imp-replacements.lua b/tex/context/base/publ-imp-replacements.lua
new file mode 100644
index 000000000..b15b17e30
--- /dev/null
+++ b/tex/context/base/publ-imp-replacements.lua
@@ -0,0 +1,13 @@
+return {
+    name         = "replacements",
+    version      = "1.00",
+    comment      = "Good riddance",
+    author       = "Alan Braslau and Hans Hagen",
+    copyright    = "ConTeXt development team",
+    replacements = {
+        [ [[Th\^e\llap{\raise0.5ex\hbox{\'{\relax}}}]] ] = "Thánh",
+        [ [[Th\^e\llap{\raise 0.5ex\hbox{\'{\relax}}}]] ] = "Thánh",
+        [ [[Th{\^e}\llap{\raise0.5ex\hbox{\'{\relax}}}]] ] = "Thánh",
+        [ [[Th{\^e}\llap{\raise 0.5ex\hbox{\'{\relax}}}]] ] = "Thánh",
+    },
+}
diff --git a/tex/context/base/publ-ini.lua b/tex/context/base/publ-ini.lua
index 2d85637a2..6cde49d7b 100644
--- a/tex/context/base/publ-ini.lua
+++ b/tex/context/base/publ-ini.lua
@@ -11,15 +11,16 @@ if not modules then modules = { } end modules ['publ-ini'] = {
 
 -- plug the list sorted in the list mechanism (specification.sortorder)
 
--- todo: delay details till alternative is known so that potential author
--- fields are known
-
 -- If we define two datasets with the same bib file we can consider
 -- sharing the data but that means that we need to have a parent which
 -- in turn makes things messy if we start manipulating entries in
 -- different ways (future) .. not worth the trouble as we will seldom
 -- load big bib files many times and even then ... fonts are larger.
 
+-- A potential optimization is to work with current_dataset, current_tag when
+-- fetching fields but the code become real messy that way (many currents). The
+-- gain is not that large anyway because not much publication stuff is flushed.
+
 local next, rawget, type, tostring, tonumber = next, rawget, type, tostring, tonumber
 local match, find = string.match, string.find
 local concat, sort, tohash = table.concat, table.sort, table.tohash
@@ -32,9 +33,11 @@ local sortedkeys, sortedhash = table.sortedkeys, table.sortedhash
 local setmetatableindex = table.setmetatableindex
 local lpegmatch = lpeg.match
 local P, S, C, Ct, R, Carg = lpeg.P, lpeg.S, lpeg.C, lpeg.Ct, lpeg.R, lpeg.Carg
+local upper = utf.upper
 
 local report             = logs.reporter("publications")
 local report_cite        = logs.reporter("publications","cite")
+local report_list        = logs.reporter("publications","list")
 local report_reference   = logs.reporter("publications","reference")
 
 local trace              = false  trackers.register("publications",                 function(v) trace            = v end)
@@ -60,16 +63,9 @@ local v_local            = variables["local"]
 local v_global           = variables["global"]
 
 local v_force            = variables.force
-local v_standard         = variables.standard
-local v_start            = variables.start
 local v_none             = variables.none
-local v_left             = variables.left
-local v_right            = variables.right
-local v_middle           = variables.middle
-local v_inbetween        = variables.inbetween
 local v_yes              = variables.yes
 local v_all              = variables.all
-local v_cite             = variables.cite
 local v_default          = variables.default
 local v_dataset          = variables.dataset
 
@@ -78,7 +74,8 @@ local numbertochar       = converters.characters
 local logsnewline        = logs.newline
 local logspushtarget     = logs.pushtarget
 local logspoptarget      = logs.poptarget
-local csname_id          = token.csname_id
+
+local isdefined          = tex.isdefined
 
 ----- basicsorter        = sorters.basicsorter -- (a,b)
 ----- sortstripper       = sorters.strip
@@ -96,78 +93,85 @@ manipulatormethods.WORD  = converters.WORD
 manipulatormethods.Words = converters.Words
 manipulatormethods.WORDS = converters.WORDS
 
-local context                     = context
-local commands                    = commands
-
-local ctx_doifelse                = commands.doifelse
-local ctx_doif                    = commands.doif
-local ctx_doifnot                 = commands.doifnot
-
-local ctx_setvalue                = context.setvalue
-local ctx_firstoftwoarguments     = context.firstoftwoarguments
-local ctx_secondoftwoarguments    = context.secondoftwoarguments
-local ctx_firstofoneargument      = context.firstofoneargument
-local ctx_gobbleoneargument       = context.gobbleoneargument
-
-local ctx_btxlistparameter        = context.btxlistparameter
-local ctx_btxcitevariantparameter = context.btxcitevariantparameter
-local ctx_btxlistvariantparameter = context.btxlistvariantparameter
-local ctx_btxdirectlink           = context.btxdirectlink
-local ctx_btxhandlelistentry      = context.btxhandlelistentry
-local ctx_btxhandlelisttextentry  = context.btxhandlelisttextentry
-local ctx_btxchecklistentry       = context.btxchecklistentry
-local ctx_btxchecklistcombi       = context.btxchecklistcombi
-local ctx_btxsetcitereference     = context.btxsetcitereference
-local ctx_btxsetlistreference     = context.btxsetlistreference
------ ctx_btxmissing              = context.btxmissing
-
-local ctx_btxsetdataset           = context.btxsetdataset
-local ctx_btxsettag               = context.btxsettag
-local ctx_btxsetnumber            = context.btxsetnumber
-local ctx_btxsetlanguage          = context.btxsetlanguage
-local ctx_btxsetcombis            = context.btxsetcombis
-local ctx_btxsetcategory          = context.btxsetcategory
-local ctx_btxcitesetup            = context.btxcitesetup
-local ctx_btxpagesetup            = context.btxpagesetup
-local ctx_btxsetfirst             = context.btxsetfirst
-local ctx_btxsetsecond            = context.btxsetsecond
-local ctx_btxsetthird             = context.btxsetthird
-local ctx_btxsetinternal          = context.btxsetinternal
-local ctx_btxsetlefttext          = context.btxsetlefttext
-local ctx_btxsetrighttext         = context.btxsetrighttext
-local ctx_btxsetbefore            = context.btxsetbefore
-local ctx_btxsetafter             = context.btxsetafter
-local ctx_btxsetbacklink          = context.btxsetbacklink
-local ctx_btxsetbacktrace         = context.btxsetbacktrace
-local ctx_btxsetcount             = context.btxsetcount
-local ctx_btxsetconcat            = context.btxsetconcat
-local ctx_btxsetoveflow           = context.btxsetoverflow
-local ctx_btxsetfirstpage         = context.btxsetfirstpage
-local ctx_btxsetlastpage          = context.btxsetlastpage
-local ctx_btxsetfirstinternal     = context.btxsetfirstinternal
-local ctx_btxsetlastinternal      = context.btxsetlastinternal
-local ctx_btxstartcite            = context.btxstartcite
-local ctx_btxstopcite             = context.btxstopcite
-local ctx_btxstartciteauthor      = context.btxstartciteauthor
-local ctx_btxstopciteauthor       = context.btxstopciteauthor
-local ctx_btxstartsubcite         = context.btxstartsubcite
-local ctx_btxstopsubcite          = context.btxstopsubcite
-local ctx_btxlistsetup            = context.btxlistsetup
-local ctx_btxflushauthor          = context.btxflushauthor
-
-local registeredcitevariants = publications.registeredcitevariants or allocate()
-local registeredlistvariants = publications.registeredlistvariants or allocate()
-
-storage.register("publications/registeredcitevariants", registeredcitevariants,"publications.registeredcitevariants")
-storage.register("publications/registeredlistvariants", registeredlistvariants,"publications.registeredlistvariants")
-
-function commands.registerbtxcitevariant(name,parent)
-    registeredcitevariants[name] = parent or ""
-end
-
-function commands.registerbtxlistvariant(name,parent)
-    registeredlistvariants[name] = parent or ""
-end
+local context                    = context
+local commands                   = commands
+
+local ctx_doifelse               = commands.doifelse
+local ctx_doif                   = commands.doif
+local ctx_doifnot                = commands.doifnot
+
+local ctx_firstoftwoarguments    = context.firstoftwoarguments
+local ctx_secondoftwoarguments   = context.secondoftwoarguments
+local ctx_firstofoneargument     = context.firstofoneargument
+
+local ctx_gobbleoneargument      = context.gobbleoneargument
+local ctx_gobbletwoarguments     = context.gobbletwoarguments
+
+local ctx_btxdirectlink          = context.btxdirectlink
+local ctx_btxhandlelistentry     = context.btxhandlelistentry
+local ctx_btxhandlelisttextentry = context.btxhandlelisttextentry
+local ctx_btxchecklistentry      = context.btxchecklistentry
+local ctx_btxchecklistcombi      = context.btxchecklistcombi
+----- ctx_btxsetcitereference    = context.btxsetcitereference
+----- ctx_btxsetlistreference    = context.btxsetlistreference
+
+local ctx_btxsetdataset          = context.btxsetdataset
+local ctx_btxsettag              = context.btxsettag
+local ctx_btxsetnumber           = context.btxsetnumber
+local ctx_btxsetlanguage         = context.btxsetlanguage
+local ctx_btxsetcombis           = context.btxsetcombis
+local ctx_btxsetcategory         = context.btxsetcategory
+local ctx_btxcitesetup           = context.btxcitesetup
+local ctx_btxpagesetup           = context.btxpagesetup
+local ctx_btxsetfirst            = context.btxsetfirst
+local ctx_btxsetsecond           = context.btxsetsecond
+local ctx_btxsetthird            = context.btxsetthird
+local ctx_btxsetinternal         = context.btxsetinternal
+local ctx_btxsetlefttext         = context.btxsetlefttext
+local ctx_btxsetrighttext        = context.btxsetrighttext
+local ctx_btxsetbefore           = context.btxsetbefore
+local ctx_btxsetafter            = context.btxsetafter
+local ctx_btxsetbacklink         = context.btxsetbacklink
+local ctx_btxsetbacktrace        = context.btxsetbacktrace
+local ctx_btxsetcount            = context.btxsetcount
+local ctx_btxsetconcat           = context.btxsetconcat
+local ctx_btxsetoveflow          = context.btxsetoverflow
+local ctx_btxsetfirstpage        = context.btxsetfirstpage
+local ctx_btxsetlastpage         = context.btxsetlastpage
+local ctx_btxsetfirstinternal    = context.btxsetfirstinternal
+local ctx_btxsetlastinternal     = context.btxsetlastinternal
+local ctx_btxstartcite           = context.btxstartcite
+local ctx_btxstopcite            = context.btxstopcite
+local ctx_btxstartciteauthor     = context.btxstartciteauthor
+local ctx_btxstopciteauthor      = context.btxstopciteauthor
+local ctx_btxstartsubcite        = context.btxstartsubcite
+local ctx_btxstopsubcite         = context.btxstopsubcite
+local ctx_btxstartlistentry      = context.btxstartlistentry
+local ctx_btxstoplistentry       = context.btxstoplistentry
+local ctx_btxlistsetup           = context.btxlistsetup
+local ctx_btxflushauthor         = context.btxflushauthor
+local ctx_btxsetnoflistentries   = context.btxsetnoflistentries
+local ctx_btxsetcurrentlistentry = context.btxsetcurrentlistentry
+local ctx_btxsetcurrentlistindex = context.btxsetcurrentlistindex
+
+local ctx_setmacro = tokens.setters and tokens.setters.macro
+
+languages.data       = languages.data       or { }
+local data           = languages.data
+
+-- local registeredcitevariants = publications.registeredcitevariants or { }
+-- local registeredlistvariants = publications.registeredlistvariants or { }
+--
+-- storage.register("publications/registeredcitevariants", registeredcitevariants,"publications.registeredcitevariants")
+-- storage.register("publications/registeredlistvariants", registeredlistvariants,"publications.registeredlistvariants")
+--
+-- function commands.registerbtxcitevariant(name,parent)
+--     registeredcitevariants[name] = parent or ""
+-- end
+--
+-- function commands.registerbtxlistvariant(name,parent)
+--     registeredlistvariants[name] = parent or ""
+-- end
 
 local specifications              = publications.specifications
 local currentspecification        = specifications[false]
@@ -205,7 +209,6 @@ end)
 
 luatex.registerstopactions(function()
     local done = false
-    local undefined = csname_id("undefined*crap")
     for name, dataset in sortedhash(datasets) do
         for command, n in sortedhash(dataset.commands) do
             if not done then
@@ -215,16 +218,12 @@ luatex.registerstopactions(function()
                 logsnewline()
                 done = true
             end
-            local c = csname_id(command)
-            if c and c ~= undefined then
+            if isdefined[command] then
                 report("%-20s %-20s % 5i %s",name,command,n,"known")
+            elseif isdefined[upper(command)] then
+                report("%-20s %-20s % 5i %s",name,command,n,"KNOWN")
             else
-                local u = csname_id(utf.upper(command))
-                if u and u ~= undefined then
-                    report("%-20s %-20s % 5i %s",name,command,n,"KNOWN")
-                else
-                    report("%-20s %-20s % 5i %s",name,command,n,"unknown")
-                end
+                report("%-20s %-20s % 5i %s",name,command,n,"unknown")
             end
         end
     end
@@ -363,9 +362,9 @@ do
                         -- reference (in list)
                         local userdata = entry.userdata
                         if userdata then
-                            local set = userdata.btxset
-                            if set then
-                                local tag = userdata.btxref
+                            local tag = userdata.btxref
+                            if tag then
+                                local set = userdata.btxset or v_default
                                 local s = usedentries[set]
                                 if s then
                                     local u = s[tag]
@@ -476,17 +475,23 @@ local findallused do
     local finder   = publications.finder
 
     findallused = function(dataset,reference,internal)
+        local current = datasets[dataset]
         local finder  = publications.finder -- for the moment, not yet in all betas
-        local find    = finder and finder(reference)
+        local find    = finder and finder(current,reference)
         local tags    = not find and settings_to_array(reference)
         local todo    = { }
         local okay    = { } -- only if mark
         local set     = usedentries[dataset]
-        local current = datasets[dataset]
         local valid   = current.luadata
         local ordered = current.ordered
         if set then
+            local registered = { }
             local function register(tag)
+                if registered[tag] then
+                    return
+                else
+                    registered[tag] = true
+                end
                 local entry = set[tag]
                 if entry then
                     -- only once in a list but at some point we can have more (if we
@@ -527,7 +532,14 @@ local findallused do
                 end
                 todo[tag] = true
             end
-            if find then
+            if reference == "*" then
+                tags = { }
+                for i=1,#ordered do
+                    local tag = ordered[i].tag
+                    register(tag)
+                    tags[#tags+1] = tag
+                end
+            elseif find then
                 tags = { }
                 for i=1,#ordered do
                     local entry = ordered[i]
@@ -554,7 +566,9 @@ local findallused do
                 for i=1,#ordered do
                     local entry = ordered[i]
                     if find(entry) then
-                        tags[#tags+1] = entry.tag
+                        local tag = entry.tag
+                        tags[#tags+1] = tag
+                        todo[tag] = true
                     end
                 end
             else
@@ -635,7 +649,7 @@ function commands.flushmarked()
             -- keep order
             local tag = marked_list[i]
             local tbm = tobemarked[tag]
-            if not tbm or tbm == true then
+            if tbm == nil or tbm == true then
                 nofcitations = nofcitations + 1
                 marknocite(marked_dataset,tag,nofcitations)
                 if trace_cite then
@@ -764,11 +778,44 @@ local function getdirect(dataset,data,field,catspec) -- no field check, no datas
     end
 end
 
+local function getfuzzy(data,field,categories) -- no field check, no dataset check
+    local catspec
+    if categories then
+        local category = data.category
+        if category then
+            catspec = categories[data.category]
+        end
+    end
+    if not field then
+        return
+    elseif not catspec then
+        return data[field]
+    end
+    local fields = catspec.fields
+    if fields then
+        local sets = catspec.sets
+        if sets then
+            local set = sets[field]
+            if set then
+                for i=1,#set do
+                    local field = set[i]
+                    local value = fields[field] and data[field] -- redundant check
+                    if value then
+                        return value
+                    end
+                end
+            end
+        end
+        return fields[field] and data[field] or nil -- redundant check
+    end
+end
+
 publications.getfield  = getfield
 publications.getdetail = getdetail
 publications.getcasted = getcasted
 publications.getfaster = getfaster
 publications.getdirect = getdirect
+publications.getfuzzy  = getfuzzy
 
 -- this needs to be checked: a specific type should have a checker
 
@@ -832,24 +879,28 @@ function commands.btxsingularorplural(dataset,tag,name)
     ctx_doifelse(true)
 end
 
-function firstandlast.pagenumber(d)
+function firstandlast.range(d)
     if type(d) == "table" then
         return d[1], d[2]
     end
 end
 
-function commands.oneorrange(dataset,tag,name)
+firstandlast.pagenumber = firstandlast.range
+
+function commands.btxoneorrange(dataset,tag,name)
     local data, field, kind = getcasted(dataset,tag,name)
     if data then
         local test = firstandlast[kind]
         if test then
             local first, last = test(data)
             ctx_doifelse(not (first and last))
+            return
         end
     end
+    ctx_gobbletwoarguments()
 end
 
-function commands.firstofrange(dataset,tag,name)
+function commands.btxfirstofrange(dataset,tag,name)
     local data, field, kind = getcasted(dataset,tag,name)
     if data then
         local test = firstandlast[kind]
@@ -909,6 +960,8 @@ do
     -- seconds are irrelevant (there is for sure more to gain by proper coding
     -- of the source and or style).
 
+    local f_short = formatters["%t%02i"]
+
     function publications.enhancers.suffixes(dataset)
         if not dataset then
             return -- bad news
@@ -922,11 +975,12 @@ do
         local luadata  = dataset.luadata
         local details  = dataset.details
         local ordered  = dataset.ordered
-        local field    = "author"  -- currently only author
-        local shorts   = { }
         if not luadata or not details or not ordered then
+            report("nothing to be analyzed in %a",dataset.name)
             return -- also bad news
         end
+        local field  = "author"  -- currently only author
+        local shorts = { }
         for i=1,#ordered do
             local entry = ordered[i]
             if entry then
@@ -940,6 +994,7 @@ do
                         local userdata  = listentry.userdata
                         local btxspc    = userdata and userdata.btxspc
                         if btxspc then
+                            -- this will become a specification entry
                             local author = getcasted(dataset,tag,field,specifications[btxspc])
                             if type(author) == "table" then
                                 -- number depends on sort order
@@ -956,7 +1011,7 @@ do
                                     end
                                 end
                                 local year  = tonumber(entry.year) or 0
-                                local short = formatters["%t%02i"](t,mod(year,100))
+                                local short = f_short(t,mod(year,100))
                                 local s = shorts[short]
                                 -- we could also sort on reference i.e. entries.text
                                 if u then
@@ -1030,8 +1085,8 @@ function commands.setbtxdataset(name,default)
     elseif default and default ~= "" then
         context(default)
     else
-        context(v_standard)
-        report("unknown dataset %a, forcing %a",name,standard)
+        context(v_default)
+        report("unknown dataset %a, forcing %a",name,v_default)
     end
 end
 
@@ -1091,6 +1146,8 @@ do
     -- then there can be cases where we have no specification for instance
     -- when we have a special kind of database
 
+    local splitter = lpeg.splitat(":")
+
     local function permitted(category,field)
         local catspec = currentspecification.categories[category]
         if not catspec then
@@ -1105,6 +1162,10 @@ do
         if ignoredfields and ignoredfields[field] then
             return false
         end
+        local virtual = catspec.virtual
+        if virtual and virtual[field] then
+            return true
+        end
         local sets = catspec.sets
         if sets then
             local set = sets[field]
@@ -1115,6 +1176,10 @@ do
         if fields[field] then
             return true
         end
+        local f, l = lpegmatch(splitter,field)
+        if f and l and fields[f] then
+            return true -- language specific one
+        end
     end
 
     local function found(dataset,tag,field,valid,fields)
@@ -1234,8 +1299,8 @@ do
             local fields = dataset.luadata[tag]
             if fields then
                 local category = fields.category
+                local manipulator, field = splitmanipulation(field)
                 if permitted(category,field) then
-                    local manipulator, field = splitmanipulation(field)
                     local value = fields[field]
                     if value then
                         typesetters[currentspecification.types[field]](field,value,manipulator)
@@ -1261,8 +1326,8 @@ do
                 local details = dataset.details[tag]
                 if details then
                     local category = fields.category
+                    local manipulator, field = splitmanipulation(field)
                     if permitted(category,field) then
-                        local manipulator, field = splitmanipulation(field)
                         local value = details[field]
                         if value then
                             typesetters[currentspecification.types[field]](field,value,manipulator)
@@ -1298,6 +1363,7 @@ do
         end
     end
 
+    publications.okay = okay
 
     function commands.btxdoifelse(name,tag,field) ctx_doifelse(okay(name,tag,field)) end
     function commands.btxdoif    (name,tag,field) ctx_doif    (okay(name,tag,field)) end
@@ -1319,7 +1385,11 @@ end
 
 do
 
-    local patterns = { "publ-imp-%s.mkvi", "publ-imp-%s.mkiv", "publ-imp-%s.tex" }
+    local patterns = {
+        "publ-imp-%s.mkvi",
+        "publ-imp-%s.mkiv",
+        "publ-imp-%s.tex",
+    }
 
     local function failure(name)
         report("unknown library %a",name)
@@ -1339,6 +1409,20 @@ do
         }
     end
 
+    local patterns = {
+        "publ-imp-%s.lua",
+    }
+
+    function commands.loadbtxreplacementfile(name) -- a more specific name
+        commands.uselibrary {
+            name     = string.gsub(name,"^publ%-",""),
+            patterns = patterns,
+            action   = publications.loaders.registercleaner,
+            failure  = failure,
+            onlyonce = true,
+        }
+    end
+
 end
 
 -- lists
@@ -1464,7 +1548,7 @@ do
         local list    = rendering.list
         for tag, data in sortedhash(luadata) do
             if not keyword or validkeyword(dataset,tag,keyword) then
-                list[#list+1] = { tag, false, 0, false, false }
+                list[#list+1] = { tag, false, 0, false, false, data.index or 0}
             end
         end
     end
@@ -1472,17 +1556,21 @@ do
     methods[v_force] = function (dataset,rendering,keyword)
         -- only for checking, can have duplicates, todo: collapse page numbers, although
         -- we then also needs deferred writes
-        local result  = structures.lists.filter(rendering.specification) or { }
+        local result  = structures.lists.filter(rendering.specifications) or { }
         local list    = rendering.list
         local current = datasets[dataset]
         local luadata = current.luadata
         for listindex=1,#result do
             local r = result[listindex]
             local u = r.userdata
-            if u and u.btxset == dataset then
-                local tag = u.btxref
-                if tag and (not keyword or validkeyword(dataset,tag,keyword)) then
-                    list[#list+1] = { tag, listindex, 0, u, u.btxint }
+            if u then
+                local set = u.btxset or v_default
+                if set == dataset then
+                    local tag = u.btxref
+                    if tag and (not keyword or validkeyword(dataset,tag,keyword)) then
+                        local data = luadata[tag]
+                        list[#list+1] = { tag, listindex, 0, u, u.btxint, data and data.index or 0 }
+                    end
                 end
             end
         end
@@ -1493,7 +1581,7 @@ do
     -- global : if tag and not alldone[tag] and done[tag] ~= section then ...
 
     methods[v_local] = function(dataset,rendering,keyword)
-        local result    = structures.lists.filter(rendering.specification) or { }
+        local result    = structures.lists.filter(rendering.specifications) or { }
         local section   = sections.currentid()
         local list      = rendering.list
         local repeated  = rendering.repeated == v_yes
@@ -1506,34 +1594,40 @@ do
         local pages     = { }
         local current   = datasets[dataset]
         local luadata   = current.luadata
+rendering.result = result
         for listindex=1,#result do
             local r = result[listindex]
             local u = r.userdata
-            if u and u.btxset == dataset then
-                local tag = u.btxref
-                if not tag then
-                    -- problem
-                elseif done[tag] == section then -- a bit messy for global and all and so
-                    -- skip
-                elseif doglobal and alldone[tag] then
-                    -- skip
-                elseif not keyword or validkeyword(dataset,tag,keyword) then
-                    if traced then
-                        local l = traced[tag]
-                        if l then
-                            l[#l+1] = u.btxint
+            if u then
+                local set = u.btxset or v_default
+                if set == dataset then
+                    local tag = u.btxref
+                    if not tag then
+                        -- problem
+                    elseif done[tag] == section then -- a bit messy for global and all and so
+                        -- skip
+                    elseif doglobal and alldone[tag] then
+                        -- skip
+                    elseif not keyword or validkeyword(dataset,tag,keyword) then
+                        if traced then
+                            local l = traced[tag]
+                            if l then
+                                l[#l+1] = u.btxint
+                            else
+                                local data = luadata[tag]
+                                local l = { tag, listindex, 0, u, u.btxint, data and data.index or 0 }
+                                list[#list+1] = l
+                                traced[tag] = l
+                            end
                         else
-                            local l = { tag, listindex, 0, u, u.btxint }
-                            list[#list+1] = l
-                            traced[tag] = l
+                            done[tag]    = section
+                            alldone[tag] = true
+                            local data = luadata[tag]
+                            list[#list+1] = { tag, listindex, 0, u, u.btxint, data and data.index or 0 }
                         end
-                    else
-                        done[tag]    = section
-                        alldone[tag] = true
-                        list[#list+1] = { tag, listindex, 0, u, u.btxint }
                     end
+                    registerpage(pages,tag,result,listindex)
                 end
-                registerpage(pages,tag,result,listindex)
             end
         end
         if traced then
@@ -1558,18 +1652,20 @@ do
         if not rendering then
             return
         end
-        local method            = specification.method or v_none
-        local ignored           = specification.ignored or ""
-        rendering.method        = method
-        rendering.ignored       = ignored ~= "" and settings_to_set(ignored) or nil
-        rendering.list          = { }
-        rendering.done          = { }
-        rendering.sorttype      = specification.sorttype or v_default
-        rendering.criterium     = specification.criterium or v_none
-        rendering.repeated      = specification.repeated or v_no
-        rendering.specification = specification
-        local filtermethod      = methods[method]
+        local method             = specification.method or v_none
+        local ignored            = specification.ignored or ""
+        rendering.method         = method
+        rendering.ignored        = ignored ~= "" and settings_to_set(ignored) or nil
+        rendering.list           = { }
+        rendering.done           = { }
+        rendering.sorttype       = specification.sorttype or v_default
+        rendering.criterium      = specification.criterium or v_none
+        rendering.repeated       = specification.repeated or v_no
+        rendering.group          = specification.group or ""
+        rendering.specifications = specification
+        local filtermethod       = methods[method]
         if not filtermethod then
+            report_list("invalid method %a",method or "")
             return
         end
         lists.result  = { } -- kind of reset
@@ -1580,11 +1676,12 @@ do
             keyword = nil
         end
         filtermethod(dataset,rendering,keyword)
+        ctx_btxsetnoflistentries(#rendering.list)
     end
 
     -- for determining width
 
-    local lastreferencenumber = 0 -- document wide
+    local groups = setmetatableindex("number")
 
     function lists.prepareentries(dataset)
         local rendering = renderings[dataset]
@@ -1593,11 +1690,13 @@ do
         local forceall  = rendering.criterium == v_all
         local repeated  = rendering.repeated == v_yes
         local sorttype  = rendering.sorttype or v_default
+        local group     = rendering.group or ""
         local sorter    = lists.sorters[sorttype]
         local current   = datasets[dataset]
         local luadata   = current.luadata
         local details   = current.details
         local newlist   = { }
+        local lastreferencenumber = groups[group] -- current.lastreferencenumber or 0
         for i=1,#list do
             local li    = list[i]
             local tag   = li[1]
@@ -1628,6 +1727,7 @@ do
                 end
             end
         end
+        groups[group] = lastreferencenumber
         if type(sorter) == "function" then
             rendering.list = sorter(dataset,rendering,newlist,sorttype) or newlist
         else
@@ -1655,7 +1755,12 @@ do
     function commands.btxflushpages(dataset,tag)
         -- todo: interaction
         local rendering = renderings[dataset]
-        local pages     = rendering.pages[tag]
+        local pages     = rendering.pages
+        if not pages then
+            return
+        else
+            pages = pages[tag]
+        end
         if not pages then
             return
         end
@@ -1713,67 +1818,153 @@ do
         end
     end
 
-    function lists.flushentries(dataset,textmode)
+    function lists.sameasprevious(dataset,i,name)
         local rendering = renderings[dataset]
         local list      = rendering.list
+        local n         = tonumber(i)
+        if n and n > 1 and n <= #list then
+            local luadata  = datasets[dataset].luadata
+            local current  = getdirect(dataset,luadata[list[n  ][1]],name)
+            local previous = getdirect(dataset,luadata[list[n-1][1]],name)
+            if trace_detail then
+                report("previous %a, current %a",tostring(previous),tostring(current))
+            end
+            return current and current == previous
+        else
+            return false
+        end
+    end
+
+    function lists.flushentry(dataset,i,textmode)
+        local rendering = renderings[dataset]
+        local list      = rendering.list
+--         local result    = rendering.result
         local luadata   = datasets[dataset].luadata
-        -- maybe a startflushing here
-        ignoredfields   = rendering.ignored or { }
-        --
-        if list then
-            for i=1,#list do
-                local li       = list[i]
-                local tag      = li[1]
-                local n        = li[3]
-                local entry    = luadata[tag]
-                local combined = entry.combined
-                local language = entry.language
-                if combined then
-                    ctx_btxsetcombis(concat(combined,","))
+        local li        = list[i]
+        if li then
+            local tag       = li[1]
+            local listindex = li[2]
+            local n         = li[3]
+            local entry     = luadata[tag]
+            --
+            ctx_btxstartlistentry()
+            ctx_btxsetcurrentlistentry(i) -- redundant
+            ctx_btxsetcurrentlistindex(listindex)
+            local combined = entry.combined
+            local language = entry.language
+            if combined then
+                ctx_btxsetcombis(concat(combined,","))
+            end
+            ctx_btxsetcategory(entry.category or "unknown")
+            ctx_btxsettag(tag)
+            ctx_btxsetnumber(n)
+            if language then
+                ctx_btxsetlanguage(language)
+            end
+            local bl = li[5]
+            if bl and bl ~= "" then
+                ctx_btxsetbacklink(bl)
+                ctx_btxsetbacktrace(concat(li," ",5))
+                local uc = citetolist[tonumber(bl)]
+                if uc then
+                    ctx_btxsetinternal(uc.references.internal or "")
                 end
-                ctx_btxsetcategory(entry.category or "unknown")
-                ctx_btxsettag(tag)
-                ctx_btxsetnumber(n)
-                if language then
-                    ctx_btxsetlanguage(language)
+            else
+                -- nothing
+            end
+            local userdata = li[4]
+            if userdata then
+                local b = userdata.btxbtx
+                local a = userdata.btxatx
+                if b then
+                    ctx_btxsetbefore(b)
                 end
-                local bl = li[5]
-                if bl and bl ~= "" then
-                    ctx_btxsetbacklink(bl)
-                    ctx_btxsetbacktrace(concat(li," ",5))
-                    local uc = citetolist[tonumber(bl)]
-                    if uc then
-                        ctx_btxsetinternal(uc.references.internal or "")
-                    end
-                else
-                    -- nothing
+                if a then
+                    ctx_btxsetafter(a)
                 end
-                local userdata = li[4]
-                if userdata then
-                    local b = userdata.btxbtx
-                    local a = userdata.btxatx
-                    if b then
-                        ctx_btxsetbefore(b)
-                    end
-                    if a then
-                        ctx_btxsetafter(a)
-                    end
+            end
+            rendering.userdata = userdata
+            if textmode then
+                ctx_btxhandlelisttextentry()
+            else
+                ctx_btxhandlelistentry()
+            end
+            ctx_btxstoplistentry()
+            --
+         -- context(function()
+         --     -- wrapup
+         --     rendering.ignoredfields = nil
+         -- end)
+        end
+    end
+
+
+if ctx_setmacro then -- no real gain, but nice as test
+
+    function lists.flushentry(dataset,i,textmode)
+        local rendering = renderings[dataset]
+        local list      = rendering.list
+        local luadata   = datasets[dataset].luadata
+        local li        = list[i]
+        if li then
+            local tag       = li[1]
+            local listindex = li[2]
+            local n         = li[3]
+            local entry     = luadata[tag]
+            --
+            ctx_btxstartlistentry()
+            ctx_setmacro("currentbtxlistentry",i) -- redundant
+            ctx_setmacro("currentbtxlistindex",listindex)
+            local combined = entry.combined
+            local language = entry.language
+            if combined then
+                ctx_setmacro("currentbtxcombis",concat(combined,","))
+            end
+            ctx_setmacro("currentbtxcategory",entry.category or "unknown")
+            ctx_setmacro("currentbtxtag",tag)
+            ctx_setmacro("currentbtxnumber",n)
+            if language then
+                ctx_setmacro("currentbtxlanguage",language)
+            end
+            local bl = li[5]
+            if bl and bl ~= "" then
+                ctx_setmacro("currentbtxbacklink",bl)
+                ctx_setmacro("currentbtxbacktrace",concat(li," ",5))
+                local uc = citetolist[tonumber(bl)]
+                if uc then
+                    ctx_setmacro("currentbtxinternal",uc.references.internal or "")
                 end
-                rendering.userdata = userdata
-                if textmode then
-                    ctx_btxhandlelisttextentry()
-                else
-                    ctx_btxhandlelistentry()
+            else
+                -- nothing
+            end
+            local userdata = li[4]
+            if userdata then
+                local b = userdata.btxbtx
+                local a = userdata.btxatx
+                if b then
+                    ctx_setmacro("currentbtxbefore",b)
+                end
+                if a then
+                    ctx_setmacro("currentbtxafter",a)
                 end
             end
+            rendering.userdata = userdata
+            if textmode then
+                ctx_btxhandlelisttextentry()
+            else
+                ctx_btxhandlelistentry()
+            end
+            ctx_btxstoplistentry()
+            --
+         -- context(function()
+         --     -- wrapup
+         --     rendering.ignoredfields = nil
+         -- end)
         end
-        context(function()
-            -- wrapup
-            ignoredfields = nil
-            setspecification(false)
-        end)
     end
 
+end
+
     local function getuserdata(dataset,key)
         local rendering = renderings[dataset]
         if rendering then
@@ -1813,13 +2004,14 @@ do
         end
     end
 
-    commands.btxresolvelistreference = lists.resolve
-    commands.btxaddtolist            = lists.addentry
-    commands.btxcollectlistentries   = lists.collectentries
-    commands.btxpreparelistentries   = lists.prepareentries
-    commands.btxfetchlistentries     = lists.fetchentries
-    commands.btxflushlistentries     = lists.flushentries
-    commands.btxflushlistentry       = lists.flushentry
+    commands.btxresolvelistreference   = lists.resolve
+    commands.btxaddtolist              = lists.addentry
+    commands.btxcollectlistentries     = lists.collectentries
+    commands.btxpreparelistentries     = lists.prepareentries
+    commands.btxfetchlistentries       = lists.fetchentries
+    commands.btxflushlistentry         = lists.flushentry
+
+    commands.btxdoifelsesameasprevious = function(...) ctx_doifelse(lists.sameasprevious(...)) end
 
 end
 
@@ -1829,9 +2021,12 @@ do
     publications.citevariants = citevariants
 
     function commands.btxhandlecite(specification)
-        local dataset   = specification.dataset or "" -- standard
+        local dataset   = specification.dataset or v_default
         local reference = specification.reference
-        local variant   = specification.variant or defaultvariant
+        local variant   = specification.variant
+        if not variant or variant == "" then
+            variant = "default"
+        end
         if not reference or reference == "" then
             return
         end
@@ -1842,11 +2037,11 @@ do
         --
         local prefix, rest = lpegmatch(prefixsplitter,reference)
         if prefix and rest then
+            dataset = prefix
             specification.dataset   = prefix
             specification.reference = rest
         end
         --
-        --
         if trace_cite then
             report_cite("inject, dataset: %s, tag: %s, variant: %s, compressed",
                 specification.dataset or "-",
@@ -1855,14 +2050,14 @@ do
             )
         end
         --
-        ctx_setvalue("currentbtxdataset",dataset)
+        ctx_btxsetdataset(dataset)
         --
         citevariants[variant](specification) -- we always fall back on default
     end
 
 
     function commands.btxhandlenocite(specification)
-        local dataset   = specification.dataset or "" -- standard
+        local dataset   = specification.dataset or v_default
         local reference = specification.reference
         if not reference or reference == "" then
             return
@@ -1901,7 +2096,21 @@ do
 
     -- sorter
 
-    local keysorter = function(a,b) return a.sortkey < b.sortkey end
+    local keysorter = function(a,b)
+        local ak = a.sortkey
+        local bk = b.sortkey
+        if ak == bk then
+            local as = a.suffix -- alphabetic
+            local bs = b.suffix -- alphabetic
+            if as and bs then
+                return (as or "") < (bs or "")
+            else
+                return false
+            end
+        else
+            return ak < bk
+        end
+    end
 
     --     local suffix   = 0
     --     local function setsuffix(entry,suffix,sortfld)
@@ -1940,7 +2149,12 @@ do
 
     local function compresslist(source)
         for i=1,#source do
-            if type(source[i].sortkey) ~= "number" then
+            local t = type(source[i].sortkey)
+            if t == "number" then
+                -- okay
+         -- elseif t == "string" then
+         --     -- okay
+            else
                 return source
             end
         end
@@ -1968,6 +2182,7 @@ do
         for i=1,#source do
             local entry = source[i]
             local current = entry.sortkey
+            local suffix  = entry.suffix -- todo but what
             if not first then
                 first, last, firstr, lastr = current, current, entry, entry
             elseif current == last + 1 then
@@ -2016,49 +2231,52 @@ do
         local setter     = specification.setter
         local compressor = specification.compressor
         --
-
         local reference  = publications.parenttag(dataset,reference)
         --
         local found, todo, list = findallused(dataset,reference,internal)
         tobemarked = specification.markentry and todo
         --
-        if not found then
+        if not found or #found == 0 then
             report("nothing found for %a",reference)
         elseif not setup then
             report("invalid reference for %a",reference)
         else
+            if trace_cite then
+                report("processing reference %a",reference)
+            end
             local source  = { }
             local badkey  = false
             local luadata = datasets[dataset].luadata
             for i=1,#found do
-                local entry    = found[i]
-                local tag      = entry.userdata.btxref
-                -- we can probably move the test into the flush
-             -- local category = luadata[tag].category
-             -- if currentspecificationfields[category][setup] then
-                    local internal = entry.references.internal
-                    local data     = setter(dataset,tag,entry,internal)
-                    if compress and not compressor then
-                        local sortkey = data.sortkey
-                        if sortkey then
-                            local key = lpegmatch(numberonly,sortkey)
-                            if key then
-                                data.sortkey = key
-                            else
-                                badkey = true
-                            end
+                local entry = found[i]
+                local tag   = entry.userdata.btxref
+                local ldata = luadata[tag]
+                local data  = {
+                    internal  = entry.references.internal,
+                    language  = ldata.language,
+                    dataset   = dataset,
+                    tag       = tag,
+                 -- luadata   = ldata,
+                }
+                setter(data,dataset,tag,entry)
+                if compress and not compressor then
+                    local sortkey = data.sortkey
+                    if sortkey then
+                        local key = lpegmatch(numberonly,sortkey)
+                        if key then
+                            data.sortkey = key
                         else
                             badkey = true
                         end
-                    end
-                    if type(data) == "table" then
-                        source[#source+1] = data
                     else
-                        report("error in cite rendering %a",setup or "?")
+                        badkey = true
                     end
-             -- else
-             --     report("cite rendering %a is not available for %a",setup,category)
-             -- end
+                end
+                if type(data) == "table" then
+                    source[#source+1] = data
+                else
+                    report("error in cite rendering %a",setup or "?")
+                end
             end
 
             local lefttext  = specification.lefttext
@@ -2071,6 +2289,9 @@ do
             if before    and before    ~= "" then before    = settings_to_array(before)    end
             if after     and after     ~= "" then after     = settings_to_array(after)     end
 
+            local oneleft  = lefttext  and #lefttext  == 1 and lefttext [1]
+            local oneright = righttext and #righttext == 1 and righttext[1]
+
             local function flush(i,n,entry,last)
                 local tag = entry.tag
                 local currentcitation = markcite(dataset,tag)
@@ -2078,10 +2299,26 @@ do
                 ctx_btxstartcite()
                 ctx_btxsettag(tag)
                 --
-                if lefttext  then ctx_btxsetlefttext (lefttext [i] or #lefttext   == 1 and lefttext [1] or "")  end
-                if righttext then ctx_btxsetrighttext(righttext[i] or #righttext  == 1 and righttext[1] or "")  end
-                if before    then ctx_btxsetbefore   (before   [i] or #before     == 1 and before   [1] or "")  end
-                if after     then ctx_btxsetafter    (after    [i] or #after      == 1 and after    [1] or "")  end
+                if oneleft then
+                    if i == 1 then
+                        ctx_btxsetlefttext(oneleft)
+                    end
+                elseif lefttext then
+                    ctx_btxsetlefttext(lefttext[i] or "")
+                end
+                if oneright then
+                    if i == n then
+                        ctx_btxsetrighttext(oneright)
+                    end
+                elseif righttext then
+                    ctx_btxsetrighttext(righttext[i] or "")
+                end
+                if before then
+                    ctx_btxsetbefore(before[i] or #before == 1 and before[1] or "")
+                end
+                if after then
+                    ctx_btxsetafter(after[i] or #after == 1 and after[1] or "")
+                end
                 --
                 ctx_btxsetbacklink(currentcitation)
                 local bl = listtocite[currentcitation]
@@ -2097,7 +2334,7 @@ do
                     ctx_btxsetlanguage(language)
                 end
                 if not getter(entry,last) then
-                    ctx_btxsetfirst(f_missing(tag))
+                    ctx_btxsetfirst("") -- (f_missing(tag))
                 end
                 ctx_btxsetconcat(concatstate(i,n))
                 if trace_detail then
@@ -2155,15 +2392,12 @@ do
     end
 
     local setters = setmetatableindex({},function(t,k)
-        local v = function(dataset,tag,entry,internal)
-            local value = getfield(dataset,tag,k)
-            return {
-                tag      = tag,
-                internal = internal,
-                [k]      = value,
-                sortkey  = value,
-                sortfld  = k,
-            }
+        local v = function(data,dataset,tag,entry)
+            local value = getcasted(dataset,tag,k)
+            data.value   = value -- not really needed
+            data[k]      = value
+            data.sortkey = value
+            data.sortfld = k
         end
         t[k] = v
         return v
@@ -2178,66 +2412,28 @@ do
     end)
 
     setmetatableindex(citevariants,function(t,k)
-        local p = registeredcitevariants[k]
-        local v = nil
-        if p and p ~= "" then
-            v = rawget(t,p)
-        end
-        if not v then
-            p = defaultvariant or "default"
-            v = rawget(t,p)
-        end
-        report_cite("variant %a falls back on %a",k,p)
+        local p = defaultvariant or "default"
+        local v = rawget(t,p)
+        report_cite("variant %a falls back on %a setter and getter with setup %a",k,p,k)
         t[k] = v
         return v
     end)
 
-    function citevariants.default(presets) -- no longer used
+    function citevariants.default(presets)
         local variant = presets.variant
         processcite(presets,{
-            setter = setters[variant],
-            getter = getters[variant],
+            setup   = variant,
+            setter  = setters[variant],
+            getter  = getters[variant],
         })
     end
 
-    --
-
- -- -- what to do with sort .. todo: sorters by type
-
- -- function citevariants.handler(key)
- --     local function setter(dataset,tag,entry,internal)
- --         return {
- --             dataset  = dataset,
- --             tag      = tag,
- --             internal = internal,
- --             category = getfield(dataset,tag,key),
- --         }
- --     end
- --     local function getter(first,last)
- --         return simplegetter(first,last,key)
- --     end
- --     return function(presets)
- --         processcite(presets,{
- --             setter  = setter,
- --             getter  = getter,
- --         })
- --     end
- -- end
- --
- -- citevariants.category = citevariants.handler("category")
- -- citevariants.type     = citevariants.handler("type")
-
     -- category | type
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                category = getfield(dataset,tag,"category"),
-            }
+        local function setter(data,dataset,tag,entry)
+            data.category = getfield(dataset,tag,"category")
         end
 
         local function getter(first,last)
@@ -2267,11 +2463,8 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                tag      = tag,
-                internal = internal,
-            }
+        local function setter(data,dataset,tag,entry)
+            -- nothing
         end
 
         local function getter(first,last) -- last not used
@@ -2293,13 +2486,9 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                tag      = tag,
-                internal = internal,
-                short    = getdetail(dataset,tag,"short"),
-                suffix   = getdetail(dataset,tag,"suffix"),
-            }
+        local function setter(data,dataset,tag,entry)
+            data.short  = getdetail(dataset,tag,"short")
+            data.suffix = getdetail(dataset,tag,"suffix")
         end
 
         local function getter(first,last) -- last not used
@@ -2330,13 +2519,8 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                pages    = getcasted(dataset,tag,"pages"),
-            }
+        local function setter(data,dataset,tag,entry)
+            data.pages = getcasted(dataset,tag,"pages")
         end
 
         local function getter(first,last)
@@ -2366,15 +2550,11 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
+        local function setter(data,dataset,tag,entry)
             local entries = entry.entries
-            local text = entries and entries.text or "?"
-            return {
-                tag      = tag,
-                internal = internal,
-                num      = text,
-                sortkey  = text,
-            }
+            local text    = entries and entries.text or "?"
+            data.num      = text
+            data.sortkey  = text
         end
 
         local function getter(first,last)
@@ -2395,15 +2575,12 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                year     = getfield(dataset,tag,"year"),
-                suffix   = getdetail(dataset,tag,"suffix"),
-                sortkey  = getdetail(dataset,tag,"suffixedyear"),
-            }
+        local function setter(data,dataset,tag,entry)
+            local year   = getfield (dataset,tag,"year")
+            local suffix = getdetail(dataset,tag,"suffix")
+            data.year    = year
+            data.suffix  = suffix
+            data.sortkey = tonumber(year) or 0
         end
 
         local function getter(first,last)
@@ -2424,15 +2601,10 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
+        local function setter(data,dataset,tag,entry)
             local index = getfield(dataset,tag,"index")
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                index    = index,
-                sortkey  = index,
-            }
+            data.index   = index
+            data.sortkey = index
         end
 
         local function getter(first,last)
@@ -2461,12 +2633,8 @@ do
 
     do
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-            }
+        local function setter(data,dataset,tag,entry)
+            -- nothing
         end
 
         local function getter(first,last)
@@ -2492,6 +2660,44 @@ do
 
     end
 
+    -- keyword
+
+    do
+
+        local function listof(list)
+            local size = type(list) == "table" and #list or 0
+            if size > 0 then
+                return function()
+                    for i=1,size do
+                        ctx_btxsetfirst(list[i])
+                        ctx_btxsetconcat(concatstate(i,size))
+                        ctx_btxcitesetup("listelement")
+                    end
+                    return true
+                end
+            else
+                return "?" -- unknown
+            end
+        end
+
+        local function setter(data,dataset,tag,entry)
+            data.keywords = getcasted(dataset,tag,"keywords")
+        end
+
+        local function getter(first,last)
+            context(listof(first.keywords))
+        end
+
+        function citevariants.keywords(presets)
+            return processcite(presets,{
+                variant = "keywords",
+                setter  = setter,
+                getter  = getter,
+            })
+        end
+
+    end
+
     -- authors
 
     do
@@ -2516,6 +2722,8 @@ do
                     end
                 end
             end
+            -- beware: we usetables as hash so we get a cycle when inspecting (unless we start
+            -- hashing with strings)
             for i=1,#found do
                 local entry  = found[i]
                 local author = entry.author
@@ -2553,7 +2761,7 @@ do
                     local bl = listtocite[currentcitation]
                     ctx_btxsetinternal(bl and bl.references.internal or "")
                     if first then
-                        ctx_btxsetfirst(first[key] or f_missing(first.tag))
+                        ctx_btxsetfirst(first[key] or "") -- f_missing(first.tag))
                         local suffix = entry.suffix
                         local value  = entry.last[key]
                         if value then
@@ -2564,7 +2772,7 @@ do
                         end
                     else
                         local suffix = entry.suffix
-                        local value  = entry[key] or f_missing(tag)
+                        local value  = entry[key] or "" -- f_missing(tag)
                         ctx_btxsetfirst(value)
                         if suffix then
                             ctx_btxsetthird(suffix)
@@ -2572,7 +2780,7 @@ do
                     end
                     ctx_btxsetconcat(concatstate(i,nofcollected))
                     if trace_detail then
-                        report("expanding %a cite setup %a","single author",setup)
+                        report("expanding %a cite setup %a","multiple author",setup)
                     end
                     ctx_btxcitesetup(setup)
                     ctx_btxstopciteauthor()
@@ -2590,10 +2798,12 @@ do
          -- ctx_btxsetbacklink(currentcitation)
          -- local bl = listtocite[currentcitation]
          -- ctx_btxsetinternal(bl and bl.references.internal or "")
-            ctx_btxsetfirst(entry[key] or f_missing(tag))
-            ctx_btxsetthird(entry.suffix)
+            ctx_btxsetfirst(entry[key] or "") -- f_missing(tag)
+            if suffix then
+                ctx_btxsetthird(entry.suffix)
+            end
             if trace_detail then
-                report("expanding %a cite setup %a","multiple author",setup)
+                report("expanding %a cite setup %a","single author",setup)
             end
             ctx_btxcitesetup(setup)
             ctx_btxstopciteauthor()
@@ -2604,7 +2814,12 @@ do
 
         local function authorgetter(first,last,key,setup) -- only first
          -- ctx_btxsetfirst(first.author)         -- unformatted
-            ctx_btxsetfirst(currentbtxciteauthor) -- formatter (much slower)
+         -- ctx_btxsetfirst(currentbtxciteauthor) -- formatter (much slower)
+            if first.type == "author" then
+                ctx_btxsetfirst(currentbtxciteauthor) -- formatter (much slower)
+            else
+                ctx_btxsetfirst(first.author)         -- unformatted
+            end
             local entries = first.entries
             -- alternatively we can use a concat with one ... so that we can only make the
             -- year interactive, as with the concat
@@ -2612,11 +2827,13 @@ do
                 entries = { first }
             end
             if entries then
+                -- happens with year
                 local c = compresslist(entries)
                 local f = function() authorconcat(c,key,setup) return true end -- indeed return true?
                 ctx_btxsetcount(#c)
                 ctx_btxsetsecond(f)
-            else
+            elseif first then
+                -- happens with num
                 local f = function() authorsingle(first,key,setup) return true end -- indeed return true?
                 ctx_btxsetcount(0)
                 ctx_btxsetsecond(f)
@@ -2626,18 +2843,16 @@ do
 
         -- author
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                author   = getcasted(dataset,tag,"author"),
-            }
+        local function setter(data,dataset,tag,entry)
+            data.author, data.field, data.type = getcasted(dataset,tag,"author")
         end
 
         local function getter(first,last,_,setup)
-         -- ctx_btxsetfirst(first.author)         -- unformatted
-            ctx_btxsetfirst(currentbtxciteauthor) -- formatter (much slower)
+            if first.type == "author" then
+                ctx_btxsetfirst(currentbtxciteauthor) -- formatter (much slower)
+            else
+                ctx_btxsetfirst(first.author)         -- unformatted
+            end
             return true
         end
 
@@ -2652,16 +2867,12 @@ do
 
         -- authornum
 
-        local function setter(dataset,tag,entry,internal)
-            local text = entry.entries.text
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                author   = getcasted(dataset,tag,"author"),
-                num      = text,
-                sortkey  = text and lpegmatch(numberonly,text),
-            }
+        local function setter(data,dataset,tag,entry)
+            local entries = entry.entries
+            local text    = entries and entries.text or "?"
+            data.author, data.field, data.type = getcasted(dataset,tag,"author")
+            data.num     = text
+            data.sortkey = text and lpegmatch(numberonly,text)
         end
 
         local function getter(first,last)
@@ -2680,16 +2891,13 @@ do
 
         -- authoryear | authoryears
 
-        local function setter(dataset,tag,entry,internal)
-            return {
-                dataset  = dataset,
-                tag      = tag,
-                internal = internal,
-                author   = getcasted(dataset,tag,"author"),
-                year     = getfield(dataset,tag,"year"),
-                suffix   = getdetail(dataset,tag,"suffix"),
-                sortkey  = getdetail(dataset,tag,"suffixedyear"),
-            }
+        local function setter(data,dataset,tag,entry)
+            data.author, data.field, data.type = getcasted(dataset,tag,"author")
+            local year   = getfield (dataset,tag,"year")
+            local suffix = getdetail(dataset,tag,"suffix")
+            data.year    = year
+            data.suffix  = suffix
+            data.sortkey = tonumber(year) or 0
         end
 
         local function getter(first,last)
diff --git a/tex/context/base/publ-ini.mkiv b/tex/context/base/publ-ini.mkiv
index c9670f535..e0e0489ab 100644
--- a/tex/context/base/publ-ini.mkiv
+++ b/tex/context/base/publ-ini.mkiv
@@ -93,58 +93,67 @@
 
 % The main rendering style (standard driven).
 
-\installcorenamespace {btx}
-
-\installsimplecommandhandler \??btx {btx} \??btx
-
-% \newconstant\btxmode
-% \newconstant\btxnonemode
-% \newconstant\btxcitemode
-% \newconstant\btxlistmode
-
-%D Loading variants:
+%D We assume that a specification is global or used grouped. It doesn't make much sense
+%D to split between cite and list here as it only complicates matters (timing) and is
+%D not clear either.
 
-\let\currentbtxrenderingdefinition\empty
-\let\currentbtxspecification      \empty
+\let\currentbtxspecification\empty
 
 \unexpanded\def\startbtxrenderingdefinitions[#1]%
-  {\pushmacro\currentbtxrenderingdefinition
-   \edef\currentbtxrenderingdefinition{#1}%
-   \letvalue{\??btxrenderingdefinition\currentbtxrenderingdefinition}\currentbtxrenderingdefinition
-   \unprotect}
+  {\unprotect
+   \pushmacro\currentbtxspecification
+   \edef\currentbtxspecification{#1}}
 
 \unexpanded\def\stopbtxrenderingdefinitions
-  {\protect
-   \popmacro\currentbtxrenderingdefinition}
+  {\popmacro\currentbtxspecification
+   \protect}
 
 \unexpanded\def\loadbtxdefinitionfile[#1]%
   {\ctxcommand{loadbtxdefinitionfile("#1")}}
 
-\appendtoks
-    \edef\currentbtxspecification{\btxparameter\c!specification}%
-    \ifcsname\??btxrenderingdefinition\currentbtxspecification\endcsname
-        % maybe fall back on 4 ?
-    \else
-        \loadbtxdefinitionfile[\currentbtxspecification]%
-        \showmessage\m!publications{14}{\currentbtxspecification}%
-    \fi
-\to \everysetupbtx
+\unexpanded\def\loadbtxreplacementfile[#1]%
+  {\ctxcommand{loadbtxreplacementfile("#1")}}
 
-\unexpanded\def\publ_specification_push#1% local, don't override
+\unexpanded\def\publ_specification_push#1%
   {\pushmacro\currentbtxspecification
+   \pushmacro\currentbtxspecificationfallback
    \edef\currentbtxspecification{#1}%
+   \edef\currentbtxspecificationfallback{\namedbtxparameter\currentbtxspecification\c!default}%
+   \ifx\currentbtxspecificationfallback\currentbtxspecification
+     \let\currentbtxspecificationfallback\empty
+   \fi
    \ctxcommand{setbtxspecification("\currentbtxspecification")}}
 
 \unexpanded\def\publ_specification_pop
-  {\popmacro\currentbtxspecification
+  {\popmacro\currentbtxspecificationfallback
+   \popmacro\currentbtxspecification
    \ctxcommand{setbtxspecification("\currentbtxspecification")}}
 
 \unexpanded\def\publ_specification_set#1% beware: is global
   {\edef\currentbtxspecification{#1}%
-   \ctxcommand{setbtxspecification("\currentbtxspecification")}}
+   \edef\currentbtxspecificationfallback{\namedbtxparameter\currentbtxspecification\c!default}%
+   \ifx\currentbtxspecificationfallback\currentbtxspecification
+     \let\currentbtxspecificationfallback\empty
+   \fi
+  % has to be done explicitly: \loadbtxdefinitionfile[\currentbtxspecification]%
+   \ctxcommand{setbtxspecification("\currentbtxspecification")}}% todo: ,true == also load
+
+\installcorenamespace {btx}
+
+\installswitchcommandhandler \??btx {btx} \??btx
 
 \appendtoks
-    \publ_specification_set{\btxparameter\c!specification}%
+    \ifnum\btxsetupmode=\doingrootsetuproot
+        \publ_specification_set{\btxparameter\c!specification}%
+    \else\ifnum\btxsetupmode=\doingrootsetupnamed
+        \publ_specification_set{\btxparameter\c!specification}%
+    \fi\fi
+\to \everysetupbtx
+
+\appendtoks
+    \ifnum\btxsetupmode=\doingrootsetuproot
+        \edef\currentbtxdataset{\ctxcommand{setbtxdataset("\btxparameter\c!dataset","\currentbtxdataset")}}%
+    \fi
 \to \everysetupbtx
 
 \appendtoks
@@ -156,226 +165,68 @@
 
 \let\stopusingbtxspecification\publ_specification_pop
 
-% a dedicated construction mechanism
-
-\installcorenamespace {btxlist}
-
-\installcommandhandler \??btxlist {btxlist} \??btxlist
-
-\unexpanded\setvalue{\??constructioninitializer\v!btxlist}%
-  {\let\currentbtxlist                  \currentconstruction
-   \let\constructionparameter           \btxlistparameter
-   \let\constructionnamespace           \??btxlist
-   \let\detokenizedconstructionparameter\detokenizedbtxlistparameter
-   \let\letconstructionparameter        \letbtxlistparameter
-   \let\useconstructionstyleandcolor    \usebtxliststyleandcolor
-   \let\setupcurrentconstruction        \setupcurrentbtxlist}
-
-\expandafter\let\csname\??constructionmainhandler   \v!btxlist\expandafter\endcsname\csname\??constructionmainhandler   \v!construction\endcsname
-\expandafter\let\csname\??constructioncommandhandler\v!btxlist\expandafter\endcsname\csname\??constructioncommandhandler\v!construction\endcsname
-\expandafter\let\csname\??constructiontexthandler   \v!btxlist\expandafter\endcsname\csname\??constructiontexthandler   \v!construction\endcsname
-
-\unexpanded\setvalue{\??constructioncommandhandler\v!btxlist}%
-  {\csname\??constructionstarthandler\v!construction\endcsname
-   \csname\??constructionstophandler \v!construction\endcsname
-   \endgroup}
-
-\unexpanded\def\startbtxlistentry#1%
-  {\begingroup
-   \strc_constructions_initialize{#1}%
-   \csname\??constructionstarthandler\currentconstructionhandler\endcsname}
-
-\unexpanded\def\stopbtxlistentry
-  {\csname\??constructionstophandler\currentconstructionhandler\endcsname}
-
-% interactivity is handled in setups
-
-\unexpanded\setvalue{\??constructiontexthandler\v!btxlist}%
-  {\begingroup
-   \fastsetup{\v!btxrendering:\v!number:\constructionparameter\c!number}%
-   \endgroup}
-
-% the whole entry can be interactive
-
-\unexpanded\setvalue{\??constructionstarthandler\v!btxlist}%
-  {\csname\??constructionstarthandler\v!construction\endcsname
-   \ifconditional\btx_interactive
-     \ifx\currentbtxnumbering\v!no\else
-       \ifx\currentbtxinternal\empty \else
-         \startgoto[\s!internal(\currentbtxinternal)]%
-       \fi
-     \fi
-   \fi}
-
-\unexpanded\setvalue{\??constructionstophandler\v!btxlist}%
-  {\ifconditional\btx_interactive
-     \ifx\currentbtxnumbering\v!no\else
-       \ifx\currentbtxinternal\empty \else
-         \stopgoto
-       \fi
-     \fi
-   \fi
-   \csname\??constructionstophandler\v!construction\endcsname
-   \endgroup}
-
-\startsetups[\v!btxrendering:\v!number:\v!no]
-    % \btx_reference_checked % needs testing
-\stopsetups
-
-\startsetups[\v!btxrendering:\v!number:\v!yes]
-   \useconstructionstyleandcolor\c!headstyle\c!headcolor % move to \currentconstructiontext
-   \the\everyconstruction
-   \relax
-   \strut
-   \constructionparameter\c!text
-   \btx_list_reference_inject
-   \relax
-\stopsetups
-
-% construction (todo:low level builder commands without using the constructor)
-
-\unexpanded\def\strc_constructions_initialize#1% class instance
-  {\edef\currentconstruction{#1}%
-   \let\currentconstructionlistentry\!!zerocount
-   \expandafter\let\expandafter\currentconstructionmain   \csname\??constructionmain \currentconstruction\endcsname
-   \expandafter\let\expandafter\currentconstructionlevel  \csname\??constructionlevel\currentconstruction\endcsname
-   \expandafter\let\expandafter\currentconstructionhandler\csname\??constructionclass\currentconstruction\endcsname
-   \csname\??constructioninitializer\currentconstructionhandler\endcsname}
-
-\appendtoks
-  % \ifx\currentbtxlistparent\empty
-  %     \defineconstruction[\currentbtxlist][\currentbtxlistparent][\s!handler=\v!btxlist,\c!level=1]%
-  % \else
-  %     \defineconstruction[\currentbtxlist][\s!handler=\v!btxlist,\c!level=1]%
-  % \fi
-    \ifx\currentbtxlistparent\empty
-        \letvalue{\??constructionmain\currentbtxlist}\currentbtxlist
-    \else
-        \letvalue{\??constructionmain\currentbtxlist}\currentbtxlistparent
-    \fi
-    \setevalue{\??constructionlevel\currentbtxlist}{\number\btxlistparameter\c!level}%
-    \setevalue{\??constructionclass\currentbtxlist}{\btxlistparameter\s!handler}%
-\to \everydefinebtxlist
-
-\setupbtxlist
-  [\s!handler=\v!btxlist,
-   \c!level=1]
-
-\setupbtxlist
-  [\c!alternative=\v!left,
-   \c!headstyle=,
-   \c!titlestyle=,
-  %\c!style=,
-  %\c!color=,
-  %\c!headcolor=,
-  %\c!titlecolor=,
-   \c!width=4\emwidth,
-   \c!distance=\emwidth,
-  %\c!titledistance=.5\emwidth,
-  %\c!hang=,
-  %\c!sample=,
-  %\c!align=,
-  %\c!headalign=,
-   \c!margin=\v!no,
-   \c!before=\blank,
-   \c!inbetween=\blank,
-   \c!after=\blank,
-  %\c!indentnext=\v!yes,
-  %\c!indenting=\v!never,
-  %\c!titleleft=(,
-  %\c!titleright=),
-  %\c!closesymbol=,
-  %\c!closecommand=\wordright,
-   \c!display=\v!yes,
-   \c!command=,
-  %\c!titlecommand=,
-  %\c!expansion=\v!no,
-  %\c!xmlsetup=,
-  %\s!catcodes=,
-  %\c!title=\v!yes,
-  %\c!text=,
-  \c!number=\v!yes,
-  ]
+% \setupbtxlist[alternative=paragraph,width=auto,distance=\emwidth]
+% \setupbtxlist[alternative=paragraph,width=auto,distance=\emwidth,margin=2em] % useless
+% \setupbtxlist[alternative=paragraph,width=fit,distance=\emwidth]
+% \setupbtxlist[alternative=paragraph,width=fit,distance=\emwidth,margin=2em]
 
 % here starts the bib stuff
 
 \installcorenamespace {btxdataset}
-\installcorenamespace {btxlistvariant}
-\installcorenamespace {btxcitevariant}
 \installcorenamespace {btxrendering}
 \installcorenamespace {btxregister}
 \installcorenamespace {btxcommand}
 \installcorenamespace {btxrenderingdefinition}
 
-\installcommandhandler \??btxdataset     {btxdataset}     \??btxdataset
-\installcommandhandler \??btxlistvariant {btxlistvariant} \??btxlistvariant
-\installcommandhandler \??btxcitevariant {btxcitevariant} \??btxcitevariant
-\installcommandhandler \??btxregister    {btxregister}    \??btxregister
-\installcommandhandler \??btxrendering   {btxrendering}   \??btxrendering
-
-%D The following two helpers permits us to use prefixes (if we want):
-%D
-%D \startbuffer
-%D \let\btxciteparameter\btxspecificationciteparameter
-%D \let\btxlistparameter\btxspecificationlistparameter
-%D
-%D \edef\currentbtxspecification  {apa}
-%D \edef\currentbtxcitealternative{author}
-%D
-%D \setupbtxcitevariant                             [crap=crap]
-%D \definebtxcitevariant [author]                   [check=author,extra=author]
-%D \definebtxcitevariant [authoryear]  [author]     [check=authoryear]
-%D \definebtxcitevariant [authoryears] [authoryear] [check=authoryears]
-%D \setupbtxcitevariant  [author]                   [apa:check=apa-author]
-%D \setupbtxcitevariant  [authoryear]               [apa:check=apa-authoryear]
-%D
-%D \starttabulate[|lT|lT|]
-%D     \NC \bf check \EQ \btxciteparameter{check} \NC\NR
-%D     \NC \bf extra \EQ \btxciteparameter{extra} \NC\NR
-%D     \NC \bf crap  \EQ \btxciteparameter{crap}  \NC\NR
-%D \stoptabulate
-%D \stopbuffer
-%D
-%D \typebuffer \start \getbuffer \stop
-
-\def\btxspecificationciteparameter#1%
-  {\csname
-     \??btxcitevariant
-     \ifcsname\??btxcitevariant\currentbtxcitealternative:\currentbtxspecification:#1\endcsname
-       \currentbtxcitealternative:\currentbtxspecification:#1%
-     \else\ifcsname\??btxcitevariant\currentbtxcitealternative:#1\endcsname
-       \currentbtxcitealternative:#1%
-     \else
-       :#1% we assume defined variants
-     \fi\fi
-   \endcsname}
-
-\def\btxspecificationlistparameter#1%
-  {\csname
-     \??btxlistvariant
-     \ifcsname\??btxlistvariant\currentbtxlistalternative:\currentbtxspecification:#1\endcsname
-       \currentbtxlistalternative:\currentbtxspecification:#1%
-     \else\ifcsname\??btxlistvariant\currentbtxlistalternative:#1\endcsname
-       \currentbtxlistalternative:#1%
-     \else
-       :#1% we assume defined variants
-     \fi\fi
-   \endcsname}
-
-% \let\btxciteparameter\btxspecificationciteparameter
-% \let\btxlistparameter\btxspecificationlistparameter
-
-\appendtoks
-    \ifx\currentbtxlistvariant\empty \else
-        \ctxcommand{registerbtxlistvariant("\currentbtxlistvariant","\currentbtxlistvariantparent")}%
-    \fi
-\to \everydefinebtxlistvariant
-
-\appendtoks
-    \ifx\currentbtxcitevariant\empty \else
-        \ctxcommand{registerbtxcitevariant("\currentbtxcitevariant","\currentbtxcitevariantparent")}%
-    \fi
-\to \everydefinebtxcitevariant
+\installcommandhandler \??btxdataset   {btxdataset}   \??btxdataset
+\installcommandhandler \??btxregister  {btxregister}  \??btxregister
+\installcommandhandler \??btxrendering {btxrendering} \??btxrendering
+
+% named: check all listvariant and citevariant
+
+\let\currentbtxcitevariant\empty
+\let\currentbtxlistvariant\empty
+
+\let\currentbtxspecificationfallback\empty
+
+\unexpanded\def\setbtxparameterset#1#2%
+  {\edef\currentbtx
+     {\ifcsname\??btx\currentbtxspecification:#1:#2:\s!parent\endcsname
+        \currentbtxspecification:%
+      \else\ifx\currentbtxspecificationfallback\empty
+      \else\ifcsname\??btx\currentbtxspecificationfallback:#1:#2:\s!parent\endcsname
+        \currentbtxspecificationfallback:%
+      \fi\fi\fi#1:#2}}
+
+\unexpanded\def\setbtxparametersetroot#1%
+  {\edef\currentbtx
+     {\ifcsname\??btx\currentbtxspecification:#1:\s!parent\endcsname
+        \currentbtxspecification:#1%
+      \else\ifx\currentbtxspecificationfallback\empty
+      \else\ifcsname\??btx\currentbtxspecificationfallback:#1:\s!parent\endcsname
+        \currentbtxspecificationfallback:#1%
+      \fi\fi\fi}}
+
+\unexpanded\def\setbtxrendering
+  {\edef\currentbtxrendering
+     {\ifcsname\??btx\currentbtxspecification:\s!parent\endcsname
+        \currentbtxspecification
+      \else\ifx\currentbtxspecificationfallback\empty
+      \else\ifcsname\??btx\currentbtxspecificationfallback:\s!parent\endcsname
+        \currentbtxspecificationfallback
+      \fi\fi\fi}}
+
+\unexpanded\def\setbtxlist % maybe simplify this one, always list=rendering?
+  {\edef\currentbtxlist
+     {\ifcsname\??btx\currentbtxrendering:\s!parent\endcsname
+        \currentbtxrendering
+      \else\ifcsname\??btx\currentbtxspecification:\s!parent\endcsname
+        \currentbtxspecification
+      \else\ifx\currentbtxspecificationfallback\empty
+      \else\ifcsname\??btx\currentbtxspecificationfallback:\s!parent\endcsname
+        \currentbtxspecificationfallback
+      \fi\fi\fi\fi}%
+   \edef\currentlist{\s!btx:\currentbtxlist}}
 
 \unexpanded\def\usebtxdataset
   {\begingroup
@@ -392,18 +243,18 @@
    \else\iffirstargument
      \ctxcommand{usebtxdataset{
         specification = "\dummyparameter\c!specification",
-        dataset       = "\v!standard",
+        dataset       = "\v!default",
         filename      = "#1",
      }}%
    \fi\fi
    \endgroup}
 
 \definebtxdataset
-  [\v!standard]
+  [\v!default]
 % [\c!language=] % nothing set so use current
 
 % \usebtxdataset
-%   [standard]
+%   [default]
 %   [mybibs.bib]
 
 \unexpanded\def\startpublication
@@ -423,11 +274,11 @@
    \fi\fi{#1}{#2}}
 
 \def\publ_set_publication_default#1#2%
-  {\publ_set_publication_indeed\v!standard{#1}}
+  {\publ_set_publication_indeed\v!default{#1}}
 
 \def\publ_set_publication_checked#1#2%
   {\doifassignmentelse{#1}
-     {\publ_set_publication_indeed\v!standard{#1}}
+     {\publ_set_publication_indeed\v!default{#1}}
      {\publ_set_publication_indeed{#1}{}}}
 
 \def\publ_set_publication_indeed#1#2#3\stoppublication
@@ -479,10 +330,7 @@
 % access
 
 \let\currentbtxtag    \empty
-\let\currentbtxdataset\v!standard
-
-\unexpanded\def\setbtxdataset[#1]%
-  {\edef\currentbtxdataset{\ctxcommand{setbtxdataset("#1","\currentbtxdataset")}}}
+\let\currentbtxdataset\v!default
 
 \unexpanded\def\setbtxentry[#1]%
   {\edef\currentbtxtag{\ctxcommand{setbtxentry("\currentbtxdataset","#1")}}}
@@ -495,17 +343,17 @@
 % \btxfield         : current
 % \btxspecificfield : dataset,tag,key
 
-\def\btxfield        #1{\ctxcommand{btxfield("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxdetail       #1{\ctxcommand{btxdetail("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxflush        #1{\ctxcommand{btxflush("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxfieldname    #1{\ctxcommand{btxfieldname("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxfieldtype    #1{\ctxcommand{btxfieldtype("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxfoundname    #1{\ctxcommand{btxfoundname("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxfoundtype    #1{\ctxcommand{btxfoundtype("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxauthorfield  #1{\ctxcommand{btxauthorfield(\number\currentbtxauthorindex,"#1")}}
-\def\btxdoifelse     #1{\ctxcommand{btxdoifelse("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxdoif         #1{\ctxcommand{btxdoif("\currentbtxdataset","\currentbtxtag","#1")}}
-\def\btxdoifnot      #1{\ctxcommand{btxdoifnot("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxfield      #1{\ctxcommand{btxfield("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxdetail     #1{\ctxcommand{btxdetail("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxflush      #1{\ctxcommand{btxflush("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxfieldname  #1{\ctxcommand{btxfieldname("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxfieldtype  #1{\ctxcommand{btxfieldtype("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxfoundname  #1{\ctxcommand{btxfoundname("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxfoundtype  #1{\ctxcommand{btxfoundtype("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxauthorfield#1{\ctxcommand{btxauthorfield(\number\currentbtxauthorindex,"#1")}}
+\def\btxdoifelse   #1{\ctxcommand{btxdoifelse("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxdoif       #1{\ctxcommand{btxdoif("\currentbtxdataset","\currentbtxtag","#1")}}
+\def\btxdoifnot    #1{\ctxcommand{btxdoifnot("\currentbtxdataset","\currentbtxtag","#1")}}
 
 \let\btxsetup\fastsetup
 
@@ -607,6 +455,26 @@
    \setconstant\currentbtxconcat     \zerocount
    \setconstant\currentbtxcount      \zerocount}
 
+%D Language:
+
+\def\mainbtxlanguage{\currentmainlanguage}
+
+\unexpanded\def\btx_check_language
+  {\let\mainbtxlanguage\currentlanguage
+   \ifx\currentbtxlanguage\empty
+     \let\currentbtxlanguage\currentlanguage
+   \else
+     \btx_check_language_indeed
+   \fi}
+
+\unexpanded\def\btx_check_language_indeed
+  {\edef\currentbtxlanguage{\reallanguagetag\currentbtxlanguage}%
+   \ifx\currentbtxlanguage\empty
+     \let\currentbtxlanguage\currentlanguage
+   \else\ifx\currentbtxlanguage\currentlanguage\else
+     \setcurrentlanguage\currentmainlanguage\currentbtxlanguage
+   \fi\fi}
+
 %D Tracing
 
 \newconditional\c_btx_trace
@@ -618,18 +486,6 @@
 
 %D Rendering lists and citations.
 
-\unexpanded\def\startbtxrendering
-  {\begingroup
-   \dosingleempty\btx_start_rendering}
-
-\def\btx_start_rendering[#1]%
-  {\edef\currentbtxrendering{#1}%
-   \btxrenderingparameter\c!before}
-
-\unexpanded\def\stopbtxrendering
-  {\btxrenderingparameter\c!after
-   \endgroup}
-
 \unexpanded\def\btxtodo#1%
   {[#1]}
 
@@ -652,17 +508,38 @@
 
 \setuplist
   [\s!btx]
-  [\c!state=\v!start]
+  [\c!prefixstopper=:,
+   \c!state=\v!start,
+   \c!alternative=\v!paragraph,
+   \c!before=\blank,
+   \c!after=\blank,
+   \c!width=\v!auto,
+   \c!distance=\emwidth]
+
+\unexpanded\def\setupbtxlist
+  {\dodoubleempty\publ_setup_list}
+
+\unexpanded\def\publ_setup_list[#1][#2]%
+  {\ifsecondargument
+     \setuplist[\s!btx:#1][#2]%
+   \else\iffirstargument
+     \setuplist[\s!btx][#1]%
+   \fi\fi}
 
 \appendtoks
     \ifx\currentbtxrenderingparent\empty
-        \definebtxlist
-          [\currentbtxrendering]%
+        \definelist
+          [\s!btx:\currentbtxrendering]%
+          [\s!btx]%
+    \else\ifx\currentbtxrenderingparent\s!btx
+        \definelist
+          [\s!btx:\currentbtxrendering]%
+          [\s!btx]%
     \else
-        \definebtxlist
-          [\currentbtxrendering]%
-          [\currentbtxrenderingparent]%
-    \fi
+        \definelist
+          [\s!btx:\currentbtxrendering]%
+          [\s!btx:\currentbtxrenderingparent]%
+    \fi\fi
 \to \everydefinebtxrendering
 
 \newconditional\c_btx_list_texts
@@ -699,18 +576,21 @@
       \settrue\setfalse\c_btx_list_pages
 \to \everysetupbtxlistplacement
 
-\unexpanded\def\btx_entry_inject_pages
+\unexpanded\def\btx_entry_inject_pages % for the moment only normal
   {\dontleavehmode
    \begingroup
-   \let\currentlist\s!btx
+   \setbtxlist % probably already set
    \btxpagereset
-   \btxlistparameter\c!pageleft
-   \ctxcommand{btxflushpages("\currentbtxdataset","\currentbtxtag")}%
-   \btxlistparameter\c!pageright
+   \setbtxparameterset\s!page\s!list
+   \btxparameter\c!command
+     {\usebtxstyleandcolor\c!style\c!color
+      \btxparameter\c!pageleft
+      \ctxcommand{btxflushpages("\currentbtxdataset","\currentbtxtag")}%
+      \btxparameter\c!pageright}%
    \endgroup}
 
 \unexpanded\def\btxpagesetup
-  {\fastsetup{\s!btx:\s!list:\s!page:normal}%
+  {\fastbtxsetup\s!page\s!list
    \btxpagereset}
 
 % end of page stuff
@@ -719,17 +599,13 @@
   {\begingroup
    \edef\currentbtxcategory{\btxfield{category}}%
    \ignorespaces
-   \edef\currentbtxsetup{\s!btx:\currentbtxspecification:\currentbtxcategory}%
-   \doifsetupselse\currentbtxsetup
-     \btx_entry_inject_yes
-     \btx_entry_inject_nop
-   \endgroup}
-
-\unexpanded\def\btx_entry_inject_yes
-  {\ifconditional\c_btx_list_texts
+   \ifconditional\c_btx_list_texts
      \currentbtxbefore
    \fi
-   \fastsetup\currentbtxsetup
+   \begingroup
+   \usebtxstyleandcolor\c!style\c!color
+   \fastbtxsetup\s!list\currentbtxcategory
+   \endgroup
    \removeunwantedspaces
    \ifconditional\c_btx_list_pages
      \btx_entry_inject_pages
@@ -740,16 +616,26 @@
    \fi
    \ifconditional\c_btx_list_texts
      \currentbtxafter
-   \fi}
+   \fi
+   \endgroup}
+
+\unexpanded\def\btxshowentryinline
+  {\dodoubleempty\btx_entry_show_inline}
 
-\def\btx_entry_inject_nop
-  {\tttf \getmessage\m!publications{12}{\currentbtxsetup}}
+\unexpanded\def\btx_entry_show_inline[#1][#2]%
+  {\ifsecondargument
+     \ctxcommand{showbtxentry("#1","#2")}
+   \else\iffirstargument
+     \ctxcommand{showbtxentry("\currentbtxdataset","#1")}
+   \else
+     \ctxcommand{showbtxentry("\currentbtxdataset","\currentbtxtag")}
+   \fi\fi}
 
 \def\btx_entry_inject_combi#1%
   {\begingroup
    \def\currentbtxtag{#1}%
    \ignorespaces
-   \fastsetup{\s!btx:\currentbtxspecification:\currentbtxcategory}%
+   \fastbtxsetup\s!list\currentbtxcategory
    \removeunwantedspaces
    \endgroup}
 
@@ -762,8 +648,7 @@
 \newtoks\everybtxlistrendering
 
 \appendtoks
-    \let\currentlist\s!btx
-    \let\currentbtxlist\currentbtxrendering
+    \setbtxlist
     %
     \edef\currentbtxcriterium{\btxrenderingparameter\c!criterium}% \v!cite will become \s!cite
     \ifx\currentbtxcriterium\empty
@@ -777,94 +662,116 @@
     \fi
 \to \everybtxlistrendering
 
-\def\publ_place_list_complete[#1][#2]% title might become obsolete, just headtext
-  {\begingroup
-   \ifsecondargument
-     \edef\currentbtxrendering{#1}%
-     \setupcurrentbtxrendering[#2]%
-   \else\iffirstargument
-     \let\currentbtxrendering\currentbtxdataset
-     \setupcurrentbtxrendering[#1]%
-   \fi\fi
-   \the\everybtxlistrendering
-   \edef\currentbtxrenderingtitle{\btxrenderingparameter\c!title}%
-   \ifx\currentbtxrenderingtitle\empty
-     \normalexpanded{\startnamedsection[\v!chapter][\c!reference=\currentbtxrendering,\c!title={\headtext{\currentbtxrendering}}]}%
-   \else
-     \normalexpanded{\startnamedsection[\v!chapter][\c!reference=\currentbtxrendering,\c!title={\currentbtxrenderingtitle}]}%
-   \fi
-   \publ_place_list_indeed
-   \stopnamedsection
-   \endgroup}
+\def\nofbtxlistentries  {0}
+\def\currentbtxlistentry{0}
+\def\currentbtxlistindex{0} % only for internal use (points back to big list)
+
+\newconditional\c_publ_prefixed
+
+\unexpanded\def\btxsetnoflistentries  #1{\edef\nofbtxlistentries  {#1}}
+\unexpanded\def\btxsetcurrentlistentry#1{\edef\currentbtxlistentry{#1}}
+\unexpanded\def\btxsetcurrentlistindex#1{\edef\currentbtxlistindex{#1}}
+
+\unexpanded\def\btxdoifsameaspreviouselse#1%
+  {\ctxcommand{btxdoifelsesameasprevious("\currentbtxdataset",\number\currentbtxlistentry,"#1")}}
 
-\def\publ_place_list_standard[#1][#2]%
+\def\publ_place_list_indeed#1[#2][#3]%
   {\begingroup
    \ifsecondargument
-     \edef\currentbtxrendering{#1}%
-     \setupcurrentbtxrendering[#2]%
+     % [rendering] [settings]
+     \edef\currentbtxrendering{#2}%
+     \setupcurrentbtxrendering[#3]%
+     \edef\p_specification{\btxrenderingparameter\c!specification}%
+     \ifx\p_specification\empty\else
+       \let\currentbtxspecification\p_specification
+     \fi
    \else\iffirstargument
-     \let\currentbtxrendering\currentbtxdataset
-     \setupcurrentbtxrendering[#1]%
+     \doifassignmentelse{#2}
+       {% [settings]
+        \let\currentbtxrendering\currentbtxspecification
+        \setupcurrentbtxrendering[#2]%
+        \edef\p_specification{\btxrenderingparameter\c!specification}%
+        \ifx\p_specification\empty\else
+           \let\currentbtxspecification\p_specification
+           \let\currentbtxrendering\currentbtxspecification % tricky
+        \fi}
+       {\edef\currentbtxrendering{#2}%
+        \edef\p_specification{\btxrenderingparameter\c!specification}%
+        \ifx\p_specification\empty\else
+          \let\currentbtxspecification\p_specification
+        \fi}%
    \else
-     \let\currentbtxrendering\currentbtxdataset
+     \let\currentbtxrendering\currentbtxspecification
    \fi\fi
+   \setbtxparameterset\s!list\currentbtxspecification
    \the\everybtxlistrendering
-   \publ_place_list_indeed
-   \endgroup}
-
-\def\publ_place_list_indeed
-  {\startbtxrendering[\currentbtxrendering]%
-   % \fastsetup{\btxrenderingparameter\c!setups}% specific initializations
-   % \determinelistcharacteristics[\currentbtxrendering]%
-     \publ_specification_push{\btxrenderingparameter\c!specification}%
-     \edef\currentbtxdataset{\btxrenderingparameter\c!dataset}%
-     \uselanguageparameter\btxdatasetparameter % new
-     \let\currentlist\s!btx
-     \let\currentbtxlist\currentbtxrendering
-     \the\everysetupbtxlistplacement
-     \forgetall
-     % why not pass this with collect .. todo
+   \ifconditional#1\relax
+     \edef\currentbtxrenderingtitle{\btxrenderingparameter\c!title}%
+     \ifx\currentbtxrenderingtitle\empty
+       \normalexpanded{\startnamedsection[\v!chapter][\c!reference=\currentbtxrendering,\c!title={\headtext{\currentbtxrendering}}]}%
+     \else
+       \normalexpanded{\startnamedsection[\v!chapter][\c!reference=\currentbtxrendering,\c!title={\currentbtxrenderingtitle}]}%
+     \fi
+   \fi
+   \ifx\currentbtxrendering\empty
+     \setbtxrendering % hm
+   \fi
+   \btxrenderingparameter\c!before
+   \edef\currentbtxdataset{\btxrenderingparameter\c!dataset}%
+   \uselanguageparameter\btxdatasetparameter % new
+   \setbtxlist
+   \the\everystructurelist
+   \the\everysetupbtxlistplacement
+   \forgetall
+   % why not pass this with collect .. todo
+   % here we just collect items
+   \ctxcommand{btxcollectlistentries {
+       names      = "btx",
+       criterium  = "\currentbtxcriterium",
+       reference  = "\btxrenderingparameter\c!reference",
+       method     = "\btxrenderingparameter\c!method",
+       btxdataset = "\currentbtxdataset",
+       keyword    = "\btxrenderingparameter\c!keyword",
+       sorttype   = "\btxrenderingparameter\c!sorttype",
+       repeated   = "\btxrenderingparameter\c!repeat",
+       ignored    = "\btxrenderingparameter\c!ignore",
+       group      = "\btxrenderingparameter\c!group",
+   }}%
+   \ifnum\nofbtxlistentries>\zerocount
      \startpacked[\v!blank]%
-       % here we just collect items
-       \ctxcommand{btxcollectlistentries {
-           names      = "btx",
-           criterium  = "\currentbtxcriterium",
-           reference  = "\btxrenderingparameter\c!reference",
-           method     = "\btxrenderingparameter\c!method",
-           btxdataset = "\currentbtxdataset",
-           keyword    = "\btxrenderingparameter\c!keyword",
-           sorttype   = "\btxrenderingparameter\c!sorttype",
-           repeated   = "\btxrenderingparameter\c!repeat",
-           ignored    = "\btxrenderingparameter\c!ignore",
-       }}%
-       % sorting and so
-       \ctxcommand{btxpreparelistentries("\currentbtxdataset")}%
-       % next we analyze the width
-       \ifx\currentbtxnumbering\empty \else
-         \edef\p_width{\btxrenderingparameter\c!width}%
-         \ifx\p_width\v!auto
-           \setbox\scratchbox\vbox \bgroup
-             \settrialtypesetting
-             \ctxcommand{btxfetchlistentries("\currentbtxdataset")}%
-           \egroup
-           \d_publ_number_width\wd\scratchbox
-           \letbtxlistparameter\c!width\d_publ_number_width
-         \fi
+     % sorting and so
+     \ctxcommand{btxpreparelistentries("\currentbtxdataset")}% could be put in collect
+     % next we analyze the width
+     \ifx\currentbtxnumbering\empty \else
+       \edef\p_width{\listparameter\c!width}%
+       \ifx\p_width\v!auto
+         \setbox\scratchbox\vbox \bgroup
+           \settrialtypesetting
+           \ctxcommand{btxfetchlistentries("\currentbtxdataset")}%
+         \egroup
+         \d_publ_number_width\wd\scratchbox
+         \letlistparameter\c!width\d_publ_number_width
        \fi
-       % this actually typesets them
-       \ctxcommand{btxflushlistentries("\currentbtxdataset")}%
+     \fi
+     \doifelse{\listparameter\c!prefix}\v!yes\settrue\setfalse\c_publ_prefixed
+     % this actually typesets them, we loop here as otherwise the whole
+     % bunch gets flushed at once
+     \dorecurse\nofbtxlistentries
+        {\let\currentbtxlistentry\recurselevel
+         \ctxcommand{btxflushlistentry("\currentbtxdataset",\currentbtxlistentry)}}%
      \stoppacked
-     \publ_specification_pop
-   \stopbtxrendering
-   \global\advance\btxblock\plusone}
+   \fi
+   \btxrenderingparameter\c!after
+   \global\advance\btxblock\plusone
+   \ifconditional#1\relax
+     \stopnamedsection
+   \fi
+   \endgroup}
 
-\def\currentbtxblock{\number\btxblock}
+\def\publ_place_list_complete{\publ_place_list_indeed\conditionaltrue}
+\def\publ_place_list_standard{\publ_place_list_indeed\conditionalfalse}
 
-\unexpanded\def\btxsetlanguage#1%
-  {\def\currentbtxlanguage{#1}%
-   \ifx\currentbtxlanguage\currentlanguage \else
-      \setcurrentlanguage\currentmainlanguage\currentbtxlanguage
-   \fi}
+\def\currentbtxblock{\number\btxblock}
 
 % called at the lua end, for determining the width
 
@@ -877,25 +784,69 @@
 
 % called at the lua end, the real rendering
 
+% we could have a yes and no where o nils the btx_reference_indeed ... saves a check there
+
+\installstructurelistprocessor{\s!btx}
+  {\let\currentlistentrynumber    \btx_reference_indeed
+   \let\currentlistentrytitle     \btx_entry_indeed
+   \let\currentlistentrypagenumber\btx_page_indeed
+   \strc_lists_apply_renderingsetup}
+
+\def\btx_entry_indeed
+  {\btx_list_reference_inject
+   \btx_entry_inject}
+
+\def\btx_page_indeed
+  {}
+
 \unexpanded\def\btxhandlelistentry
-  {\begingroup
-   \let\currentlist\s!btx % probably obsolete here
-   \startbtxlistentry\currentbtxrendering
-     \btx_entry_inject
-   \stopbtxlistentry
-   \endgroup}
+  {\strc_lists_entry_process}
 
-\unexpanded\def\btxlistsetup#1%
-  {\fastsetup{\s!btx:\s!list:#1}}
+\unexpanded\def\btxstartlistentry % maybe pass i
+  {\begingroup}
+
+\unexpanded\def\btxstoplistentry
+  {\endgroup}
+
+\newtoks\everybtxlistentry
+
+\unexpanded\def\btxlistsetup#1% used for the reference in the list
+  {\the\everybtxlistentry
+   \everybtxlistentry\emptytoks % so only once per entry to be sure
+   \fastbtxsetup\s!list{#1}}
+
+\appendtoks
+    \btx_check_language
+\to \everybtxlistentry
 
 \unexpanded\def\btx_reference_indeed
   {\begingroup
    \let\currentbtxlistvariant\currentbtxnumbering
-   \btxlistvariantparameter\c!left
-   \ctxcommand{btxlistvariant("\currentbtxdataset","\currentbtxblock","\currentbtxtag","\currentbtxnumbering","\currentbtxnumber")}% some can go
-   \btxlistvariantparameter\c!right
+   \setbtxparameterset\c!list\currentbtxnumbering
+   \ifx\currentbtxnumbering\empty
+     % nothing
+   \else\ifx\currentbtxnumbering\v!no
+     % nothing
+   \else
+     \btxparameter\c!left
+     \ifconditional\c_publ_prefixed\btxlistprefixednumber\fi
+     \ctxcommand{btxlistvariant("\currentbtxdataset","\currentbtxblock","\currentbtxtag","\currentbtxnumbering","\currentbtxnumber")}% some can go
+     \btxparameter\c!right
+   \fi\fi
    \endgroup}
 
+\unexpanded\def\btxlistprefixednumber % hack but alan needs it
+  {\ctxcommand{listprefixednumber("\currentlist",\currentbtxlistindex, {
+        prefix        = "\listparameter\c!prefix",
+        separatorset  = "\listparameter\c!prefixseparatorset",
+        conversionset = "\listparameter\c!prefixconversionset",
+        starter       = \!!bs\listparameter\c!prefixstarter\!!es,
+        stopper       = \!!bs\listparameter\c!prefixstopper\!!es,
+        set           = "\listparameter\c!prefixset",
+        segments      = "\listparameter\c!prefixsegments",
+        connector     = \!!bs\listparameter\c!prefixconnector\!!es,
+    })}}
+
 \unexpanded\def\btx_reference_checked
   {\dontleavehmode\hbox\bgroup
      \btx_reference_indeed
@@ -908,14 +859,14 @@
      \iftrialtypesetting\else
        \btx_list_reference_inject_now
      \fi
-     \btx_reference_indeed
+   % \btx_reference_indeed % else double entry in list
    \endgroup}
 
 \def\btx_list_reference_inject_now
   {\btx_trace_list_cross\empty\currentbtxbacktrace
    \global\advance\c_btx_list_reference\plusone
    \strc_references_direct_full_user
-      {\s!btxset="\currentbtxdataset",%
+      {\ifx\currentbtxdataset\v!default\else\s!btxset="\currentbtxdataset",\fi%
        \s!btxref="\currentbtxtag",%
        \s!btxspc="\currentbtxspecification",%
        \ifx\currentbtxbefore\empty\else\s!btxbtx={\currentbtxbefore},\fi%
@@ -941,7 +892,7 @@
    \the\t_btx_reference_inject
    \normalexpanded{\writedatatolist
       [\s!btx]%
-      [\s!btxset=\currentbtxdataset,%
+      [\ifx\currentbtxdataset\v!default\else\s!btxset=\currentbtxdataset,\fi%
        \s!btxref=\currentbtxtag,%
        \ifx\currentbtxbefore\empty\else\s!btxbtx={\currentbtxbefore},\fi%
        \ifx\currentbtxafter \empty\else\s!btxatx={\currentbtxafter },\fi%
@@ -956,16 +907,19 @@
 \let\currentbtxnumbering\empty
 
 \appendtoks
-   \edef\currentbtxnumbering{\btxrenderingparameter\c!numbering}%
-   \letlistparameter\c!numbercommand\firstofoneargument % for the moment, no doubling needed
-   \ifx\currentbtxnumbering\v!no
-     \letlistparameter\c!textcommand\outdented % needed? we can use titlealign
-     \letlistparameter\c!symbol     \v!none
-     \letlistparameter\c!aligntitle \v!yes
-     \let\currentbtxnumbering\empty
-   \else
-     \letlistparameter\c!headnumber\v!always
-   \fi
+    \edef\currentbtxnumbering{\btxrenderingparameter\c!numbering}%
+    \edef\p_numbering{\btxrenderingparameter\c!numbering}% link to headnumber
+    \ifx\p_numbering\v!no
+        \letlistparameter\c!headnumber\v!no
+        \let\currentbtxnumbering\empty
+      % \letlistparameter\c!textcommand\outdented % needed? we can use titlealign
+        \letlistparameter\c!symbol     \v!none
+        \letlistparameter\c!aligntitle \v!yes
+        \letlistparameter\c!numbercommand\firstofoneargument % for the moment, no doubling needed
+    \else
+        \letlistparameter\c!headnumber\v!always
+    \fi
+    \let\currentlistmethod\s!btx
 \to \everysetupbtxlistplacement
 
 % \appendtoks
@@ -976,22 +930,23 @@
   {\doifnextoptionalcselse\btx_flush_author_yes\btx_flush_author_nop}
 
 \def\btx_flush_author_yes[#1]{\btx_flush_author{#1}}
-\def\btx_flush_author_nop    {\btx_flush_author{\btxlistvariantparameter\c!authorconversion}}
+\def\btx_flush_author_nop    {\btx_flush_author{\btxparameter\c!authorconversion}}
 
 \unexpanded\def\btx_flush_author#1#2%
   {\begingroup
    \edef\currentbtxfield{#2}%
+   \setbtxparameterset\s!list\currentbtxfield
    \let\currentbtxlistvariant\currentbtxfield
    \ctxcommand{btxauthor("\currentbtxdataset","\currentbtxtag","\currentbtxfield",{
         combiner    = "#1",
         kind        = "list",
-       %symbol      = \btxlistvariantparameter\c!initialsterminator,
-       %connector   = \btxlistvariantparameter\c!initialssep,
-        etallimit   = \number\btxlistvariantparameter\c!etallimit,
-        etaldisplay = \number\btxlistvariantparameter\c!etaldisplay,
+        etallimit   = "\btxparameter\c!etallimit",
+        etaldisplay = "\btxparameter\c!etaldisplay",
    })}%
    \endgroup}
 
+% yes or no: maybe just \flushauthor{...}{...}
+
 \unexpanded\def\btxflushauthorname         {\btx_flush_author{name}}          % #1
 \unexpanded\def\btxflushauthornormal       {\btx_flush_author{normal}}        % #1
 \unexpanded\def\btxflushauthornormalshort  {\btx_flush_author{normalshort}}   % #1
@@ -1000,13 +955,12 @@
 
 \unexpanded\def\currentbtxciteauthor % always author
   {\begingroup
-   \ctxcommand{btxauthor("\currentbtxdataset","\currentbtxtag","author",{
-        combiner    = "\btxcitevariantparameter\c!authorconversion",
+   \setbtxparameterset\s!cite\s!author
+   \ctxcommand{btxauthor("\currentbtxdataset","\currentbtxtag","\s!author",{
+        combiner    = "\btxparameter\c!authorconversion",
         kind        = "cite",
-       %symbol      = \btxcitevariantparameter\c!initialsterminator,
-       %connector   = \btxcitevariantparameter\c!initialssep,
-        etallimit   = \number\btxcitevariantparameter\c!etallimit,
-        etaldisplay = \number\btxcitevariantparameter\c!etaldisplay,
+        etallimit   = "\btxparameter\c!etallimit",
+        etaldisplay = "\btxparameter\c!etaldisplay",
    })}%
    \endgroup}
 
@@ -1040,40 +994,19 @@
 % \btxflushauthor[inverted]{author}
 % \btxflushauthor[invertedshort]{author}
 
-% Interaction: only list
+% Interaction
 
 \newconditional\btxinteractive
 \newconditional\btx_interactive
 
-\unexpanded\def\btxdoifelseinteractive{\thirdofthreearguments}
-\unexpanded\def\btxdoifelseinteraction{\secondoftwoarguments}
-
-\unexpanded\def\publ_doifelse_interactive_list_yes#1%
-  {\edef\p_interaction{\namedbtxlistvariantparameter{#1}\c!interaction}%
-   \ifx\p_interaction\v!start
-     \expandafter\firstoftwoarguments
-   \else
-     \expandafter\secondoftwoarguments
-   \fi}
-
-\unexpanded\def\publ_doifelse_interactive_cite_yes#1%
-  {\edef\p_interaction{\namedbtxcitevariantparameter{#1}\c!interaction}%
-   \ifx\p_interaction\v!start
-     \expandafter\firstoftwoarguments
-   \else
-     \expandafter\secondoftwoarguments
-   \fi}
+% of maybe modes?
 
 \appendtoks
     \iflocation
-        \edef\p_interaction{\btxrenderingparameter\c!interaction}%
+        \edef\p_interaction{\btxparameter\c!interaction}%
         \ifx\p_interaction\v!stop
-            \let\btxdoifelseinteraction\secondoftwounexpanded
-            \let\btxdoifelseinteractive\thirdofthreeunexpanded
             \setfalse\btxinteractive
         \else
-            \let\btxdoifelseinteraction\firstoftwounexpanded
-            \let\btxdoifelseinteractive\publ_doifelse_interactive_list_yes
             \settrue\btxinteractive
             \ifx\p_interaction\v!all
                 \settrue\btx_interactive
@@ -1082,8 +1015,6 @@
             \fi
         \fi
     \else
-        \let\btxdoifelseinteraction\secondoftwounexpanded
-        \let\btxdoifelseinteractive\thirdofthreeunexpanded
         \setfalse\btxinteractive
         \setfalse\btx_interactive
     \fi
@@ -1091,44 +1022,26 @@
 
 \appendtoks
     \iflocation
-        \edef\p_interaction{\btxcitevariantparameter\c!interaction}%
+        \edef\p_interaction{\btxparameter\c!interaction}%
         \ifx\p_interaction\v!stop
-            \let\btxdoifelseinteraction\secondoftwounexpanded
-            \let\btxdoifelseinteractive\thirdofthreeunexpanded
             \setfalse\btxinteractive
         \else
-            \let\btxdoifelseinteraction\firstoftwounexpanded
-            \let\btxdoifelseinteractive\publ_doifelse_interactive_cite_yes
             \settrue\btxinteractive
         \fi
     \else
-        \let\btxdoifelseinteraction\secondoftwounexpanded
-        \let\btxdoifelseinteractive\thirdofthreeunexpanded
         \setfalse\btxinteractive
     \fi
 \to \everysetupbtxciteplacement
 
-\appendtoks
-    % for old times sake, for a while at least
-    \let\maybeyear\gobbleoneargument
-    \let\noopsort \gobbleoneargument
-\to \everysetupbtxlistplacement
-
-\appendtoks
-    % for old times sake, for a while at least
-    \let\maybeyear\gobbleoneargument
-    \let\noopsort \gobbleoneargument
-\to \everysetupbtxciteplacement
-
 % till here
 
 \unexpanded\def\btxnumberedreference[#1]% \bibtexnumref (replaced by \cite[num])
   {\dontleavehmode
    \begingroup
-   \btxcitevariantparameter\v!left
+   \btxparameter\v!left
    \penalty\plustenthousand % todo
    \ctxcommand{btxresolvelistreference("\currentbtxdataset","#1")}% todo: split dataset from #1, so another call
-   \btxcitevariantparameter\v!right
+   \btxparameter\v!right
    \endgroup}
 
 %D When a publication is cited, we need to signal that somehow. This is done with the
@@ -1172,7 +1085,9 @@
 
 \unexpanded\def\publ_cite_tags_indeed#1%
   {\letinteractionparameter\c!style\empty
-   \edef\currentbtxcitevariant{\btxcitevariantparameter\c!alternative}%
+   \setbtxparametersetroot\s!cite % we need to get the default
+   \edef\currentbtxcitevariant{\btxparameter\c!alternative}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
    \edef\currentbtxcitetag{#1}%
    \the\everysetupbtxciteplacement
    \publ_cite_variant
@@ -1185,7 +1100,6 @@
   {\letinteractionparameter\c!style\empty
   %\letinteractionparameter\c!color\empty
    \letdummyparameter\c!reference  \empty
-   \letdummyparameter\c!extras     \empty
    \letdummyparameter\c!alternative\empty
    \letdummyparameter\c!before     \empty
    \letdummyparameter\c!after      \empty
@@ -1201,26 +1115,19 @@
    \fi
    \edef\p_alternative{\dummyparameter\c!alternative}%
    \ifx\p_alternative\empty
-     \edef\currentbtxcitevariant{\btxcitevariantparameter\c!alternative}%
+     \setbtxparametersetroot\s!cite
+     \edef\currentbtxcitevariant{\btxparameter\c!alternative}%
    \else
      \let\currentbtxcitevariant\p_alternative
    \fi
-   \setupcurrentbtxcitevariant[#1]%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
+   \setupcurrentbtx[#1]%
    %
    \edef\p_publ_cite_before   {\dummyparameter\c!before}%
    \edef\p_publ_cite_after    {\dummyparameter\c!after}%
    \edef\p_publ_cite_lefttext {\dummyparameter\c!lefttext}%
    \edef\p_publ_cite_righttext{\dummyparameter\c!righttext}%
    %
-   \edef\p_extras             {\dummyparameter\c!extras}%
-   \ifx\p_extras\empty \else
-     \ifx\p_publ_cite_righttext\empty
-       \let\p_publ_cite_righttex\p_extras
-     \else
-       % ignored: righttext wins over extras
-     \fi
-   \fi
-   %
    \the\everysetupbtxciteplacement
    \publ_cite_variant
    \endgroup}
@@ -1229,12 +1136,15 @@
   {\letinteractionparameter\c!style\empty
    \edef\currentbtxcitevariant{#1}%
    \edef\currentbtxcitetag{#2}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
    \the\everysetupbtxciteplacement
    \publ_cite_variant
    \endgroup}
 
 \newconditional\btxcitecompress
 
+\let\currentbtxreference\empty
+
 \def\publ_cite_variant
   {\begingroup
    \publ_cite_handle_variant_indeed[\currentbtxcitetag]}
@@ -1242,31 +1152,31 @@
 \unexpanded\def\publ_cite_handle_variant#1%
   {\begingroup
    \edef\currentbtxcitevariant{#1}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
    \the\everysetupbtxciteplacement
    \dosingleargument\publ_cite_handle_variant_indeed}
 
 \def\publ_cite_handle_variant_indeed[#1]%
-  {\usebtxcitevariantstyleandcolor\c!style\c!color
+  {\letbtxparameter\c!alternative\currentbtxcitevariant
+   \usebtxstyleandcolor\c!style\c!color
    \uselanguageparameter\btxdatasetparameter % new
-   \publ_specification_push{\btxcitevariantparameter\c!specification}%
-   \letbtxcitevariantparameter\c!alternative\currentbtxcitevariant
-   \btxcitevariantparameter\v!left
+   \btxparameter\v!left
+   \edef\currentbtxreference{#1}%
    \ctxcommand{btxhandlecite{%
      dataset   = "\currentbtxdataset",%
-     reference = "#1",%
+     reference = \!!bs\currentbtxreference\!!es,%
      markentry = \iftrialtypesetting false\else true\fi,%
      variant   = "\currentbtxcitevariant",%
-     sorttype  = "\btxcitevariantparameter\c!sorttype",%
-     compress  = "\btxcitevariantparameter\c!compress",%
-     author    = "\btxcitevariantparameter\c!author",%
+     sorttype  = "\btxparameter\c!sorttype",%
+     compress  = "\btxparameter\c!compress",%
+     author    = "\btxparameter\c!author",%
      lefttext  = \!!bs\p_publ_cite_lefttext\!!es,%
      righttext = \!!bs\p_publ_cite_righttext\!!es,%
      before    = \!!bs\p_publ_cite_before\!!es,%
      after     = \!!bs\p_publ_cite_after\!!es,%
    }}%
-   \btxcitevariantparameter\v!right
+   \btxparameter\v!right
    \ctxcommand{flushmarked()}%
-   \publ_specification_pop
    \endgroup}
 
 \unexpanded\def\btxcitation
@@ -1286,12 +1196,15 @@
 
 \unexpanded\def\publ_cite_no[#1]%
   {\iftrialtypesetting \else
+     \begingroup
+     \edef\currentbtxreference{#1}%
      \ctxcommand{btxhandlenocite{%
        dataset   = "\currentbtxdataset",%
-       reference = "#1",%
+       reference = \!!bs\currentbtxreference#1\!!es,%
        markentry = true,%
      }}%
    % \ctxcommand{flushmarked()}%
+     \endgroup
    \fi}
 
 \unexpanded\def\btxmissing#1%
@@ -1305,23 +1218,151 @@
 \let\nocitation    \btxnocitation
 %let\usepublication\btxnocitation
 
+%D Setup helpers, beware, we need to wrap this .. now we need to know
+%D how setups are implemented.
+
+\setvalue{\??setup:\s!btx:\s!unknown}#1{\inframed{\tttf#1}}
+
+\def\fastbtxsetup_yes#1#2%
+  {\csname\??setup:\s!btx:%
+     \ifcsname\??setup:\s!btx:\currentbtxspecification:#1:#2\endcsname
+        \currentbtxspecification:#1:#2%
+     \else\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback:#1:#2\endcsname
+        \currentbtxspecificationfallback:#1:#2%
+     \else\ifcsname\??setup:\s!btx:#1:#2\endcsname
+        #1:#2%
+     \else\ifcsname\??setup:\s!btx:\currentbtxspecification:#1:\s!unknown\endcsname
+        \currentbtxspecification:#1:\s!unknown
+     \else\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback:#1:\s!unknown\endcsname
+        \currentbtxspecificationfallback:#1:\s!unknown
+     \else
+        #1:\s!unknown
+     \fi\fi\fi\fi\fi
+   \endcsname{#2}}
+
+\def\fastbtxsetup_nop#1#2%
+  {\csname\??setup:\s!btx:%
+     \ifcsname\??setup:\s!btx:\currentbtxspecification:#1:#2\endcsname
+        \currentbtxspecification:#1:#2%
+     \else\ifcsname\??setup:\s!btx:#1:#2\endcsname
+        #1:#2%
+     \else\ifcsname\??setup:\s!btx:\currentbtxspecification:#1:\s!unknown\endcsname
+        \currentbtxspecification:#1:\s!unknown
+     \else
+        #1:\s!unknown
+     \fi\fi\fi
+   \endcsname{#2}}
+
+\def\fastbtxsetup
+  {\ifx\currentbtxspecificationfallback\empty
+     \expandafter\fastbtxsetup_nop
+   \else
+     \expandafter\fastbtxsetup_yes
+   \fi}
+
+\let\publ_fastbtxsetup_normal\fastbtxsetup
+
+% \unexpanded\def\publ_fastbtxsetup_chain_yes#1#2%
+%   {\inframed[\c!foregroundstyle=\infofont]{%
+%      \currentbtxspecification        :#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecification                        :#1:#2\endcsname\else->%
+%      \currentbtxspecificationfallback:#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback                :#1:#2\endcsname\else->%
+%                                       #1:#2\ifcsname\??setup:\s!btx                                                 :#1:#2\endcsname\else->%
+%      \currentbtxspecification        :#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecification        :#1:\s!unknown\endcsname\else->%
+%      \currentbtxspecificationfallback:#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback:#1:\s!unknown\endcsname\else->%
+%      ?\fi\fi\fi\fi\fi}}
+
+% \unexpanded\def\publ_fastbtxsetup_chain_nop#1#2%
+%   {\inframed[\c!foregroundstyle=\infofont]{%
+%      \currentbtxspecification        :#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecification                        :#1:#2\endcsname\else->%
+%                                       #1:#2\ifcsname\??setup:\s!btx                                                 :#1:#2\endcsname\else->%
+%      \currentbtxspecification        :#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecification        :#1:\s!unknown\endcsname\else->%
+%      ?\fi\fi\fi}}
+
+\unexpanded\def\publ_fastbtxsetup_chain_inbetween
+  {\allowbreak->\allowbreak}
+
+\unexpanded\def\publ_fastbtxsetup_chain_yes#1#2%
+  {\dontleavehmode\begingroup\infofont\darkblue[%
+   \currentbtxspecification        :#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecification                        :#1:#2\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   \currentbtxspecificationfallback:#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback                :#1:#2\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+                                    #1:#2\ifcsname\??setup:\s!btx                                                 :#1:#2\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   \currentbtxspecification        :#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecification        :#1:\s!unknown\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   \currentbtxspecificationfallback:#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecificationfallback:#1:\s!unknown\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   unset\fi\fi\fi\fi\fi
+   ]\endgroup}
+
+\unexpanded\def\publ_fastbtxsetup_chain_nop#1#2%
+  {\dontleavehmode\begingroup\infofont\darkred[%
+   \currentbtxspecification        :#1:#2\ifcsname\??setup:\s!btx:\currentbtxspecification                        :#1:#2\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+                                    #1:#2\ifcsname\??setup:\s!btx                                                 :#1:#2\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   \currentbtxspecification        :#1:\s!unknown\ifcsname\??setup:\s!btx:\currentbtxspecification        :#1:\s!unknown\endcsname\else
+   \publ_fastbtxsetup_chain_inbetween
+   unset\fi\fi\fi
+   ]\endgroup}
+
+\unexpanded\def\publ_fastbtxsetup_chain
+  {\ifx\currentbtxspecificationfallback\empty
+     \expandafter\publ_fastbtxsetup_chain_nop
+   \else
+     \expandafter\publ_fastbtxsetup_chain_yes
+   \fi}
+
+\unexpanded\def\publ_fastbtxsetup_visual#1#2%
+  {\publ_fastbtxsetup_chain{#1}{#2}%
+   \publ_fastbtxsetup_normal{#1}{#2}}
+
+\installtextracker
+  {publications.setups}
+  {\let\fastbtxsetup\publ_fastbtxsetup_visual}
+  {\let\fastbtxsetup\publ_fastbtxsetup_normal}
+
 %D Cite helpers:
 
+\newtoks\everybtxciteentry
+
 \unexpanded\def\btxcitesetup#1%
-  {\currentbtxlefttext
-   \fastsetup{\s!btx:\s!cite:#1}%
+  {\the\everybtxciteentry
+   \everybtxciteentry\emptytoks % tricky maybe not when subcites
+   \currentbtxlefttext
+   \fastbtxsetup\s!cite{#1}%
    \currentbtxrighttext} % no \btxcitereset as we loose dataset and such
 
-\unexpanded\def\btxstartsubcite#1% #1 can go
+\appendtoks
+    \btx_check_language
+\to \everybtxciteentry
+
+\unexpanded\def\btxstartsubcite#1%
   {\begingroup
    \btxcitereset % todo: limited set
    \def\currentbtxcitevariant{#1}%
-   \btxcitevariantparameter\c!left
+   \setbtxparameterset\s!cite\currentbtxcitevariant
+   \usebtxstyleandcolor\c!style\c!color
+   \btxparameter\c!left
    \relax}
 
 \unexpanded\def\btxstopsubcite
   {\relax
-   \btxcitevariantparameter\c!right
+   \btxparameter\c!right
+   \endgroup}
+
+\unexpanded\def\btxstartciterendering[#1]%
+  {\begingroup
+   \edef\currentbtxcitevariant{#1}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
+   \usebtxstyleandcolor\c!style\c!color
+   \btxparameter\c!left
+   \relax}
+
+\unexpanded\def\btxstopciterendering
+  {\relax
+   \btxparameter\c!right
    \endgroup}
 
 \let\btxstartcite      \begingroup
@@ -1332,8 +1373,8 @@
 %D Whatever helpers:
 
 \unexpanded\def\btxsingularplural#1{\ctxcommand{btxsingularorplural("\currentbtxdataset","\currentbtxtag","#1")}}
-\unexpanded\def\btxoneorrange    #1{\ctxcommand{oneorrange("\currentbtxdataset","\currentbtxtag","#1")}}
-\unexpanded\def\btxfirstofrange  #1{\ctxcommand{firstofrange("\currentbtxdataset","\currentbtxtag","#1")}}
+\unexpanded\def\btxoneorrange    #1{\ctxcommand{btxoneorrange("\currentbtxdataset","\currentbtxtag","#1")}}
+\unexpanded\def\btxfirstofrange  #1{\ctxcommand{btxfirstofrange("\currentbtxdataset","\currentbtxtag","#1")}}
 
 \let\btxsingularorplural\btxsingularplural
 
@@ -1372,29 +1413,29 @@
    \ctxcommand{btxsavedataset("#1","#2","\dummyparameter\c!alternative","\dummyparameter\c!criterium")}%
    \endgroup}
 
-% \savebtxdataset[standard][e:/tmp/foo.bib]
-% \savebtxdataset[standard][e:/tmp/foo.lua]
-% \savebtxdataset[standard][e:/tmp/foo.xml]
+% \savebtxdataset[default][e:/tmp/foo.bib]
+% \savebtxdataset[default][e:/tmp/foo.lua]
+% \savebtxdataset[default][e:/tmp/foo.xml]
 
 %D In-text entries:
 
-\definebtxcitevariant
-  [entry]
+% \definebtxcitevariant
+%   [entry]
 
 \unexpanded\def\placecitation{\citation[entry]} % [#1]
 
 \unexpanded\def\btxhandleciteentry
   {\dontleavehmode
    \begingroup
-   \publ_specification_push{\btxcitevariantparameter\c!specification}%
+   \def\currentbtxcitevariant{entry}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant % needs checking
    \btxcitereference
    \btx_entry_inject
-   \publ_specification_pop
    \endgroup}
 
 \startsetups \s!btx:\s!cite:entry
     \ifx\currentbtxfirst\empty
-        \fastsetup{\s!btx:\s!cite:\s!unknown}
+        \fastbtxsetup\s!cite\s!unknown
     \else
         \btxhandleciteentry
     \fi
@@ -1454,239 +1495,82 @@
    \def\currentbtxinitials   {#4}%
    \def\currentbtxfirstnames {#5}%
    \def\currentbtxjuniors    {#6}%
+   \setbtxparameterset\s!cite\currentbtxcitevariant
    \fastsetup{\s!btx:\s!cite:\s!author:\currentbtxcitevariant}%
    \endgroup}
 
-%D Defaults:
+%D We hook some setters in the definition sets:
+
+% \installdefinitionsetmember \??btx {btxspecification} \??btxcitevariant {btxcitevariant}
+% \installdefinitionsetmember \??btx {btxspecification} \??btxlistvariant {btxlistvariant}
+% \installdefinitionsetmember \??btx {btxspecification} \??btxlist        {btxlist}
+% \installdefinitionsetmember \??btx {btxspecification} \??btxrendering   {btxrendering}
+% \installdefinitionsetmember \??btx {btxspecification} \??btx            {btx}
+
+%D And more helpers ... a never ending story these publications:
+
+% \definebtx
+%   [btx:apa:list:article:title]
+%   [style=bolditalic,
+%    command=\WORD]
+%
+% \btxstartstyle[btx:apa:list:article:title]
+%     \btxusecommand[btx:apa:list:article:title]{foo}
+% \btxstopstyle
 
-\setbtxdataset
-  [\v!standard]
+\unexpanded\def\btxstartstyle[#1]%
+  {\begingroup
+   \def\currentbtx{#1}%
+   \usebtxstyle\c!style}
+
+\unexpanded\def\btxstartcolor[#1]%
+  {\begingroup
+   \def\currentbtx{#1}%
+   \usebtxcolor\c!color}
+
+\unexpanded\def\btxstartstyleandcolor[#1]%
+  {\begingroup
+   \def\currentbtx{#1}%
+   \usebtxstyleandcolor\c!style\c!color}
+
+\let\btxstopstyle        \endgroup
+\let\btxstopcolor        \endgroup
+\let\btxstopstyleandcolor\endgroup
+
+\unexpanded\def\btxusecommand[#1]%
+  {\namedbtxparameter{#1}\c!command}
+
+%D Defaults:
 
 \setupbtxrendering
   [\c!interaction=\v!start, % \v!all
    \c!specification=\btxparameter\c!specification,
-   \c!dataset=\v!standard,
+   \c!dataset=\v!default,
    \c!repeat=\v!no,
    \c!continue=\v!no,
    \c!method=\v!global,
  % \c!setups=btx:\btxrenderingparameter\c!alternative:initialize, % not the same usage as cite !
-%    \c!sorttype=authoryear,
+ % \c!sorttype=authoryear,
    \c!criterium=\v!text,
    \c!refcommand=authoryears,  % todo
    \c!numbering=\v!yes,
- % \c!autohang=\v!no, % not used
   %\c!saveinlist=\v!no, % maybe for before/after
    \c!textstate=\v!start,
    \c!width=\v!auto,
+  %\c!pageright=,
+  %\c!pageleft=,
    \c!separator={;\space},
    \c!distance=1.5\emwidth]
 
-\definebtxrendering
-  [\v!standard]
-
-% reasonable defaults; may be redefined by style.
-
-\setupbtxlistvariant
-  [\c!namesep={,\space},
-   \c!lastnamesep={,\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!finalnamesep={,\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!firstnamesep=\space,
-   \c!otherstext={\space\btxlabeltext{\currentbtxspecification:others}},
-   \c!juniorsep=\space,
-   \c!vonsep=\space,
-   \c!initialsep=\space,  % between initials and lastname
-  %\c!initialssep=\space, % between multiple initials  % todo
-  %\c!initialsterminator={.},                          % todo
-   \c!surnamesep={,\space},
-   \c!surnameinitialsep={,\space},
-   \c!surnamefirstnamesep={,\space},
+% Quite some interpunction and labels are the same of at least consistent witin
+% a standard when citations and list entries are involved. We assume that each
+% standard defines its own set but it can fall back on the defaults.
+
+\setupbtx
+  [\c!alternative=\v!num, % default cite
+   \c!interaction=\v!start,
    \c!etallimit=3,
-   \c!etaldisplay=\btxlistvariantparameter\c!etallimit,
-  %\c!journalconversion=\v!normal,
-   \c!monthconversion=\v!number,
-   \c!authorconversion=\v!inverted,
-   \c!interaction=\c!start]
-
-\definebtxlistvariant
-  [author]
-
-\definebtxlistvariant
-  [editor]
-  [author]
-
-\definebtxlistvariant
-  [url]
-
-\definebtxlistvariant
-  [doi]
-
-\definebtxlistvariant % because we inherit
-  [invertedshort]
-
-\definebtxlistvariant % because we inherit
-  [short]
-
-\setupbtxcitevariant
-  [\c!specification=\btxparameter\c!specification,
-   \c!alternative=num,
-   \c!namesep=\btxlistvariantparameter\c!namesep,
-   \c!lastnamesep=\btxlistvariantparameter\c!lastnamesep,
-   \c!finalnamesep=\btxlistvariantparameter\c!finalnamesep,
-   \c!firstnamesep=\btxlistvariantparameter\c!firstnamesep,
-   \c!otherstext=\btxlistvariantparameter\c!otherstext,
-   \c!juniorsep=\btxlistvariantparameter\c!juniorsep,
-   \c!vonsep=\btxlistvariantparameter\c!vonsep,
-   \c!initialsep=\btxlistvariantparameter\c!initialsep,
-  %\c!initialssep=\btxlistvariantparameter\c!initialssep,
-  %\c!initialsterminator=\btxlistvariantparameter\c!initialsterminator,
-   \c!surnamesep=\btxlistvariantparameter\c!surnamesep,
-   \c!surnameinitialsep=\btxlistvariantparameter\c!surnameinitialsep,
-   \c!surnamefirstnamesep=\btxlistvariantparameter\c!surnamefirstnamesep,
-   \c!etallimit=\btxlistvariantparameter\c!etallimit,
-   \c!etaldisplay=\btxlistvariantparameter\c!etaldisplay,
-   \c!monthconversion=\btxlistvariantparameter\c!monthconversion,
-   \c!authorconversion=\v!name,
- % \c!setups=btx:cite:initialize,
-   \c!pubsep={,\space},
-   \c!lastpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!finalpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space},
-   \c!sorttype=,
-   \c!compress=\v!no,
-   \c!inbetween=\space,
-   \c!range=\endash,
-   \c!left=,
-   \c!middle=,
-   \c!right=,
-   \c!interaction=\v!start]
-
-\definebtxcitevariant
-   [author]
-
-\definebtxcitevariant
-   [authornum]
-   [author]
-   [\c!left={(},
-    \c!right={)}]
-
-\definebtxcitevariant
-   [authoryear]
-   [\c!compress=\v!yes,
-    \c!inbetween={,\space},
-    \c!left={(},
-    \c!right={)},
-    \c!pubsep={;\space},
-    \c!lastpubsep={;\space},
-    \c!finalpubsep={;\space}]
-
-\definebtxcitevariant
-   [authoryears]
-   [authoryear]
-   [\c!left=,
-    \c!inbetween={\space(},
-    \c!pubsep={);\space},
-    \c!lastpubsep={);\space},
-    \c!finalpubsep={);\space}]
-
-\definebtxcitevariant
-   [author:num]
-   [authornum]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [author:year]
-   [authoryear]
-   [\c!left=,
-    \c!right=]
-
-\definebtxcitevariant
-   [author:years]
-   [author:year]
-
-\definebtxcitevariant
-   [year]
-   [\c!left={(},
-    \c!pubsep={,\space},
-    \c!lastpubsep={,\space},
-    \c!finalpubsep={,\space},
-    \c!right={)}]
-
-\definebtxcitevariant
-   [title]
-
-\definebtxcitevariant
-   [tag]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [key]
-   [tag]
-
-\definebtxcitevariant
-   [serial]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [page]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [pages]
-   [page]
-
-\definebtxcitevariant
-   [invertedshort]
-
-\definebtxcitevariant
-   [short]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [category]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [type]
-   [category]
-
-\definebtxcitevariant
-   [doi]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [url]
-   [\c!left={[},
-    \c!right={]}]
-
-\definebtxcitevariant
-   [page]
-   [\c!left=,
-    \c!right=]
-
-\definebtxcitevariant
-   [num]
-   [\c!compress=\v!yes,
-    \c!left={[},
-    \c!right={]},
-    \c!pubsep={,},
-    \c!lastpubsep={,},
-    \c!finalpubsep={,}]
-
-\definebtxcitevariant
-   [textnum]
-   [num]
-   [\c!left={Ref.\nbsp}, % {Refs.\nbsp}, if multiple?
-    %yuck! ={\btxlabeltext{\currentbtxspecification:Reference\btxsingularplural{num}{}{s}}\nbsp}
-    \c!right=,
-    \c!pubsep={,},
-    \c!lastpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space},
-    \c!finalpubsep={\space\btxlabeltext{\currentbtxspecification:and}\space}]
+   \c!etaldisplay=\btxparameter\c!etallimit]
 
 % Do we want these in the format? Loading them delayed is somewhat messy.
 
@@ -1698,9 +1582,19 @@
 \loadbtxdefinitionfile[page]
 \loadbtxdefinitionfile[author]
 
+% we assume that the users sets up the right specification and if not ... well,
+% hope for the best that something shows up and consult the manual otherwise
+
+\unexpanded\def\usebtxdefinitions[#1]%
+  {\loadbtxdefinitionfile[#1]%     % for hh
+   \setupbtx[\c!specification=#1]} % for ab
+
 \setupbtx
-  [\c!specification=apa]
+  [\c!specification=\s!default,
+   \c!dataset=\v!default,
+   \c!default=]
 
-% \letvalue{\??btxrenderingdefinition apa}\undefined % we will reload at runtime
+\loadbtxdefinitionfile
+  [\s!default]
 
 \protect
diff --git a/tex/context/base/publ-reg.lua b/tex/context/base/publ-reg.lua
index 3df853736..531c4dcf0 100644
--- a/tex/context/base/publ-reg.lua
+++ b/tex/context/base/publ-reg.lua
@@ -17,7 +17,6 @@ local commands       = commands
 local variables      = interfaces.variables
 
 local v_once         = variables.once
-local v_standard     = variables.standard
 local v_stop         = variables.stop
 local v_all          = variables.all
 
diff --git a/tex/context/base/publ-sor.lua b/tex/context/base/publ-sor.lua
index c17273cc3..c3fcdb0ee 100644
--- a/tex/context/base/publ-sor.lua
+++ b/tex/context/base/publ-sor.lua
@@ -23,7 +23,7 @@ local writers      = publications.writers
 
 local variables    = interfaces.variables
 local v_short      = variables.short
-local v_default    = variables.reference
+local v_default    = variables.default
 local v_reference  = variables.reference
 local v_dataset    = variables.dataset
 
@@ -238,9 +238,10 @@ local sorters = {
     end,
     [v_dataset] = function(dataset,rendering,list)
         local function compare(a,b)
-            local aa, bb = a and a[1], b and b[1]
+-- inspect(a,b)
+            local aa, bb = a and a[6], b and b[6]
             if aa and bb then
-                aa, bb = list[aa].index or 0, list[bb].index or 0
+             -- aa, bb = list[aa].index or 0, list[bb].index or 0
                 return aa and bb and aa < bb
             end
             return false
diff --git a/tex/context/base/publ-tra.lua b/tex/context/base/publ-tra.lua
index 5f1610beb..65e9b7ff4 100644
--- a/tex/context/base/publ-tra.lua
+++ b/tex/context/base/publ-tra.lua
@@ -19,22 +19,32 @@ local concat            = table.concat
 local context           = context
 local commands          = commands
 
+local v_default         = interfaces.variables.default
+
 local publications      = publications
 local tracers           = publications.tracers
 local tables            = publications.tables
 local datasets          = publications.datasets
 local specifications    = publications.specifications
+local citevariants      = publications.citevariants
 
 local getfield          = publications.getfield
 local getcasted         = publications.getcasted
 
 local ctx_NC, ctx_NR, ctx_HL, ctx_FL, ctx_ML, ctx_LL, ctx_EQ = context.NC, context.NR, context.HL, context.FL, context.ML, context.LL, context.EQ
-local ctx_bold, ctx_monobold, ctx_rotate, ctx_llap, ctx_rlap = context.bold, context.formatted.monobold, context.rotate, context.llap, context.rlap
 
 local ctx_starttabulate = context.starttabulate
 local ctx_stoptabulate  = context.stoptabulate
 
-local ctx_verbatim      = context.verbatim
+local ctx_formatted     = context.formatted
+local ctx_bold          = ctx_formatted.monobold
+local ctx_monobold      = ctx_formatted.monobold
+local ctx_verbatim      = ctx_formatted.verbatim
+
+local ctx_rotate        = context.rotate
+local ctx_llap          = context.llap
+local ctx_rlap          = context.rlap
+local ctx_page          = context.page
 
 local privates = tables.privates
 local specials = tables.specials
@@ -313,7 +323,11 @@ function tracers.showtables(settings)
             ctx_NC()
             context(k)
             ctx_NC()
-            context(tostring(v))
+            if type(v) == "table" then
+                context("% t",v)
+            else
+                context(tostring(v))
+            end
             ctx_NC()
             ctx_NR()
         end
@@ -329,8 +343,8 @@ function tracers.showdatasetauthors(settings)
 
     local sortkey = publications.writers.author
 
-    if not dataset or dataset == "" then dataset = "standard" end
-    if not field   or field   == "" then field   = "author"   end
+    if not dataset or dataset == "" then dataset = v_default end
+    if not field   or field   == "" then field   = "author"  end
 
     local function row(i,k,v)
         ctx_NC()
@@ -374,36 +388,43 @@ function tracers.showdatasetauthors(settings)
 
     local d = datasets[dataset].luadata
 
+    local trialtypesetting = context.trialtypesetting()
+
     for tag, entry in sortedhash(d) do
 
-        local a = getcasted(dataset,tag,field)
+        local a, f, k = getcasted(dataset,tag,field)
 
-        if a then
+        if type(a) == "table" and #a > 0 and k == "author" then
             context.start()
             context.tt()
-            context.starttabulate { "|B|Bl|p|" }
+            ctx_starttabulate { "|B|Bl|p|" }
                 ctx_FL()
+                local original = getfield(dataset,tag,field)
                 commonrow("tag",tag)
                 commonrow("field",field)
-                commonrow("content",getfield(dataset,tag,field))
+                commonrow("original",original)
                 commonrow("sortkey",sortkey(a))
                 for i=1,#a do
                     ctx_ML()
                     local ai = a[i]
-                    authorrow(ai,"original",i)
-                    authorrow(ai,"snippets")
-                    authorrow(ai,"initials")
-                    authorrow(ai,"firstnames")
-                    authorrow(ai,"vons")
-                    authorrow(ai,"surnames")
-                    authorrow(ai,"juniors")
-                    local options = ai.options
-                    if options then
-                        row(false,"options",sortedkeys(options))
+                    if ai then
+                        authorrow(ai,"original",i)
+                        authorrow(ai,"snippets")
+                        authorrow(ai,"initials")
+                        authorrow(ai,"firstnames")
+                        authorrow(ai,"vons")
+                        authorrow(ai,"surnames")
+                        authorrow(ai,"juniors")
+                        local options = ai.options
+                        if options then
+                            row(false,"options",sortedkeys(options))
+                        end
+                    elseif not trialtypesetting then
+                        report("bad author name: %s",original or "?")
                     end
                 end
                 ctx_LL()
-            context.stoptabulate()
+            ctx_stoptabulate()
             context.stop()
         end
 
@@ -411,8 +432,49 @@ function tracers.showdatasetauthors(settings)
 
 end
 
+function tracers.showentry(dataset,tag)
+    local dataset = datasets[dataset]
+    if dataset then
+        local entry = dataset.luadata[tag]
+        local done  = false
+        for k, v in sortedhash(entry) do
+            if not privates[k] then
+                ctx_verbatim("%w[%s: %s]",done and 1 or 0,k,v)
+                done = true
+            end
+        end
+    end
+end
+
+local skipped = { index = true, default = true }
+
+function tracers.showvariants(dataset,pages)
+    local variants = sortedkeys(citevariants)
+    for tag in publications.sortedentries(dataset or v_default) do
+        if pages then
+            ctx_page()
+        end
+        ctx_starttabulate { "|T||" }
+        for i=1,#variants do
+            local variant = variants[i]
+            if not skipped[variant] then
+                ctx_NC() context(variant)
+             -- ctx_EQ() citevariants[variant] { dataset = v_default, reference = tag, variant = variant }
+                ctx_EQ() context.cite({variant},{dataset .. "::" .. tag})
+                ctx_NC() ctx_NR()
+            end
+        end
+        ctx_stoptabulate()
+        if pages then
+            ctx_page()
+        end
+    end
+end
+
 commands.showbtxdatasetfields       = tracers.showdatasetfields
 commands.showbtxdatasetcompleteness = tracers.showdatasetcompleteness
 commands.showbtxfields              = tracers.showfields
 commands.showbtxtables              = tracers.showtables
 commands.showbtxdatasetauthors      = tracers.showdatasetauthors
+commands.showbtxentry               = tracers.showentry
+commands.showbtxvariants            = tracers.showvariants
diff --git a/tex/context/base/publ-tra.mkiv b/tex/context/base/publ-tra.mkiv
index f4e7e867e..fb64b4171 100644
--- a/tex/context/base/publ-tra.mkiv
+++ b/tex/context/base/publ-tra.mkiv
@@ -28,7 +28,7 @@
 
 \def\publ_show_dataset_whatever#1[#2]%
   {\begingroup
-   \setdummyparameter\c!specification{\btxparameter\c!specification}%
+   \letdummyparameter\c!specification\currentbtxspecification
    \setdummyparameter\c!dataset      {\currentbtxdataset}%
    \letdummyparameter\c!field        \empty
    \iffirstargument
@@ -54,10 +54,12 @@
 \def\publ_show_fields[#1]%
   {\begingroup
    \setdummyparameter\c!rotation{90}%
-   \doifassignmentelse{#1}
-     {\setdummyparameter\c!specification{\btxparameter\c!specification}%
+   \doifassignmentelse{#1}%
+     {\letdummyparameter\c!specification\currentbtxspecification
       \getdummyparameters[#1]}%
-     {\setdummyparameter\c!specification{#1}}%
+     {\doifelsenothing{#1}%
+        {\letdummyparameter\c!specification\currentbtxspecification}%
+        {\setdummyparameter\c!specification{#1}}}%
  % \publ_specification_push{"\dummyparameter\c!specification}%
    \ctxcommand{showbtxfields{
       rotation      = "\dummyparameter\c!rotation",
@@ -80,4 +82,6 @@
     \showbtxfields[rotation=85] \page
     \showbtxfields[rotation=90] \page
 
+    \showbtxtables \page
+
 \stoptext
diff --git a/tex/context/base/publ-xml.mkiv b/tex/context/base/publ-xml.mkiv
index 007f9bb27..c08d84a9b 100644
--- a/tex/context/base/publ-xml.mkiv
+++ b/tex/context/base/publ-xml.mkiv
@@ -19,7 +19,7 @@
   {\dosingleempty\publ_convert_to_xml}
 
 \def\publ_convert_to_xml[#1]%
-  {\ctxcommand{convertbtxdatasettoxml("\iffirstargument#1\else\v!standard\fi",true)}} % or current when not empty
+  {\ctxcommand{convertbtxdatasettoxml("\iffirstargument#1\else\v!default\fi",true)}} % or current when not empty
 
 % \startxmlsetups btx:initialize
 %     \xmlregistereddocumentsetups{#1}{}
diff --git a/tex/context/base/status-files.pdf b/tex/context/base/status-files.pdf
index bebc7d2e5..a210afdc5 100644
--- a/tex/context/base/status-files.pdf
+++ b/tex/context/base/status-files.pdf
diff --git a/tex/context/base/status-lua.pdf b/tex/context/base/status-lua.pdf
index 789ee16eb..ab1a38859 100644
--- a/tex/context/base/status-lua.pdf
+++ b/tex/context/base/status-lua.pdf
diff --git a/tex/context/base/strc-bkm.lua b/tex/context/base/strc-bkm.lua
index 527188f23..f41f79db8 100644
--- a/tex/context/base/strc-bkm.lua
+++ b/tex/context/base/strc-bkm.lua
@@ -80,8 +80,13 @@ function bookmarks.overload(name,text)
         end
     end
     if ls then
-        ls.titledata.bookmark = text
+        local titledata = ls.titledata
+        if titledata then
+            titledata.bookmark = text
+        end
     end
+    -- last resort
+ -- context.writetolist({name},text,"")
 end
 
 local function stripped(str) -- kind of generic
@@ -124,6 +129,24 @@ function bookmarks.place()
                 local name = metadata.name
                 if not metadata.nolist or forced[name] then -- and levelmap[name] then
                     local titledata = li.titledata
+                    --
+                    if not titledata then
+                        local userdata = li.userdata
+                        if userdata then
+                            local first  = userdata.first
+                            local second = userdata.second
+                            if first then
+                                if second then
+                                    titledata = { title = first .. " " .. second }
+                                else
+                                    titledata = { title = first }
+                                end
+                            else
+                                titledata = { title = second }
+                            end
+                        end
+                    end
+                    --
                     if titledata then
                         if not blockdone then
                             if showblocktitle then
@@ -151,12 +174,11 @@ function bookmarks.place()
                         local title = titledata.bookmark
                         if not title or title == "" then
                             -- We could typeset the title and then convert it.
-                            if not structural then
-                                -- placeholder, todo: bookmarklabel
-                                title = name .. ": " .. (titledata.title or "?")
-                            else
+                         -- if not structural then
+                         --     title = titledata.title or "?")
+                         -- else
                                 title = titledata.title or "?"
-                            end
+                         -- end
                         end
                         if numbered[name] then
                             local sectiondata = sections.collected[li.references.section]
@@ -174,12 +196,14 @@ function bookmarks.place()
                         noflevels = noflevels + 1
                         local references = li.references
                         levels[noflevels] = {
-                            level     = lastlevel,
-                            title     = stripped(title), -- can be replaced by converter
-                            reference = references,   -- has internal and realpage
-                            opened    = allopen or opened[name],
-                            realpage  = references and references.realpage or 0, -- handy for later
-                            usedpage  = true,
+                            level      = lastlevel,
+                            title      = stripped(title), -- can be replaced by converter
+                            reference  = references,   -- has internal and realpage
+                            opened     = allopen or opened[name],
+                            realpage   = references and references.realpage or 0, -- handy for later
+                            usedpage   = true,
+                            structural = structural,
+                            name       = name,
                         }
                     end
                 end
@@ -204,7 +228,11 @@ function bookmarks.flatten(levels)
         local function showthem()
             for i=1,noflevels do
                 local level = levels[i]
-                report_bookmarks("%i > %s > %s",level.level,level.reference.block,level.title)
+             -- if level.structural then
+             --     report_bookmarks("%i > %s > %s",level.level,level.reference.block,level.title)
+             -- else
+                    report_bookmarks("%i > %s > %s > %s",level.level,level.reference.block,level.name,level.title)
+             -- end
             end
         end
         if trace_bookmarks then
diff --git a/tex/context/base/strc-bkm.mkiv b/tex/context/base/strc-bkm.mkiv
index 5f1acb686..48273787a 100644
--- a/tex/context/base/strc-bkm.mkiv
+++ b/tex/context/base/strc-bkm.mkiv
@@ -74,7 +74,11 @@
 \def\strc_bookmarks_bookmark_yes[#1]#2%
   {\begingroup
    \simplifycommands
-   \ctxcommand{overloadbookmark("#1",\!!bs\detokenize\expandafter{\normalexpanded{#2}}\!!es)}%
+   \ifnum\thenamedheadlevel{#1}>\zerocount
+     \ctxcommand{overloadbookmark("#1",\!!bs\detokenize\expandafter{\normalexpanded{#2}}\!!es)}%
+   \else
+     \strc_lists_write_to[#1][]{#2}{}% todo: a dedicated bookmark writer
+   \fi
    \endgroup}
 
 \def\strc_bookmarks_bookmark_nop[#1]#2%
diff --git a/tex/context/base/strc-def.mkiv b/tex/context/base/strc-def.mkiv
index 2f5116459..b4d2a5fea 100644
--- a/tex/context/base/strc-def.mkiv
+++ b/tex/context/base/strc-def.mkiv
@@ -32,6 +32,7 @@
 \defineresetset      [\s!default] [] [1] % each level
 \defineprefixset     [\s!default] [section-1,section-2,section-3] []
 
+\defineconversionset [\v!number]     [] [numbers]
 \defineconversionset [\v!pagenumber] [] [numbers]
 
 \defineprefixset     [\v!all]  [section-1,section-2,section-3,section-4,section-5,section-6,section-7,section-8] []
@@ -47,6 +48,9 @@
 \setupuserpagenumber
   [\c!numberconversionset=\v!pagenumber]
 
+\setupcounters
+  [\c!numberconversionset=\v!number]
+
 % \startsetups defaults:frontpart:pagenumbers:roman
 %     \defineconversionset[\c!frontpart:\c!pagenumber][][romannumerals]
 %     \setupuserpagenumber[\c!way=\v!by\v!block]
diff --git a/tex/context/base/strc-doc.lua b/tex/context/base/strc-doc.lua
index f91136f5d..f63832035 100644
--- a/tex/context/base/strc-doc.lua
+++ b/tex/context/base/strc-doc.lua
@@ -21,6 +21,7 @@ local concat, fastcopy = table.concat, table.fastcopy
 local max, min = math.max, math.min
 local allocate, mark, accesstable = utilities.storage.allocate, utilities.storage.mark, utilities.tables.accesstable
 local setmetatableindex = table.setmetatableindex
+local lpegmatch, P, C = lpeg.match, lpeg.P, lpeg.C
 
 local catcodenumbers      = catcodes.numbers
 local ctxcatcodes         = catcodenumbers.ctxcatcodes
@@ -59,6 +60,8 @@ local startapplyprocessor = processors.startapply
 local stopapplyprocessor  = processors.stopapply
 local strippedprocessor   = processors.stripped
 
+local convertnumber       = converters.convert
+
 local a_internal          = attributes.private('internal')
 
 local ctx_convertnumber   = context.convertnumber
@@ -600,10 +603,10 @@ local function process(index,numbers,ownnumbers,criterium,separatorset,conversio
             if ownnumber ~= "" then
                 result[#result+1] = ownnumber
             elseif conversion and conversion ~= "" then -- traditional (e.g. used in itemgroups) .. inherited!
-                result[#result+1] = converters.convert(conversion,number,language)
+                result[#result+1] = convertnumber(conversion,number,language)
             else
                 local theconversion = sets.get("structure:conversions",block,conversionset,index,"numbers")
-                result[#result+1] = converters.convert(theconversion,number,language)
+                result[#result+1] = convertnumber(theconversion,number,language)
             end
         else
             if ownnumber ~= "" then
@@ -921,7 +924,14 @@ end
 
 function sections.getnumber(depth,what) -- redefined here
     local sectiondata = sections.findnumber(depth,what)
-    context((sectiondata and sectiondata.numbers[depth]) or 0)
+    local askednumber = 0
+    if sectiondata then
+        local numbers = sectiondata.numbers
+        if numbers then
+            askednumber = numbers[depth] or 0
+        end
+    end
+    context(askednumber)
 end
 
 -- experimental
@@ -1003,8 +1013,16 @@ commands.setsectionentry            = sections.setentry
 commands.reportstructure            = sections.reportstructure
 --
 
-local byway = "^" .. v_by -- ugly but downward compatible
+-- local byway = "^" .. v_by -- ugly but downward compatible
+
+-- function commands.way(way)
+--     context((gsub(way,byway,"")))
+-- end
+
+local pattern = P(v_by)^-1 * C(P(1)^1)
 
 function commands.way(way)
-    context((gsub(way,byway,"")))
+    if way ~= "" then
+        context(lpegmatch(pattern,way))
+    end
 end
diff --git a/tex/context/base/strc-ini.lua b/tex/context/base/strc-ini.lua
index a48679e6f..e7dc97dcd 100644
--- a/tex/context/base/strc-ini.lua
+++ b/tex/context/base/strc-ini.lua
@@ -160,7 +160,7 @@ local function simplify(d,nodefault)
                     t[k] = simplify(v)
                 end
             elseif tv == "string" then
-                if v ~= "" and v ~= "default" then
+                if v ~= "" then
                     t[k] = v
                 end
             elseif tv == "boolean" then
@@ -336,7 +336,8 @@ function sets.getall(namespace,block,name)
     end
 end
 
--- messy (will be another keyword, fixedconversion)
+-- messy (will be another keyword, fixedconversion) .. needs to be documented too
+-- maybe we should cache
 
 local splitter = lpeg.splitat("::")
 
diff --git a/tex/context/base/strc-itm.lua b/tex/context/base/strc-itm.lua
index 675917d59..b736ff4e3 100644
--- a/tex/context/base/strc-itm.lua
+++ b/tex/context/base/strc-itm.lua
@@ -15,7 +15,6 @@ local getvariable = jobpasses.getfield
 
 local texsetcount = tex.setcount
 local texsetdimen = tex.setdimen
-local texgetcount = tex.getcount
 
 local f_stamp     = string.formatters["itemgroup:%s:%s"]
 local counts      = table.setmetatableindex("number")
@@ -24,6 +23,8 @@ local counts      = table.setmetatableindex("number")
 -- an itemgroup which in turn makes for less passes when one itemgroup
 -- entry is added or removed.
 
+local trialtypesetting = context.trialtypesetting
+
 function commands.analyzeitemgroup(name,level)
     local n = counts[name]
     if level == 1 then
@@ -39,7 +40,7 @@ end
 
 function commands.registeritemgroup(name,level,nofitems,maxwidth)
     local n = counts[name]
-    if texgetcount("@@trialtypesetting") == 0 then
+    if not trialtypesetting() then
         -- no trialtypsetting
         setvariable(f_stamp(name,n), { nofitems, maxwidth }, level)
     elseif level == 1 then
diff --git a/tex/context/base/strc-lst.lua b/tex/context/base/strc-lst.lua
index f3fd9867d..9e0309139 100644
--- a/tex/context/base/strc-lst.lua
+++ b/tex/context/base/strc-lst.lua
@@ -891,11 +891,11 @@ function lists.number(name,n,spec)
     end
 end
 
-function lists.prefixednumber(name,n,prefixspec,numberspec)
+function lists.prefixednumber(name,n,prefixspec,numberspec,forceddata)
     local data = lists.result[n]
     if data then
         helpers.prefix(data,prefixspec)
-        local numberdata = data.numberdata
+        local numberdata = data.numberdata or forceddata
         if numberdata then
             typesetnumber(numberdata,"number",numberspec or false,numberdata or false)
         end
diff --git a/tex/context/base/strc-lst.mkvi b/tex/context/base/strc-lst.mkvi
index 6e7e28e99..e5bdbdc99 100644
--- a/tex/context/base/strc-lst.mkvi
+++ b/tex/context/base/strc-lst.mkvi
@@ -453,13 +453,8 @@
 
 \let\dotaglistlocation\relax
 
-\unexpanded\def\strclistsentryprocess#tag#method#index#extra% This one is called at the lua end!
-  {\ctxcommand{pushlist(#index)}%
-   \edef\currentlist      {#tag}%
-   \edef\currentlistmethod{#method}%
-   \edef\currentlistindex {#index}%
-   \edef\currentlistextra {#extra}%
-   \listextraparameter\c!before
+\def\strc_lists_entry_process % assume things to be set up
+  {\listextraparameter\c!before
    \dostarttagged\t!listitem\currentlist
    \dotaglistlocation
    \csname\??structurelistprocessor
@@ -469,7 +464,15 @@
                                                                                 \s!default                     \fi\fi\fi
    \endcsname
    \dostoptagged
-   \listextraparameter\c!after
+   \listextraparameter\c!after}
+
+\unexpanded\def\strclistsentryprocess#tag#method#index#extra% This one is called at the lua end!
+  {\ctxcommand{pushlist(#index)}%
+   \edef\currentlist      {#tag}%
+   \edef\currentlistmethod{#method}%
+   \edef\currentlistindex {#index}%
+   \edef\currentlistextra {#extra}%
+   \strc_lists_entry_process
    \ctxcommand{poplist()}}
 
 % lists that have a number/title are kind of generic and can share code
@@ -964,6 +967,8 @@
                 \hsize\scratchhsize
                 \usealignparameter\listparameter
                 \ifdim\scratchwidth<\hsize
+                    % we have leftskip so we'd better just skip back instead of messing
+                    % with hang*
                     \edef\p_hang{\listparameter\c!hang}
                     \hangindent\dimexpr\wd\b_strc_lists_number+\scratchdistance\relax
                     \hangafter\ifx\p_hang\v!no\zerocount\else\plusone\fi
@@ -976,7 +981,7 @@
                     \scratchdistance\zeropoint
                 \fi
                 \parindent\zeropoint
-                \dontleavehmode
+                \dontleavehmode % this nils hang: i need to figure out why
                 % % topaligned
                 %
                 % \scratchdimen\wd\b_strc_lists_number
@@ -1193,6 +1198,90 @@
    \listparameter\c!after
 \stopsetups
 
+%D One special for publications (as Alan loves to hangindent). No fonts and
+%D such (for now). No interaction either as that is dealt with elsewhere.
+%D
+%D \currentlistsymbol
+%D \currentlistentry
+%D \currentlistentrypagenumber % not really used
+
+\definelistalternative
+  [\v!paragraph]
+  [\c!filler=\hskip.25\emwidth,
+   \c!renderingsetup=\??listrenderings:\v!paragraph]
+
+\startsetups[\??listrenderings:\v!paragraph]
+    \endgraf % are we grouped?
+    \typo_injectors_check_list % ?
+    \listparameter\c!before
+    \endgraf
+    \begingroup
+    \forgetall
+    \noindent
+    \parindent\zeropoint
+    \edef\p_width{\listparameter\c!width}%
+    \edef\p_distance{\listparameter\c!distance}% we are nice for bib users
+    \edef\p_margin{\listparameter\c!margin}% we are nice for bib users
+    \ifx\p_distance\v!none
+        \scratchdistance\zeropoint
+    \else
+        \scratchdistance\p_distance
+    \fi
+    \ifx\p_margin\v!none
+        \scratchoffset\zeropoint
+    \else
+        \scratchoffset\p_margin
+    \fi
+    \ifx\p_width\v!fit
+        \scratchwidth\zeropoint
+        \leftskip\scratchoffset
+    \else
+        \scratchwidth\p_width
+        \ifdim\scratchoffset=\zeropoint
+            \leftskip\dimexpr\scratchwidth+\scratchdistance\relax
+        \else
+            \leftskip\scratchoffset
+        \fi
+    \fi
+    \usealignparameter\listparameter
+    \hskip-\leftskip
+    \ifconditional\c_lists_has_number
+        \ifconditional\c_lists_show_number
+            \setbox\scratchbox\hbox\ifdim\scratchwidth>\zeropoint to \scratchwidth\fi
+                \bgroup
+                    \useliststyleandcolor\c!numberstyle\c!numbercolor
+                    \currentlistsymbol
+                    \hss
+                \egroup
+            \ifdim\wd\scratchbox>\zeropoint
+                \box\scratchbox
+                \hskip\scratchdistance\relax
+            \fi
+        \fi
+    \fi
+    \begingroup
+        \useliststyleandcolor\c!textstyle\c!textcolor
+        \setstrut
+        \begstrut
+        \currentlistentrytitle
+        \endstrut
+    \endgroup
+    \ifconditional\c_lists_has_page
+        \ifconditional\c_lists_show_page
+            \nobreak
+            \listalternativeparameter\c!filler\relax
+            \begingroup
+                \useliststyleandcolor\c!pagestyle\c!pagecolor
+                \currentlistentrypagenumber
+            \endgroup
+        \fi
+    \fi
+    \endgraf
+    \endgroup
+    \allowbreak
+    \listparameter\c!after
+\stopsetups
+
 %D List elements are packaged in such a way that we can click on them
 %D in an interactive document. Here are a few helpers.
 
diff --git a/tex/context/base/strc-not.mkvi b/tex/context/base/strc-not.mkvi
index 142696b28..3de4766ca 100644
--- a/tex/context/base/strc-not.mkvi
+++ b/tex/context/base/strc-not.mkvi
@@ -1830,4 +1830,24 @@
 %   [ownnote]
 %   [\ownnotesymbol]
 
+% tricky:
+%
+% \enabletrackers[nodes.areas]
+% \enabletrackers[nodes.references]
+% \enabletrackers[nodes.destinations]
+%
+% \setupnotes[interaction=all,rule=no]
+% \setupinteraction[state=start,focus=standard]
+%
+% \starttext
+%     \goto{\input tufte\relax}[page(2)] \par
+%     \ruledhbox{\gotobox{\vtop{\input tufte\relax}}[page(2)]} \par
+%     \ruledhbox{\gotobox{\vbox{\input tufte\relax}}[page(2)]} \par
+%     % \completecontent
+%     % \chapter{Chapter}
+%     % \dorecurse{5}{\input knuth}
+%     a\footnote{\input tufte\par\input ward\relax}
+% \stoptext
+
 \protect \endinput
+
diff --git a/tex/context/base/strc-num.mkiv b/tex/context/base/strc-num.mkiv
index 7c3ac17db..5adec5afd 100644
--- a/tex/context/base/strc-num.mkiv
+++ b/tex/context/base/strc-num.mkiv
@@ -27,7 +27,9 @@
 
 \installcommandhandler \??counter {counter} \??counter
 
-\let\setupstructurecounting\setupcounter
+\let\setupcounters\setupcounter
+
+\let\setupstructurecounting\setupcounter % will disappear
 
 \setupcounter
   [\c!way=\v!by\v!chapter,
diff --git a/tex/context/base/strc-ref.lua b/tex/context/base/strc-ref.lua
index 1a4ccecd8..58ef9625f 100644
--- a/tex/context/base/strc-ref.lua
+++ b/tex/context/base/strc-ref.lua
@@ -1955,12 +1955,12 @@ function genericfilters.text(data)
     end
 end
 
-function genericfilters.number(data,what,prefixspec) -- todo: spec and then no stopper
+function genericfilters.number(data,what,prefixspec,numberspec)
     if data then
         numberdata = lists.reordered(data) -- data.numberdata
         if numberdata then
             helpers.prefix(data,prefixspec)
-            sections.typesetnumber(numberdata,"number",numberdata)
+            sections.typesetnumber(numberdata,"number",numberspec,numberdata)
         else
             local useddata = data.useddata
             if useddata and useddata.number then
diff --git a/tex/context/base/strc-ref.mkvi b/tex/context/base/strc-ref.mkvi
index d2f36eb74..4d4b07e9c 100644
--- a/tex/context/base/strc-ref.mkvi
+++ b/tex/context/base/strc-ref.mkvi
@@ -2046,15 +2046,36 @@
 
 \installcorenamespace{referencingprefix}
 
+% \def\getreferencestructureprefix#kind#name#category% name will change
+%   {{
+%         prefix        =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefix",
+%         separatorset  =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixseparatorset",
+%         conversion    =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconversion",
+%         conversionset =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconversionset",
+%         set           =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixset",
+%         segments      =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixsegments",
+%         connector     = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconnector\!!es,
+%   }}
+
 \def\getreferencestructureprefix#kind#name#category% name will change
   {{
         prefix        =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefix",
         separatorset  =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixseparatorset",
         conversion    =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconversion",
         conversionset =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconversionset",
+        starter       = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixstarter\!!es,
+        stopper       = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixstopper\!!es,
         set           =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixset",
         segments      =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixsegments",
         connector     = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!prefixconnector\!!es,
+  },
+  {
+        separatorset  =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!numberseparatorset",
+        conversion    =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!numberconversion",
+        conversionset =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!numberconversionset",
+        starter       = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!numberstarter\!!es,
+        stopper       = \!!bs\referencestructureprefixparameter{#kind}{#name}{#category}\c!numberstopper\!!es,
+        segments      =     "\referencestructureprefixparameter{#kind}{#name}{#category}\c!numbersegments",
   }}
 
 \unexpanded\def\setupreferencestructureprefix
diff --git a/tex/context/base/strc-reg.lua b/tex/context/base/strc-reg.lua
index 0d59cc321..a8d388a71 100644
--- a/tex/context/base/strc-reg.lua
+++ b/tex/context/base/strc-reg.lua
@@ -983,22 +983,18 @@ function registers.flush(data,options,prefixspec,pagespec)
         local data = sublist.data
         local d, n = 0, 0
         ctx_startregistersection(sublist.tag)
-
--- -- no: we lost the see word
---
---         for d=1,#data do
---             local entry = data[d]
---             if entry.metadata.kind == "see" then
---                 local list = entry.list
---                 if #list > 1 then
---                     list[#list] = nil
---                 else
---                     -- we have an \seeindex{Foo}{Bar} without Foo being defined anywhere
---                     report_registers("invalid see entry in register %a, reference %a",entry.metadata.name,list[1][1])
---                 end
---             end
---         end
-
+        for d=1,#data do
+            local entry = data[d]
+            if entry.metadata.kind == "see" then
+                local list = entry.list
+                if #list > 1 then
+                    list[#list] = nil
+                else
+                    -- we have an \seeindex{Foo}{Bar} without Foo being defined anywhere
+                    report_registers("invalid see entry in register %a, reference %a",entry.metadata.name,list[1][1])
+                end
+            end
+        end
         -- ok, this is tricky: we use e[i] delayed so we need it to be local
         -- but we don't want to allocate too many entries so there we go
         while d < #data do
diff --git a/tex/context/base/strc-sec.mkiv b/tex/context/base/strc-sec.mkiv
index 26ddfaac0..5c539794f 100644
--- a/tex/context/base/strc-sec.mkiv
+++ b/tex/context/base/strc-sec.mkiv
@@ -413,7 +413,7 @@
             \definemarking[\currenthead]         [\currentheadsection]%
             \definemarking[\currenthead\v!number][\currentheadsection]%
             \setupmarking [\currenthead]         [\c!filtercommand=\noexpand\sectionheadmarkingtitle {\currenthead}]%
-            \setupmarking [\currenthead\c!number][\c!filtercommand=\noexpand\sectionheadmarkingnumber{\currenthead}]%
+            \setupmarking [\currenthead\v!number][\c!filtercommand=\noexpand\sectionheadmarkingnumber{\currenthead}]%
         }%
         \doifelselist\currenthead\donothing
           {\definelist[\currenthead][\c!prefix=\v!no]}%
diff --git a/tex/context/base/syst-aux.lua b/tex/context/base/syst-aux.lua
index c65f97fd0..69c9f8168 100644
--- a/tex/context/base/syst-aux.lua
+++ b/tex/context/base/syst-aux.lua
@@ -131,4 +131,4 @@ function commands.upper(s) context(upper(s)) end
 function commands.lower(s) context(lower(s)) end
 function commands.strip(s) context(strip(s)) end
 
-function commands.converteddimen(dimen,unit) context(todimen(dimen,unit or "pt","%0.5f")) end -- no unit appended
+function commands.converteddimen(dimen,unit) context(todimen(dimen,unit or "pt","%0.5f")) end -- no unit appended (%F)
diff --git a/tex/context/base/syst-aux.mkiv b/tex/context/base/syst-aux.mkiv
index 81b6406f9..38afd034f 100644
--- a/tex/context/base/syst-aux.mkiv
+++ b/tex/context/base/syst-aux.mkiv
@@ -11,13 +11,17 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
-%D There are some references to \LUA\ variants here but these concern
-%D (often old) experiments, moved from local test modules to here,
-%D cleaned up, but not really used. After all it's not that urgent
-%D and replacing helpers is a delicate process. Don't depend on it.
+%D There are some references to \LUA\ variants here but these concern (often old)
+%D experiments, moved from local test modules to here, cleaned up, but not really
+%D used. After all it's not that urgent and replacing helpers is a delicate process.
+%D Don't depend on it.
 
 \registerctxluafile{syst-aux}{1.001}
 
+% A dedicated primitive \ifvoidmacro\cs == \ifx\cs\empty is some 10% faster but
+% probably not that noticeable in practice. An \ifvoidtoks might make sense but we
+% don't test that often for it (and it's more work to implement in the engine).
+
 %D This is a stripped down combination of:
 %D
 %D \startitemize
@@ -26,20 +30,18 @@
 %D \item \type {syst-new.tex}
 %D \stopitemize
 %D
-%D We keep them around (for \MKII) so you can find comments,
-%D experiences, intermediate versions and cleaner variants
-%D there (and also non-\ETEX\ variants).
+%D We keep them around (for \MKII) so you can find comments, experiences,
+%D intermediate versions and cleaner variants there (and also non-\ETEX\ variants).
 %D
-%D Contrary to the older files, we now assume that this one
-%D is used in \CONTEXT\ and therefore we might also assume that
-%D some basic functionality is available.
+%D Contrary to the older files, we now assume that this one is used in \CONTEXT\ and
+%D therefore we might also assume that some basic functionality is available.
 %D
-%D The original files contain previous implementations and notes about
-%D performance. This file will be stripped down in due time.
-
-%D Some of the macros here were only used in the bibliography module. They
-%D have been be moved to a separate syst module since the bib module is no
-%D longer using them. Some more will go away.
+%D The original files contain previous implementations and notes about performance.
+%D This file will be stripped down in due time.
+%D
+%D Some of the macros here were only used in the bibliography module. They have been
+%D be moved to a separate syst module since the bib module is no longer using them.
+%D Some more will go away.
 
 \unprotect
 
@@ -3403,6 +3405,7 @@
   {\expandafter\syst_helpers_checked_stripped_csname\string#1}
 
 \def\syst_helpers_checked_stripped_csname#1%
+ %{\ifx#1\letterbackslash\else#1\fi}
   {\if\noexpand#1\letterbackslash\else#1\fi}
 
 %D \macros
diff --git a/tex/context/base/syst-ini.mkiv b/tex/context/base/syst-ini.mkiv
index 7628788d2..879f3ed53 100644
--- a/tex/context/base/syst-ini.mkiv
+++ b/tex/context/base/syst-ini.mkiv
@@ -638,6 +638,8 @@
 %D
 %D In \LUATEX\ we have ways around this.
 
+% no longer \errorstopmode cf. plain tex 3.141592653
+
 \normalprotected\def\tracingall
   {\tracingonline    \plusone
    \tracingcommands  \plusthree
@@ -654,8 +656,7 @@
    \tracingifs       \plusone
    \tracingscantokens\plusone
    \tracingnesting   \plusone
-   \tracingassigns   \plustwo
-   \errorstopmode}
+   \tracingassigns   \plustwo}
 
 \normalprotected\def\loggingall
   {\tracingall
diff --git a/tex/context/base/syst-lua.lua b/tex/context/base/syst-lua.lua
index 95f8628ee..c50c5f1ca 100644
--- a/tex/context/base/syst-lua.lua
+++ b/tex/context/base/syst-lua.lua
@@ -123,13 +123,18 @@ function commands.ntimes(str,n)
     context(rep(str,n or 1))
 end
 
-function commands.write(n,str)
-    if n == 18 then
-        os.execute(str)
-    elseif n == 16 then
-        logs.report(str)
-    else
-        -- at the tex end we can still drop the write
-        context.writeviatex(n,str)
-    end
+function commands.execute(str)
+    os.execute(str) -- wrapped in sandbox
 end
+
+-- function commands.write(n,str)
+--     if n == 18 then
+--         os.execute(str)
+--     elseif n == 16 then
+--         -- immediate
+--         logs.report(str)
+--     else
+--         -- at the tex end we can still drop the write / also delayed vs immediate
+--         context.writeviatex(n,str)
+--     end
+-- end
diff --git a/tex/context/base/syst-lua.mkiv b/tex/context/base/syst-lua.mkiv
index c146b81b7..2a6bcdf6d 100644
--- a/tex/context/base/syst-lua.mkiv
+++ b/tex/context/base/syst-lua.mkiv
@@ -72,15 +72,28 @@
 % which in fact we can do by defining write18 as macro instead of
 % primitive ... todo.
 
-\unexpanded\def\write#1#%
-  {\syst_write{#1}}
+% \unexpanded\def\write#1#%
+%   {\syst_write{#1}}
+%
+% \def\syst_write#1#2%
+%   {\ctxcommand{write(\number#1,\!!bs\normalunexpanded{#2}\!!es)}}
+%
+% \unexpanded\def\writeviatex#1#2%
+%   {\ifx\normalwrite\relax\else
+%      \normalwrite#1{#2}%
+%    \fi}
+
+% we have no way yet to pickup \immediate unless we redefine it
+% we assume immediate execution
 
-\def\syst_write#1#2%
-  {\ctxcommand{write(\number#1,\!!bs#2\!!es)}}
+\def\syst_write_execute#1%
+  {\ctxcommand{execute(\!!bs#1\!!es)}}
 
-\unexpanded\def\writeviatex#1#2%
-  {\ifx\normalwrite\relax\else
-     \normalwrite#1{#2}%
+\unexpanded\def\write#1#%
+  {\ifnum#1=18
+     \expandafter\syst_write_execute
+   \else
+     \normalwrite#1%
    \fi}
 
 \protect \endinput
diff --git a/tex/context/base/syst-rtp.mkiv b/tex/context/base/syst-rtp.mkiv
index f65e599ec..58278972b 100644
--- a/tex/context/base/syst-rtp.mkiv
+++ b/tex/context/base/syst-rtp.mkiv
@@ -13,6 +13,6 @@
 
 \unprotect
 
-\def\executesystemcommand#1{\ctxlua{os.execute([[#1]])}}
+\def\executesystemcommand#1{\ctxlua{os.execute(\!!bs#1\!!es)}}
 
 \protect \endinput
diff --git a/tex/context/base/tabl-xtb.mkvi b/tex/context/base/tabl-xtb.mkvi
index 56e52794f..d0997c045 100644
--- a/tex/context/base/tabl-xtb.mkvi
+++ b/tex/context/base/tabl-xtb.mkvi
@@ -29,6 +29,8 @@
 % - maybe only tag the box
 % - scale to fit
 %
+% - buffers permit verbatim but are not always handy
+
 %D This module started as an afternoon experiment and surprisingly could be
 %D mostly finished the same evening. Of course it builds upon existing
 %D functionality. The main reason for writing it is that we occasionally
diff --git a/tex/context/base/toks-ini.lua b/tex/context/base/toks-ini.lua
index 0f0c016f8..82c801b88 100644
--- a/tex/context/base/toks-ini.lua
+++ b/tex/context/base/toks-ini.lua
@@ -5,338 +5,219 @@ if not modules then modules = { } end modules ['toks-ini'] = {
     license   = "see context related readme files"
 }
 
-local context, commands = context, commands
-local utfbyte, utfchar, utfvalues = utf.byte, utf.char, utf.values
-local format, gsub = string.format, string.gsub
-
---[[ldx--
-<p>This code is experimental and needs a cleanup. The visualizers will move to
-a module.</p>
---ldx]]--
-
--- 1 = command, 2 = modifier (char), 3 = controlsequence id
---
--- callback.register('token_filter', token.get_next)
---
--- token.get_next()
--- token.expand()
--- token.create()
--- token.csname_id()
--- token.csname_name(v)
--- token.command_id()
--- token.command_name(v)
--- token.is_expandable()
--- token.is_activechar()
--- token.lookup(v)
-
--- actually, we can use token registers to store tokens
-
-local token, tex = token, tex
-
-local createtoken   = token.create
-local csname_id     = token.csname_id
-local command_id    = token.command_id
-local command_name  = token.command_name
-local get_next      = token.get_next
-local expand        = token.expand
-local is_activechar = token.is_activechar
-local csname_name   = token.csname_name
-
-tokens        = tokens or { }
-local tokens  = tokens
-
-tokens.vbox   = createtoken("vbox")
-tokens.hbox   = createtoken("hbox")
-tokens.vtop   = createtoken("vtop")
-tokens.bgroup = createtoken(utfbyte("{"), 1)
-tokens.egroup = createtoken(utfbyte("}"), 2)
-
-tokens.letter = function(chr) return createtoken(utfbyte(chr), 11) end
-tokens.other  = function(chr) return createtoken(utfbyte(chr), 12) end
-
-tokens.letters = function(str)
-    local t, n = { }, 0
-    for chr in utfvalues(str) do
-        n = n + 1
-        t[n] = createtoken(chr, 11)
-    end
-    return t
-end
-
-tokens.collectors     = tokens.collectors or { }
-local collectors      = tokens.collectors
-
-collectors.data       = collectors.data or { }
-local collectordata   = collectors.data
-
-collectors.registered = collectors.registered or { }
-local registered      = collectors.registered
-
-local function printlist(data)
-    callbacks.push('token_filter', function ()
-       callbacks.pop('token_filter') -- tricky but the nil assignment helps
-       return data
-    end)
-end
-
-tex.printlist = printlist -- will change to another namespace
-
-function collectors.flush(tag)
-    printlist(collectordata[tag])
-end
-
-function collectors.test(tag)
-    printlist(collectordata[tag])
-end
-
-function collectors.register(name)
-    registered[csname_id(name)] = name
-end
-
-local call   = command_id("call")
-local letter = command_id("letter")
-local other  = command_id("other_char")
-
-function collectors.install(tag,end_cs)
-    local data, d = { }, 0
-    collectordata[tag] = data
-    local endcs = csname_id(end_cs)
-    while true do
-        local t = get_next()
-        local a, b = t[1], t[3]
-        if b == endcs then
-            context["end_cs"]()
-            return
-        elseif a == call and registered[b] then
-            expand()
-        else
-            d = d + 1
-            data[d] = t
+tokens = tokens or { }
+
+local tokens     = tokens
+local tostring   = tostring
+local utfchar    = utf.char
+local char       = string.char
+local printtable = table.print
+local concat     = table.concat
+
+if newtoken then
+
+    if setinspector then
+
+        local istoken = newtoken.is_token
+        local simple  = { letter = "letter", other_char = "other" }
+
+        local function astable(t)
+            if t and istoken(t) then
+                local cmdname = t.cmdname
+                local simple  = simple[cmdname]
+                if simple then
+                    return {
+                        category   = simple,
+                        character  = utfchar(t.mode) or nil,
+                    }
+                else
+                    return {
+                        command    = t.command,
+                        id         = t.id,
+                        tok        = t.tok,
+                        csname     = t.csname,
+                        active     = t.active,
+                        expandable = t.expandable,
+                        protected  = t.protected,
+                        mode       = t.mode,
+                        cmdname    = cmdname,
+                    }
+                end
+            end
         end
-    end
-end
-
-function collectors.handle(tag,handle,flush)
-    collectordata[tag] = handle(collectordata[tag])
-    if flush then
-        collectors.flush(tag)
-    end
-end
 
-local show_methods      = { }
-collectors.show_methods = show_methods
+        tokens.istoken = istoken
+        tokens.astable = astable
 
-function collectors.show(tag, method)
-    if type(tag) == "table" then
-        show_methods[method or 'a'](tag)
-    else
-        show_methods[method or 'a'](collectordata[tag])
-    end
-end
+        setinspector(function(v) if istoken(v) then printtable(astable(v),tostring(v)) return true end end)
 
-function collectors.defaultwords(t,str)
-    local n = #t
-    n = n + 1
-    t[n] = tokens.bgroup
-    n = n + 1
-    t[n] = createtoken("red")
-    for i=1,#str do
-        n = n + 1
-        t[n] = tokens.other('*')
     end
-    n = n + 1
-    t[n] = tokens.egroup
-end
 
-function collectors.dowithwords(tag,handle)
-    local t, w, tn, wn = { }, { }, 0, 0
-    handle = handle or collectors.defaultwords
-    local tagdata = collectordata[tag]
-    for k=1,#tagdata do
-        local v = tagdata[k]
-        if v[1] == letter then
-            wn = wn + 1
-            w[wn] = v[2]
-        else
-            if wn > 0 then
-                handle(t,w)
-                wn = 0
+    local scan_toks    = newtoken.scan_toks
+    local scan_string  = newtoken.scan_string
+    local scan_int     = newtoken.scan_int
+    local scan_code    = newtoken.scan_code
+    local scan_dimen   = newtoken.scan_dimen
+    local scan_glue    = newtoken.scan_glue
+    local scan_keyword = newtoken.scan_keyword
+    local scan_token   = newtoken.scan_token
+
+    local get_next     = newtoken.get_next
+
+    local set_macro    = newtoken.set_macro
+
+    local bits = {
+        escape      = 2^ 0,
+        begingroup  = 2^ 1,
+        endgroup    = 2^ 2,
+        mathshift   = 2^ 3,
+        alignment   = 2^ 4,
+        endofline   = 2^ 5,
+        parameter   = 2^ 6,
+        superscript = 2^ 7,
+        subscript   = 2^ 8,
+        ignore      = 2^ 9,
+        space       = 2^10, -- 1024
+        letter      = 2^11,
+        other       = 2^12,
+        active      = 2^13,
+        comment     = 2^14,
+        invalid     = 2^15,
+        --
+        character   = 2^11 + 2^12,
+        whitespace  = 2^13 + 2^10, --    / needs more checking
+        --
+        open        = 2^10 + 2^1, -- space + begingroup
+        close       = 2^10 + 2^2, -- space + endgroup
+    }
+
+ -- for k, v in next, bits do bits[v] = k end
+
+    tokens.bits = bits
+
+    local space_bits = bits.space
+
+    -- words are space or \relax terminated and the trailing space is gobbled; a word
+    -- can contain any non-space letter/other
+
+    local t = { } -- small optimization, a shared variable that is not reset
+
+    local function scan_word()
+        local n = 0
+        while true do
+            local c = scan_code()
+            if c then
+                n = n + 1
+                t[n] = utfchar(c)
+            elseif scan_code(space_bits) then
+                if n > 0 then
+                    break
+                end
+            elseif n > 0 then
+                break
+            else
+                return
             end
-            tn = tn + 1
-            t[tn] = v
         end
+        return concat(t,"",1,n)
     end
-    if wn > 0 then
-        handle(t,w)
-    end
-    collectordata[tag] = t
-end
 
-local function showtoken(t)
-    if t then
-        local cmd, chr, id, cs, name = t[1], t[2], t[3], nil, command_name(t) or ""
-        if cmd == letter or cmd == other then
-            return format("%s-> %s -> %s", name, chr, utfchar(chr))
-        elseif id > 0 then
-            cs = csname_name(t) or nil
-            if cs then
-                return format("%s-> %s", name, cs)
-            elseif tonumber(chr) < 0 then
-                return format("%s-> %s", name, id)
+    -- so we gobble the space (like scan_int) (number has to be space or non-char terminated
+    -- as we accept 0xabcd and such so there is no clear separator for a keyword
+
+    local function scan_number(base)
+        local n = 0
+        while true do
+            local c = scan_code()
+            if c then
+                n = n + 1
+                t[n] = char(c)
+            elseif scan_code(space_bits) then
+                if n > 0 then
+                    break
+                end
+            elseif n > 0 then
+                break
             else
-                return format("%s-> (%s,%s)", name, chr, id)
+                return
             end
-        else
-            return format("%s", name)
-        end
-    else
-        return "no node"
-    end
-end
-
-collectors.showtoken = showtoken
-
-function collectors.trace()
-    local t = get_next()
-    logs.report("tokenlist",showtoken(t))
-    return t
-end
-
--- these might move to a runtime module
-
-show_methods.a = function(data) -- no need to store the table, just pass directly
-    local function row(one,two,three,four,five)
-        context.NC() context(one)
-        context.NC() context(two)
-        context.NC() context(three)
-        context.NC() context(four)
-        context.NC() context(five)
-        context.NC() context.NR()
-    end
-    context.starttabulate { "|T|Tr|cT|Tr|T|" }
-    row("cmd","chr","","id","name")
-    context.HL()
-    for _,v in next, data do
-        local cmd, chr, id, cs, sym = v[1], v[2], v[3], "", ""
-        local name = gsub(command_name(v) or "","_","\\_")
-        if id > 0 then
-            cs = csname_name(v) or ""
-            if cs ~= "" then cs = "\\string " .. cs end
-        else
-            id = ""
-        end
-        if cmd == letter or cmd == other then
-            sym = "\\char " .. chr
         end
-        if tonumber(chr) < 0 then
-            row(name,"",sym,id,cs)
+        local s = concat(t,"",1,n)
+        if base then
+            return tonumber(s,base)
         else
-            row(name,chr,sym,id,cs)
+            return tonumber(s)
         end
     end
-    context.stoptabulate()
-end
 
-local function show_b_c(data,swap) -- no need to store the table, just pass directly
-    local function row(one,two,three)
-        context.NC() context(one)
-        context.NC() context(two)
-        context.NC() context(three)
-        context.NC() context.NR()
-    end
-    if swap then
-        context.starttabulate { "|Tl|Tl|Tr|" }
-    else
-        context.starttabulate { "|Tl|Tr|Tl|" }
-    end
-    row("cmd","chr","name")
-    context.HL()
-    for _,v in next, data do
-        local cmd, chr, id, cs, sym = v[1], v[2], v[3], "", ""
-        local name = gsub(command_name(v) or "","_","\\_")
-        if id > 0 then
-            cs = csname_name(v) or ""
-        end
-        if cmd == letter or cmd == other then
-            sym = "\\char " .. chr
-        elseif cs == "" then
-            -- okay
-        elseif is_activechar(v) then
-            sym = "\\string " .. cs
-        else
-            sym = "\\string\\" .. cs
-        end
-        if swap then
-            row(name,sym,chr)
-        elseif tonumber(chr) < 0 then
-            row(name,"",sym)
+ -- -- the next one cannot handle \iftrue true\else false\fi
+ --
+ -- local function scan_boolean()
+ --     if scan_keyword("true") then
+ --         return true
+ --     elseif scan_keyword("false") then
+ --         return false
+ --     else
+ --         return nil
+ --     end
+ -- end
+
+    local function scan_boolean()
+        local kw = scan_word()
+        if kw == "true" then
+            return true
+        elseif kw == "false" then
+            return false
         else
-            row(name,chr,sym)
+            return nil
         end
     end
-    context.stoptabulate()
-end
-
--- Even more experimental ...
 
-show_methods.b = function(data) show_b_c(data,false) end
-show_methods.c = function(data) show_b_c(data,true ) end
-
-local remapper      = { }  -- namespace
-collectors.remapper = remapper
-
-local remapperdata  = { }  -- user mappings
-remapper.data       = remapperdata
-
-function remapper.store(tag,class,key)
-    local s = remapperdata[class]
-    if not s then
-        s = { }
-        remapperdata[class] = s
-    end
-    s[key] = collectordata[tag]
-    collectordata[tag] = nil
-end
-
-function remapper.convert(tag,toks)
-    local data = remapperdata[tag]
-    local leftbracket, rightbracket = utfbyte('['), utfbyte(']')
-    local skipping = 0
-    -- todo: math
-    if data then
-        local t, n = { }, 0
-        for s=1,#toks do
-            local tok = toks[s]
-            local one, two = tok[1], tok[2]
-            if one == 11 or one == 12 then
-                if two == leftbracket then
-                    skipping = skipping + 1
-                    n = n + 1 ; t[n] = tok
-                elseif two == rightbracket then
-                    skipping = skipping - 1
-                    n = n + 1 ; t[n] = tok
-                elseif skipping == 0 then
-                    local new = data[two]
-                    if new then
-                        if #new > 1 then
-                            for n=1,#new do
-                                n = n + 1 ; t[n] = new[n]
-                            end
-                        else
-                            n = n + 1 ; t[n] = new[1]
-                        end
-                    else
-                        n = n + 1 ; t[n] = tok
-                    end
-                else
-                    n = n + 1 ; t[n] = tok
-                end
-            else
-                n = n + 1 ; t[n] = tok
-            end
-        end
-        return t
-    else
-        return toks
-    end
-end
+    tokens.scanners = { -- these expand
+        token     = scan_token or get_next,
+        toks      = scan_toks,
+        tokens    = scan_toks,
+        dimen     = scan_dimen,
+        dimension = scan_dimen,
+        glue      = scan_glue,
+        skip      = scan_glue,
+        integer   = scan_int,
+        count     = scan_int,
+        string    = scan_string,
+        code      = scan_code,
+        word      = scan_word,
+        number    = scan_number,
+        boolean   = scan_boolean,
+        keyword   = scan_keyword,
+    }
+
+    tokens.getters = { -- these don't expand
+        token = get_next,
+    }
+
+    tokens.setters = {
+        macro = set_macro,
+    }
+
+end
+
+-- static int run_scan_token(lua_State * L)
+-- {
+--     saved_tex_scanner texstate;
+--     save_tex_scanner(texstate);
+--     get_x_token();
+--     make_new_token(L, cur_cmd, cur_chr, cur_cs);
+--     unsave_tex_scanner(texstate);
+--     return 1;
+-- }
+--
+-- static int run_get_future(lua_State * L)
+-- {
+--  /* saved_tex_scanner texstate; */
+--  /* save_tex_scanner(texstate); */
+--     get_token();
+--     make_new_token(L, cur_cmd, cur_chr, cur_cs);
+--     back_input();
+--  /* unsave_tex_scanner(texstate); */
+--     return 1;
+-- }
diff --git a/tex/context/base/toks-ini.mkiv b/tex/context/base/toks-ini.mkiv
index 4eb756b75..c23b84e06 100644
--- a/tex/context/base/toks-ini.mkiv
+++ b/tex/context/base/toks-ini.mkiv
@@ -17,54 +17,6 @@
 
 \unprotect
 
-%D Handy for manuals \unknown
-
-\unexpanded\def\starttokens  [#1]{\ctxlua{tokens.collectors.install("#1","stoptokens")}}
-           \let\stoptokens        \relax
-           \def\flushtokens  [#1]{\ctxlua{tokens.collectors.flush("#1")}}
-           \def\showtokens   [#1]{\ctxlua{tokens.collectors.show("#1")}}
-           \def\testtokens   [#1]{\ctxlua{tokens.collectors.with_words("#1")}}
-           \def\registertoken  #1{\ctxlua{tokens.collectors.register("#1")}}
-
-%D Inspired by a prototype by Taco for Thomas cum suis.
-
-% \defineremapper[babelgreek]
-%
-% \remapcharacter[babelgreek][`a]{\alpha}
-% \remapcharacter[babelgreek][`b]{\beta}
-% \remapcharacter[babelgreek][`c]{\gamma}
-% \remapcharacter[babelgreek][`d]{OEPS}
-%
-% \starttext
-%
-% [\startbabelgreek
-% a b c some stuff here \blank[big] oeps b d
-% \stopbabelgreek]
-%
-% [\babelgreek{some stuff here}]
-%
-% \stoptext
-
-\unexpanded\def\defineremapper[#1]%
-  {\setuevalue{\e!start#1}{\toks_start_remapper{#1}}%
-   \setuevalue{\e!stop #1}{\toks_stop_remapper {#1}}%
-   \letvalue{#1}\relax
-   \normalexpanded{\expandafter\def\csname#1\endcsname##1{\csname\e!start#1\endcsname##1\csname\e!stop#1\endcsname}}}
-
-\unexpanded\def\toks_start_remapper#1%
-  {\ctxlua{tokens.collectors.install("#1", "\e!stop#1")}}
-
-\unexpanded\def\toks_stop_remapper#1%
-  {\ctxlua{tokens.collectors.handle("#1",function(str) return tokens.collectors.remapper.convert("#1",str) end, true)}}
-
-\unexpanded\def\remaptokens#1%
-  {\ctxlua{tokens.collectors.handle("#1",function(str) return tokens.collectors.remapper.convert("#1",str) end)}}
-
-\unexpanded\def\remapcharacter
-  {\dodoubleempty\toks_remap_character}
-
-\def\toks_remap_character[#1][#2]#3%
-  {\ctxlua{tokens.collectors.install("store", "ctxlua")}#3%
-   \ctxlua{tokens.collectors.remapper.store("store","#1",\number#2)}}
+% nothing yet
 
 \protect \endinput
diff --git a/tex/context/base/toks-map.lua b/tex/context/base/toks-map.lua
new file mode 100644
index 000000000..9120c2084
--- /dev/null
+++ b/tex/context/base/toks-map.lua
@@ -0,0 +1,70 @@
+if not modules then modules = { } end modules ['toks-map'] = {
+    version   = 1.001,
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- Even more experimental ... this used to be part of toks-ini but as
+-- this kind of remapping has not much use it is not loaded in the
+-- core. We just keep it here for old times sake.
+
+-- local remapper      = { }  -- namespace
+-- collectors.remapper = remapper
+--
+-- local remapperdata  = { }  -- user mappings
+-- remapper.data       = remapperdata
+--
+-- function remapper.store(tag,class,key)
+--     local s = remapperdata[class]
+--     if not s then
+--         s = { }
+--         remapperdata[class] = s
+--     end
+--     s[key] = collectordata[tag]
+--     collectordata[tag] = nil
+-- end
+--
+-- function remapper.convert(tag,toks)
+--     local data         = remapperdata[tag]
+--     local leftbracket  = utfbyte('[')
+--     local rightbracket = utfbyte(']')
+--     local skipping     = 0
+--     -- todo: math
+--     if data then
+--         local t, n = { }, 0
+--         for s=1,#toks do
+--             local tok = toks[s]
+--             local one, two = tok[1], tok[2]
+--             if one == 11 or one == 12 then
+--                 if two == leftbracket then
+--                     skipping = skipping + 1
+--                     n = n + 1 ; t[n] = tok
+--                 elseif two == rightbracket then
+--                     skipping = skipping - 1
+--                     n = n + 1 ; t[n] = tok
+--                 elseif skipping == 0 then
+--                     local new = data[two]
+--                     if new then
+--                         if #new > 1 then
+--                             for n=1,#new do
+--                                 n = n + 1 ; t[n] = new[n]
+--                             end
+--                         else
+--                             n = n + 1 ; t[n] = new[1]
+--                         end
+--                     else
+--                         n = n + 1 ; t[n] = tok
+--                     end
+--                 else
+--                     n = n + 1 ; t[n] = tok
+--                 end
+--             else
+--                 n = n + 1 ; t[n] = tok
+--             end
+--         end
+--         return t
+--     else
+--         return toks
+--     end
+-- end
diff --git a/tex/context/base/toks-map.mkiv b/tex/context/base/toks-map.mkiv
new file mode 100644
index 000000000..f1b63a68b
--- /dev/null
+++ b/tex/context/base/toks-map.mkiv
@@ -0,0 +1,63 @@
+%D \module
+%D   [       file=toks-map, % experimental moved from toks-ini
+%D        version=2007.03.03,
+%D          title=\CONTEXT\ Token Support,
+%D       subtitle=Initialization,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+% \writestatus{loading}{ConTeXt Token Support / Remapping}
+%
+% \registerctxluafile{toks-map}{1.001}
+%
+% \unprotect
+%
+% %D Inspired by a prototype by Taco for Thomas cum suis.
+% %D
+% %D \starttyping
+% %D \defineremapper[babelgreek]
+% %D
+% %D \remapcharacter[babelgreek][`a]{\alpha}
+% %D \remapcharacter[babelgreek][`b]{\beta}
+% %D \remapcharacter[babelgreek][`c]{\gamma}
+% %D \remapcharacter[babelgreek][`d]{OEPS}
+% %D
+% %D \starttext
+% %D
+% %D [\startbabelgreek
+% %D a b c some stuff here \blank[big] oeps b d
+% %D \stopbabelgreek]
+% %D
+% %D [\babelgreek{some stuff here}]
+% %D
+% %D \stoptext
+% %D \stoptyping
+%
+% \unexpanded\def\defineremapper[#1]%
+%   {\setuevalue{\e!start#1}{\toks_start_remapper{#1}}%
+%    \setuevalue{\e!stop #1}{\toks_stop_remapper {#1}}%
+%    \letvalue{#1}\relax
+%    \normalexpanded{\expandafter\def\csname#1\endcsname##1{\csname\e!start#1\endcsname##1\csname\e!stop#1\endcsname}}}
+%
+% \unexpanded\def\toks_start_remapper#1%
+%   {\ctxlua{tokens.collectors.install("#1", "\e!stop#1")}}
+%
+% \unexpanded\def\toks_stop_remapper#1%
+%   {\ctxlua{tokens.collectors.handle("#1",function(str) return tokens.collectors.remapper.convert("#1",str) end, true)}}
+%
+% \unexpanded\def\remaptokens#1%
+%   {\ctxlua{tokens.collectors.handle("#1",function(str) return tokens.collectors.remapper.convert("#1",str) end)}}
+%
+% \unexpanded\def\remapcharacter
+%   {\dodoubleempty\toks_remap_character}
+%
+% \def\toks_remap_character[#1][#2]#3%
+%   {\ctxlua{tokens.collectors.install("store", "ctxlua")}#3%
+%    \ctxlua{tokens.collectors.remapper.store("store","#1",\number#2)}}
+%
+% \protect \endinput
diff --git a/tex/context/base/toks-tra.lua b/tex/context/base/toks-tra.lua
new file mode 100644
index 000000000..bf2b91d38
--- /dev/null
+++ b/tex/context/base/toks-tra.lua
@@ -0,0 +1,298 @@
+if not modules then modules = { } end modules ['toks-ini'] = {
+    version   = 1.001,
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+
+local utfbyte, utfchar, utfvalues = utf.byte, utf.char, utf.values
+local format, gsub = string.format, string.gsub
+local tostring = tostring
+
+local tokens   = tokens
+local newtoken = newtoken
+local tex      = tex
+local context  = context
+local commands = commands
+
+tokens.collectors     = tokens.collectors or { }
+local collectors      = tokens.collectors
+
+collectors.data       = collectors.data or { }
+local collectordata   = collectors.data
+
+collectors.registered = collectors.registered or { }
+local registered      = collectors.registered
+
+local report          = logs.reporter("tokens","collectors")
+
+if newtoken then
+
+    -- todo:
+    --
+    -- register : macros that will be expanded (only for demo-ing)
+    -- flush    : print back to tex
+    -- test     : fancy stuff
+
+    local get_next = newtoken.get_next
+    local create   = newtoken.create
+
+    function collectors.install(tag,end_cs)
+        local data, d = { }, 0
+        collectordata[tag] = data
+        end_cs = gsub(end_cs,"^\\","")
+        while true do
+            local t = get_next()
+            if t.csname == end_cs then
+                context[end_cs]()
+                return
+            else
+                d = d + 1
+                data[d] = t
+            end
+        end
+    end
+
+    local simple = { letter = "letter", other_char = "other" }
+
+    function collectors.show(data)
+        -- We no longer have methods as we only used (in demos) method a
+        -- so there is no need to burden the core with this. We have a
+        -- different table anyway.
+        if type(data) == "string" then
+            data = collectordata[data]
+        end
+        if not data then
+            return
+        end
+        local ctx_NC       = context.NC
+        local ctx_NR       = context.NR
+        local ctx_bold     = context.bold
+        local ctx_verbatim = context.verbatim
+        context.starttabulate { "|Tl|Tc|Tl|" }
+        ctx_NC() ctx_bold("cmd")
+        ctx_NC() ctx_bold("meaning")
+        ctx_NC() ctx_bold("properties")
+        ctx_NC() ctx_NR()
+        context.HL()
+        for i=1,#data do
+            local token   = data[i]
+            local cmdname = token.cmdname
+            local simple  = simple[cmdname]
+            ctx_NC()
+            ctx_verbatim(simple or cmdname)
+            ctx_NC()
+            ctx_verbatim(simple and utfchar(token.mode) or token.csname)
+            ctx_NC()
+            if token.active     then context("active ") end
+            if token.expandable then context("expandable ") end
+            if token.protected  then context("protected ") end
+            ctx_NC()
+            ctx_NR()
+        end
+        context.stoptabulate()
+    end
+
+    local function printlist(data)
+        if data and #data > 0 then
+            report("not supported (yet): printing back to tex")
+        end
+    end
+
+    tokens.printlist = printlist -- will change to another namespace
+
+    function collectors.flush(tag)
+        printlist(collectordata[tag])
+    end
+
+    function collectors.test(tag,handle)
+        report("not supported (yet): testing")
+    end
+
+    function collectors.register(name)
+        report("not supported (yet): registering")
+    end
+
+else
+
+    -- 1 = command, 2 = modifier (char), 3 = controlsequence id
+
+    local create       = token.create
+    local csname_id    = token.csname_id
+    local command_id   = token.command_id
+    local command_name = token.command_name
+    local get_next     = token.get_next
+    local expand       = token.expand
+    local csname_name  = token.csname_name
+
+    local function printlist(data)
+        if data and #data > 0 then
+            callbacks.push('token_filter', function ()
+               callbacks.pop('token_filter') -- tricky but the nil assignment helps
+               return data
+            end)
+        end
+    end
+
+    tokens.printlist = printlist -- will change to another namespace
+
+    function collectors.flush(tag)
+        printlist(collectordata[tag])
+    end
+
+    function collectors.register(name)
+        registered[csname_id(name)] = name
+    end
+
+    local call   = command_id("call")
+    local letter = command_id("letter")
+    local other  = command_id("other_char")
+
+    function collectors.install(tag,end_cs)
+        local data, d = { }, 0
+        collectordata[tag] = data
+        end_cs = gsub(end_cs,"^\\","")
+        local endcs = csname_id(end_cs)
+        while true do
+            local t = get_next()
+            local a, b = t[1], t[3]
+            if b == endcs then
+                context[end_cs]()
+                return
+            elseif a == call and registered[b] then
+                expand()
+            else
+                d = d + 1
+                data[d] = t
+            end
+        end
+    end
+
+    function collectors.show(data)
+        -- We no longer have methods as we only used (in demos) method a
+        -- so there is no need to burden the core with this.
+        if type(data) == "string" then
+            data = collectordata[data]
+        end
+        if not data then
+            return
+        end
+        local ctx_NC       = context.NC
+        local ctx_NR       = context.NR
+        local ctx_bold     = context.bold
+        local ctx_verbatim = context.verbatim
+        context.starttabulate { "|T|Tr|cT|Tr|T|" }
+        ctx_NC() ctx_bold("cmd")
+        ctx_NC() ctx_bold("chr")
+        ctx_NC()
+        ctx_NC() ctx_bold("id")
+        ctx_NC() ctx_bold("name")
+        ctx_NC() ctx_NR()
+        context.HL()
+        for i=1,#data do
+            local token = data[i]
+            local cmd   = token[1]
+            local chr   = token[2]
+            local id    = token[3]
+            local name  = command_name(token)
+            ctx_NC()
+            ctx_verbatim(name)
+            ctx_NC()
+            if tonumber(chr) >= 0 then
+                ctx_verbatim(chr)
+            end
+            ctx_NC()
+            if cmd == letter or cmd == other then
+                ctx_verbatim(utfchar(chr))
+            end
+            ctx_NC()
+            if id > 0 then
+                ctx_verbatim(id)
+            end
+            ctx_NC()
+            if id > 0 then
+                ctx_verbatim(csname_name(token) or "")
+            end
+            ctx_NC() ctx_NR()
+        end
+        context.stoptabulate()
+    end
+
+    function collectors.test(tag,handle)
+        local t, w, tn, wn = { }, { }, 0, 0
+        handle = handle or collectors.defaultwords
+        local tagdata = collectordata[tag]
+        for k=1,#tagdata do
+            local v = tagdata[k]
+            if v[1] == letter then
+                wn = wn + 1
+                w[wn] = v[2]
+            else
+                if wn > 0 then
+                    handle(t,w)
+                    wn = 0
+                end
+                tn = tn + 1
+                t[tn] = v
+            end
+        end
+        if wn > 0 then
+            handle(t,w)
+        end
+        collectordata[tag] = t
+    end
+
+end
+
+-- Interfacing:
+
+commands.collecttokens = collectors.install
+commands.showtokens    = collectors.show
+commands.flushtokens   = collectors.flush
+commands.testtokens    = collectors.test
+commands.registertoken = collectors.register
+
+-- Redundant:
+
+-- function collectors.test(tag)
+--     printlist(collectordata[tag])
+-- end
+
+-- For old times sake:
+
+collectors.dowithwords = collectors.test
+
+-- This is only used in old articles ... will move to a module:
+
+local create  = newtoken and newtoken.create or token.create
+
+tokens.vbox   = create("vbox")
+tokens.hbox   = create("hbox")
+tokens.vtop   = create("vtop")
+tokens.bgroup = create(utfbyte("{"),1)
+tokens.egroup = create(utfbyte("}"),2)
+
+tokens.letter = function(chr) return create(utfbyte(chr),11) end
+tokens.other  = function(chr) return create(utfbyte(chr),12) end
+
+tokens.letters = function(str)
+    local t, n = { }, 0
+    for chr in utfvalues(str) do
+        n = n + 1
+        t[n] = create(chr, 11)
+    end
+    return t
+end
+
+function collectors.defaultwords(t,str)
+    if t then
+        local n = #t
+        n = n + 1 ; t[n] = tokens.bgroup
+        n = n + 1 ; t[n] = create("red")
+        for i=1,#str do
+            n = n + 1 ; t[n] = tokens.other('*')
+        end
+        n = n + 1 ; t[n] = tokens.egroup
+    end
+end
diff --git a/tex/context/base/toks-tra.mkiv b/tex/context/base/toks-tra.mkiv
new file mode 100644
index 000000000..a3e27eaf8
--- /dev/null
+++ b/tex/context/base/toks-tra.mkiv
@@ -0,0 +1,31 @@
+%D \module
+%D   [       file=toks-tra, % was toks-ini
+%D        version=2007.03.03,
+%D          title=\CONTEXT\ Token Support,
+%D       subtitle=Initialization,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+\writestatus{loading}{ConTeXt Token Support / Tracing}
+
+\registerctxluafile{toks-tra}{1.001}
+
+\unprotect
+
+%D Handy for manuals \unknown\ but not really used in practice, so it might
+%D become a runtime loaded module instead.
+
+\unexpanded\def\starttokens  [#1]{\ctxcommand{collecttokens("#1","stoptokens")}}
+           \let\stoptokens        \relax
+           \def\flushtokens  [#1]{\ctxcommand{flushtokens("#1")}}
+           \def\showtokens   [#1]{\ctxcommand{showtokens("#1")}}
+           \def\testtokens   [#1]{\ctxcommand{testtokens("#1")}}
+           \def\registertoken  #1{\ctxcommand{registertoken("#1")}}
+
+
+\protect \endinput
diff --git a/tex/context/base/trac-tex.lua b/tex/context/base/trac-tex.lua
index 7e3406073..5fe4754cb 100644
--- a/tex/context/base/trac-tex.lua
+++ b/tex/context/base/trac-tex.lua
@@ -8,7 +8,7 @@ if not modules then modules = { } end modules ['trac-tex'] = {
 
 -- moved from trac-deb.lua
 
-local format = string.format
+local next = next
 
 local texhashtokens = tex.hashtokens
 
@@ -20,23 +20,70 @@ function trackers.savehash()
     saved = texhashtokens()
 end
 
-function trackers.dumphashtofile(filename,delta)
-    local list, hash, command_name = { }, texhashtokens(), token.command_name
-    for name, token in next, hash do
-        if not delta or not saved[name] then
-            -- token: cmd, chr, csid -- combination cmd,chr determines name
-            local category = command_name(token)
-            local dk = list[category]
-            if not dk then
-                -- a bit funny names but this sorts better (easier to study)
-                dk = { names = { }, found = 0, code = token[1] }
-                list[category] = dk
+if newtoken then
+
+    function trackers.dumphashtofile(filename,delta)
+        local list   = { }
+        local hash   = tex.hashtokens()
+        local create = newtoken.create
+        for name, token in next, hash do
+            if not delta or not saved[name] then
+                if token[2] ~= 0 then -- still old interface
+                    local token = create(name)
+                 -- inspect(token)
+                    local category = token.cmdname
+                    local dk = list[category]
+                    if not dk then
+                        dk = {
+                            names = { },
+                            found = 0,
+                         -- code  = token[1],
+                        }
+                        list[category] = dk
+                    end
+                    if token.protected then
+                        if token.expandable then
+                            dk.names[name] = "ep"
+                        else
+                            dk.names[name] = "-p"
+                        end
+                    else
+                        if token.expandable then
+                            dk.names[name] = "ep"
+                        else
+                            dk.names[name] = "--"
+                        end
+                    end
+                    dk.found = dk.found + 1
+                end
             end
-            dk.names[name] = { token[2], token[3] }
-            dk.found = dk.found + 1
         end
+        table.save(filename or tex.jobname .. "-hash.log",list)
     end
-    io.savedata(filename or tex.jobname .. "-hash.log",table.serialize(list,true))
+
+else
+
+    function trackers.dumphashtofile(filename,delta)
+        local list    = { }
+        local hash    = texhashtokens()
+        local getname = token.command_name
+        for name, token in next, hash do
+            if not delta or not saved[name] then
+                -- token: cmd, chr, csid -- combination cmd,chr determines name
+                local category = getname(token)
+                local dk = list[category]
+                if not dk then
+                    -- a bit funny names but this sorts better (easier to study)
+                    dk = { names = { }, found = 0, code = token[1] }
+                    list[category] = dk
+                end
+                dk.names[name] = { token[2], token[3] }
+                dk.found = dk.found + 1
+            end
+        end
+        table.save(filename or tex.jobname .. "-hash.log",list)
+    end
+
 end
 
 local delta = nil
diff --git a/tex/context/base/typo-chr.lua b/tex/context/base/typo-chr.lua
new file mode 100644
index 000000000..87cffa7d4
--- /dev/null
+++ b/tex/context/base/typo-chr.lua
@@ -0,0 +1,104 @@
+if not modules then modules = { } end modules ['typo-chr'] = {
+    version   = 1.001,
+    comment   = "companion to typo-bld.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- local nodecodes      = nodes.nodecodes
+-- local whatsitcodes   = nodes.whatsitcodes
+-- local glyph_code     = nodecodes.glyph
+-- local whatsit_code   = nodecodes.whatsit
+-- local user_code      = whatsitcodes.userdefined
+--
+-- local stringusernode = nodes.pool.userstring
+--
+-- local nuts           = nodes.nuts
+-- local pool           = nuts.pool
+--
+-- local tonut          = nuts.tonut
+-- local tonode         = nuts.tonode
+-- local getid          = nuts.getid
+-- local getprev        = nuts.getprev
+-- local getsubtype     = nuts.getsubtype
+-- local getchar        = nuts.getchar
+-- local getfield       = nuts.getfield
+--
+-- local remove_node    = nuts.remove
+-- local traverse_by_id = nuts.traverse_id
+--
+-- local signal         = pool.userids.signal
+--
+-- local is_punctuation = characters.is_punctuation
+--
+-- local actions = {
+--     removepunctuation = function(head,n)
+--         local prev = getprev(n)
+--         if prev then
+--             if getid(prev) == glyph_code then
+--                 if is_punctuation[getchar(prev)] then
+--                     head = remove_node(head,prev,true)
+--                 end
+--             end
+--         end
+--         return head
+--     end
+-- }
+--
+-- -- we can also use properties .. todo (saves pass)
+--
+-- typesetters.signals = { }
+--
+-- function typesetters.signals.handler(head)
+--     local h = tonut(head)
+--     local done = false
+--     for n in traverse_by_id(whatsit_code,h) do
+--         if getsubtype(n) == user_code and getfield(n,"user_id") == signal and getfield(n,"type") == 115 then
+--             local action = actions[getfield(n,"value")]
+--             if action then
+--                 h = action(h,n)
+--             end
+--             h = remove_node(h,n,true)
+--             done = true
+--         end
+--     end
+--     if done then
+--         return tonode(h), true
+--     else
+--         return head
+--     end
+-- end
+--
+-- local enabled = false
+--
+-- function commands.signal(what)
+--     if not enabled then
+--         nodes.tasks.prependaction("processors","normalizers", "typesetters.signals.handler")
+--         enabled = true
+--     end
+--     context(stringusernode(signal,what))
+-- end
+
+local nodecodes   = nodes.nodecodes
+local glyph_code  = nodecodes.glyph
+
+local texnest     = tex.nest
+local free_node   = node.free
+
+local punctuation = characters.is_punctuation
+
+function commands.removepunctuation()
+    local list = texnest[texnest.ptr]
+    if list then
+        local tail = list.tail
+        if tail and tail.id == glyph_code and punctuation[tail.char] then
+            local prev = tail.prev
+            list.tail = prev
+            if prev then
+                prev.next = nil
+            end
+            free_node(tail)
+        end
+    end
+end
diff --git a/tex/context/base/typo-chr.mkiv b/tex/context/base/typo-chr.mkiv
new file mode 100644
index 000000000..138bf348a
--- /dev/null
+++ b/tex/context/base/typo-chr.mkiv
@@ -0,0 +1,27 @@
+
+%D \module
+%D   [       file=typo-cap,
+%D        version=2009.03.27, % code moved from core-spa.mkiv
+%D          title=\CONTEXT\ Typesetting Macros,
+%D       subtitle=Capping,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+\writestatus{loading}{ConTeXt Typesetting Macros / Characters}
+
+\unprotect
+
+%D Maybe we need a more clever system: either command or style mode etc. so
+%D that we can avoid the grouped mess in a simple style switch.
+
+\registerctxluafile{typo-chr}{1.001}
+
+%unexpanded\def\removepunctuation{\ctxcommand{signal("removepunctuation")}}
+\unexpanded\def\removepunctuation{\ctxcommand{removepunctuation()}}
+
+\protect
diff --git a/tex/context/base/typo-del.mkiv b/tex/context/base/typo-del.mkiv
index 6ce768ab2..2b4e6e6aa 100644
--- a/tex/context/base/typo-del.mkiv
+++ b/tex/context/base/typo-del.mkiv
@@ -70,23 +70,23 @@
   {\ifcase\boundarycharactermode
    \or
      %\nobreak
-     \hskip\hspaceamount\currentlanguage{#2}%
-     \languageparameter#1%
+     \hskip\hspaceamount\currentusedlanguage{#2}%
+     \usedlanguageparameter#1%
      %\nobreak
-      \hskip\hspaceamount\currentlanguage{#2}%
+     \hskip\hspaceamount\currentusedlanguage{#2}%
    \or
-     \languageparameter#1%
+     \usedlanguageparameter#1%
    \fi
    \boundarycharactermode\plusone}
 
 \unexpanded\def\leftboundarycharacter#1#2%
   {\ifcase\boundarycharactermode
    \or
-     \languageparameter#1%
+     \usedlanguageparameter#1%
      \nobreak
-     \hskip\hspaceamount\currentlanguage{#2}%
+     \hskip\hspaceamount\currentusedlanguage{#2}%
    \or
-     \languageparameter#1%
+     \usedlanguageparameter#1%
    \fi
    \boundarycharactermode\plusone}
 
@@ -94,10 +94,10 @@
   {\ifcase\boundarycharactermode
    \or
      \prewordbreak %\nobreak
-     \hskip\hspaceamount\currentlanguage{#2}%
-     \languageparameter#1%
+     \hskip\hspaceamount\currentusedlanguage{#2}%
+     \usedlanguageparameter#1%
    \or
-     \languageparameter#1%
+     \usedlanguageparameter#1%
    \fi
    \boundarycharactermode\plusone}
 
@@ -142,7 +142,7 @@
   {\beforesubsentence
    \ifdim\lastkern=\d_typo_subsentence_signal
      \unskip
-     \kern\hspaceamount\currentlanguage{intersentence}%
+     \kern\hspaceamount\currentusedlanguage{intersentence}%
    \fi
    \global\advance\c_typo_subsentence_nesting\plusone
    \ifnum\c_typo_subsentence_nesting=\plusone
@@ -166,7 +166,7 @@
 \unexpanded\def\endofsubsentencespacing
   {\ifdim\lastkern=\d_typo_subsentence_signal
      \unskip
-     \hskip\hspaceamount\currentlanguage{intersentence}%
+     \hskip\hspaceamount\currentusedlanguage{intersentence}%
      % no good, actually language dependent:
 %     \ignorespaces
    \else
@@ -193,8 +193,8 @@
 %definehspace [quote]  [\zeropoint]
 %definehspace [speech] [\zeropoint]
 
-\definehspace [quote]  [\hspaceamount\currentlanguage{quotation}]
-\definehspace [speech] [\hspaceamount\currentlanguage{quotation}]
+\definehspace [quote]  [\hspaceamount\currentusedlanguage{quotation}]
+\definehspace [speech] [\hspaceamount\currentusedlanguage{quotation}]
 
 \definesymbol
   [\c!leftquotation]
@@ -256,6 +256,7 @@
 \def\typo_delimited_push#1%
   {\globalpushmacro\currentdelimitedtext
    \def\currentdelimitedtext{#1}%
+   \setlanguageparameter\delimitedtextparameter
    \let\currentparentdelimitedtext\currentdelimitedtext
    \global\advance\c_typo_delimited_nesting\plusone
    \edef\delimitedtextlevel{\number\c_typo_delimited_nesting}%
@@ -543,7 +544,7 @@
    \ifdim\wd\scratchbox>\zeropoint
      \ifdim\lastkern=\d_typo_delimited_signal
        \unkern
-       \hskip\hspaceamount\currentlanguage{interquotation}%
+       \hskip\hspaceamount\currentusedlanguage{interquotation}%
      \fi
      \ifhmode % else funny pagebeaks
        \penalty\plustenthousand
@@ -563,10 +564,10 @@
    \ifdim\wd\scratchbox>\zeropoint
      \ifdim\lastkern=\d_typo_delimited_signal
        \unkern
-       \hskip\hspaceamount\currentlanguage{interquotation}%
+       \hskip\hspaceamount\currentusedlanguage{interquotation}%
      \else\ifdim\lastskip=\d_typo_delimited_signal
        \unskip
-       \hskip\hspaceamount\currentlanguage{interquotation}%
+       \hskip\hspaceamount\currentusedlanguage{interquotation}%
      \fi\fi
      \strut % new, needed below
      \ifhmode % else funny pagebeaks
@@ -588,11 +589,11 @@
      \ifdim\lastkern=\d_typo_delimited_signal
        \unkern
        \penalty\plustenthousand
-       \hskip\hspaceamount\currentlanguage{interquotation}%
+       \hskip\hspaceamount\currentusedlanguage{interquotation}%
      \else\ifdim\lastskip=\d_typo_delimited_signal
        \unskip
        \penalty\plustenthousand
-       \hskip\hspaceamount\currentlanguage{interquotation}%
+       \hskip\hspaceamount\currentusedlanguage{interquotation}%
      \fi\fi
      \ifhmode % else funny pagebeaks
        \penalty\plustenthousand
@@ -674,11 +675,11 @@
 
 \def\typo_delimited_fontdriven_b
   {\dostarttaggedchained\t!delimited\currentdelimitedtext\??delimitedtext
-   \languageparameter{\c!left\currentparentdelimitedtext}% was: \currentdelimitedtext
+   \usedlanguageparameter{\c!left\currentparentdelimitedtext}% was: \currentdelimitedtext
    \usedelimitedtextstyleandcolor\c!style\c!color}
 
 \def\typo_delimited_fontdriven_e
-  {\languageparameter{\c!right\currentparentdelimitedtext}% was: \currentdelimitedtext
+  {\usedlanguageparameter{\c!right\currentparentdelimitedtext}% was: \currentdelimitedtext
    \dostoptagged
    \typo_delimited_pop}
 
diff --git a/tex/context/base/typo-mar.lua b/tex/context/base/typo-mar.lua
index b0906020e..bba8501d0 100644
--- a/tex/context/base/typo-mar.lua
+++ b/tex/context/base/typo-mar.lua
@@ -603,10 +603,10 @@ local function inject(parent,head,candidate)
 --         offset = offset + height
     end
     if stack == v_yes then
-        offset = offset + candidate.dy
+        offset = offset + candidate.dy -- always
         shift = shift + offset
     elseif stack == v_continue then
-        offset = offset + candidate.dy
+        offset = offset + candidate.dy -- always
         if firstonstack then
             offset = offset + getovershoot(location)
         end
diff --git a/tex/context/base/util-dim.lua b/tex/context/base/util-dim.lua
index bfffb1010..2bdb870e7 100644
--- a/tex/context/base/util-dim.lua
+++ b/tex/context/base/util-dim.lua
@@ -92,9 +92,9 @@ format (string) is implemented using this table.</p>
 --ldx]]--
 
 local f_none = formatters["%s%s"]
-local f_true = formatters["%0.5f%s"]
+local f_true = formatters["%0.5F%s"]
 
-local function numbertodimen(n,unit,fmt)
+local function numbertodimen(n,unit,fmt) -- will be redefined later !
     if type(n) == 'string' then
         return n
     else
diff --git a/tex/context/base/util-prs.lua b/tex/context/base/util-prs.lua
index 302b98441..a3ae01be0 100644
--- a/tex/context/base/util-prs.lua
+++ b/tex/context/base/util-prs.lua
@@ -333,7 +333,7 @@ end
 
 -- for mtx-context etc: aaaa bbbb cccc=dddd eeee=ffff
 
-local str      = C((1-whitespace-equal)^1)
+local str      = Cs(lpegpatterns.unquoted) + C((1-whitespace-equal)^1)
 local setting  = Cf( Carg(1) * (whitespace^0 * Cg(str * whitespace^0 * (equal * whitespace^0 * str + Cc(""))))^1,rawset)
 local splitter = setting^1
 
@@ -524,7 +524,7 @@ function parsers.rfc4180splitter(specification)
     local field       = escaped + non_escaped + Cc("")
     local record      = Ct(field * (separator * field)^1)
     local headerline  = record * Cp()
-    local wholeblob   = Ct((newline^-1 * record)^0)
+    local wholeblob   = Ct((newline^(specification.strict and -1 or 1) * record)^0)
     return function(data,getheader)
         if getheader then
             local header, position = lpegmatch(headerline,data)
diff --git a/tex/context/base/x-asciimath.lua b/tex/context/base/x-asciimath.lua
index ff9c5c3d6..20cbd14e4 100644
--- a/tex/context/base/x-asciimath.lua
+++ b/tex/context/base/x-asciimath.lua
@@ -21,6 +21,7 @@ ugly and unsatisfying code mess down here. Don't take this as an example.</p>
 
 local trace_mapping    = false  if trackers then trackers.register("modules.asciimath.mapping", function(v) trace_mapping = v end) end
 local trace_detail     = false  if trackers then trackers.register("modules.asciimath.detail",  function(v) trace_detail  = v end) end
+local trace_digits     = false  if trackers then trackers.register("modules.asciimath.digits",  function(v) trace_digits  = v end) end
 
 local report_asciimath = logs.reporter("mathematics","asciimath")
 
@@ -40,7 +41,7 @@ local rep, gmatch, gsub, find = string.rep, string.gmatch, string.gsub, string.f
 local utfchar = utf.char
 
 local lpegmatch, patterns = lpeg.match, lpeg.patterns
-local S, P, R, C, V, Cc, Ct, Cs = lpeg.S, lpeg.P, lpeg.R, lpeg.C, lpeg.V, lpeg.Cc, lpeg.Ct, lpeg.Cs
+local S, P, R, C, V, Cc, Ct, Cs, Carg = lpeg.S, lpeg.P, lpeg.R, lpeg.C, lpeg.V, lpeg.Cc, lpeg.Ct, lpeg.Cs, lpeg.Carg
 
 local sortedhash   = table.sortedhash
 local sortedkeys   = table.sortedkeys
@@ -753,8 +754,83 @@ local isright = {
 local issimplified = {
 }
 
+--
+
+-- special mess
+
+local d_one    = lpeg.R("09")
+local d_two    = d_one * d_one
+local d_three  = d_two * d_one
+local d_spaced = (Carg(1) * d_three)^1
+local d_split  = P(-1) + P(",")
+
+local digitized = Cs((
+        d_three * d_spaced * d_split +
+        d_two   * d_spaced * d_split +
+        d_one   * d_spaced * d_split +
+        P(1)
+    )^1)
+
+-- print(lpeg.match(digitized,"1"))
+-- print(lpeg.match(digitized,"12"))
+-- print(lpeg.match(digitized,"123"))
+-- print(lpeg.match(digitized,"1234"))
+-- print(lpeg.match(digitized,"12345"))
+-- print(lpeg.match(digitized,"123456"))
+-- print(lpeg.match(digitized,"1234567"))
+-- print(lpeg.match(digitized,"12345678"))
+-- print(lpeg.match(digitized,"123456789"))
+
+-- print(lpeg.match(digitized,"1,1"))
+-- print(lpeg.match(digitized,"12,12"))
+-- print(lpeg.match(digitized,"123,123"))
+-- print(lpeg.match(digitized,"1234,1234"))
+-- print(lpeg.match(digitized,"12345,12345"))
+-- print(lpeg.match(digitized,"123456,123456"))
+-- print(lpeg.match(digitized,"1234567,1234567"))
+-- print(lpeg.match(digitized,"12345678,12345678"))
+-- print(lpeg.match(digitized,"123456789,123456789"))
+
+function asciimath.setup(settings)
+    local separator = settings.separator
+    if separator == interfaces.variables.yes then
+        digitseparator = utfchar(0x2008)
+    elseif separator and separator ~= "" then
+        digitseparator = separator
+    end
+end
+
+local collected_digits   = { }
+local collected_filename = "asciimath-digits.lua"
+
+function numbermess(s)
+    if digitseparator then
+        local d = lpegmatch(digitized,s,1,digitseparator)
+        if d then
+            if trace_digits and s ~= d then
+                collected_digits[s] = d
+            end
+            return d
+        end
+    end
+    return s
+end
+
+statistics.register("asciimath",function()
+    if trace_digits then
+        local n = table.count(collected_digits)
+        if n > 0 then
+            table.save(collected_filename,collected_digits)
+            return string.format("%s digit conversions saved in %s",n,collected_filename)
+        else
+            os.remove(collected_filename)
+        end
+    end
+end)
+
 local p_number_base = patterns.cpnumber or patterns.cnumber or patterns.number
 local p_number      = C(p_number_base)
+----- p_number      = p_number_base
 local p_spaces      = patterns.whitespace
 
 local p_utf_base    = patterns.utf8character
@@ -774,7 +850,8 @@ local real    = digits * (S(".,") * digits)^-1
 local float   = real * (P("E") * integer)^-1
 
 -- local number  = C(float + integer)
-local p_number  = C(float)
+-- local p_number  = C(float)
+local p_number  = float / numbermess
 
 local k_reserved = sortedkeys(reserved)
 local k_commands = { }
@@ -1682,7 +1759,8 @@ if not context then
 --     report_asciimath(cleanedup([[a "α" b]]))
 --     report_asciimath(cleanedup([[//4]]))
 
-convert("4/18*100text(%)~~22,2")
+-- convert("10000,00001")
+-- convert("4/18*100text(%)~~22,2")
 
 --     convert([[sum x]])
 --     convert([[sum^(1)_(2) x]])
@@ -1876,12 +1954,15 @@ function show.statistics()
             end
         end
     end
+    local NC = context.NC
+    local NR = context.NR
+    local EQ = context.EQ
     context.starttabulate { "|B||" }
-        context.NC() context("files")     context.EQ() context(noffiles)       context.NC() context.NR()
-        context.NC() context("formulas")  context.EQ() context(nofokay+nofbad) context.NC() context.NR()
-        context.NC() context("uniques")   context.EQ() context(#indexed)       context.NC() context.NR()
-        context.NC() context("cleanedup") context.EQ() context(nofcleanedup)   context.NC() context.NR()
-        context.NC() context("errors")    context.EQ() context(nofbad)         context.NC() context.NR()
+        NC() context("files")     EQ() context(noffiles)       NC() NR()
+        NC() context("formulas")  EQ() context(nofokay+nofbad) NC() NR()
+        NC() context("uniques")   EQ() context(#indexed)       NC() NR()
+        NC() context("cleanedup") EQ() context(nofcleanedup)   NC() NR()
+        NC() context("errors")    EQ() context(nofbad)         NC() NR()
     context.stoptabulate()
 end
 
diff --git a/tex/context/base/x-asciimath.mkiv b/tex/context/base/x-asciimath.mkiv
index c24377275..27d19693f 100644
--- a/tex/context/base/x-asciimath.mkiv
+++ b/tex/context/base/x-asciimath.mkiv
@@ -129,6 +129,8 @@
 
 \usemodule[mathml-basics]
 
+\startmodule[asciimath]
+
 \unprotect
 
 \writestatus{asciimath}{beware, this is an experimental (m4all only) module}
@@ -143,6 +145,16 @@
 
 %D The core commands:
 
+% if we need to set
+
+\installsetuponlycommandhandler {asciimath} {asciimath}
+
+\appendtoks
+    \ctxlua{moduledata.asciimath.setup {
+        separator = "\asciimathparameter\c!separator",
+    }}%
+\to \everysetupasciimath
+
 \unexpanded\def\asciimath#1%
   {\ctxcommand{asciimath(\!!bs\detokenize\expandafter{\normalexpanded{#1}}\!!es)}}
 
@@ -258,10 +270,14 @@
 
 \stopsetups
 
+\stopmodule
+
 \continueifinputfile{x-asciimath.mkiv}
 
 %D This will become an extra.
 
+\showframe
+
 \setups[asciimath:layout]
 
 % \enabletrackers[modules.asciimath.mapping]
@@ -273,10 +289,10 @@
 %   % \ShowAsciiMathSave[e:/temporary/asciimath/asciimath.lua]
 % \stoptext
 
-% \starttext
-% \unexpanded\def\MyAsciiMath#1{\startformula\asciimath{#1}\stopformula}
-% \startlines
-% \MyAsciiMath{x^2 / 10 // z_12^34 / 20}
+\starttext
+\unexpanded\def\MyAsciiMath#1{\startformula\asciimath{#1}\stopformula}
+\startlines
+\MyAsciiMath{x^2 / 10 // z_12^34 / 20}
 % \MyAsciiMath{{:{:x^2:} / 10:} // {:{:z_12^34 :} / 20:}}
 % \MyAsciiMath{x^2+y_1+z_12^34}
 % \MyAsciiMath{sin^-1(x)}
@@ -360,5 +376,5 @@
 % \MyAsciiMath{x^ (-1 1/2) =1/x^ (1 1/2)=1/ (x^1*x^ (1/2)) =1/ (xsqrt(x))}
 % \MyAsciiMath{x^2(10 -x)&gt;2 x^2}
 % \MyAsciiMath{x^4&gt;x}
-% \stoplines
-% \stoptext
+\stoplines
+\stoptext
diff --git a/tex/context/base/x-cals.lua b/tex/context/base/x-cals.lua
index 13f0e2bbe..3af6106d8 100644
--- a/tex/context/base/x-cals.lua
+++ b/tex/context/base/x-cals.lua
@@ -6,6 +6,7 @@ if not modules then modules = { } end modules ['x-cals'] = {
     license   = "see context related readme files"
 }
 
+local next = next
 local format, lower = string.format, string.lower
 local xmlsprint, xmlcprint, xmlcollected, xmlelements = xml.sprint, xml.cprint, xml.collected, xml.elements
 local n_todimen, s_todimen = number.todimen, string.todimen
diff --git a/tex/context/base/x-html.mkiv b/tex/context/base/x-html.mkiv
index bcb36a7d6..e1806eb9e 100644
--- a/tex/context/base/x-html.mkiv
+++ b/tex/context/base/x-html.mkiv
@@ -38,6 +38,8 @@
 \definehighlight[tt]    [\c!command=\v!no,\c!style=\v!mono]
 \definehighlight[strong][\c!command=\v!no,\c!style=\v!bold]
 \definehighlight[u]     [\c!command=\v!no,\c!style=\directsetbar{\v!underbar}]
+\definehighlight[code]  [\c!command=\v!no,\c!style=\v!mono]
+\definehighlight[pre]   [\c!command=\v!no]
 
 \protect
 
@@ -114,6 +116,14 @@
     \stopitem
 \stopxmlsetups
 
+\startxmlsetups xml:html:code
+    \directhighlight{code}{\xmlflushspacewise{#1}}
+\stopxmlsetups
+
+\startxmlsetups xml:html:pre
+    \directhighlight{pre}{\xmlflushspacewise{#1}}
+\stopxmlsetups
+
 \startxmlsetups xml:html:span
     \xmlflush{#1}
 \stopxmlsetups
@@ -134,7 +144,7 @@
 % todo: align
 
 % beware, the padding code is somewhat experimental, eventually the
-% table will be done in cdl code
+% table will be done in cld code
 %
 % we can also use \xmlmap for border etc
 
diff --git a/tex/context/base/x-set-11.mkiv b/tex/context/base/x-set-11.mkiv
index 12854dc92..c0575e625 100644
--- a/tex/context/base/x-set-11.mkiv
+++ b/tex/context/base/x-set-11.mkiv
@@ -369,7 +369,8 @@
     } {
         \let\currentSETUPprefix\empty
     }
-    \edef\currentSETUPname{\xmlatt{#1}{name}}
+  % \edef\currentSETUPname{\xmlatt{#1}{name}}
+    \edef\currentSETUPname{\xmlattribute{#1}{/sequence/string[1]}{value}}%
     \doifelse {\xmlatt{#1}{generated}} {yes} {
         \def\currentSETUPgenerated{*}
     } {
@@ -457,7 +458,7 @@
 \def\showsetupindeed#1%
   {\startelement[setup][name=#1]%
      \startelement[noexport][comment={setup definition #1}]
-       \xmlfilterlist{\loadedsetups}{/interface/command['#1' == (@type=='environment' and 'start' or '') .. @name]/command(xml:setups:typeset)}%
+       \xmlfilterlist{\loadedsetups}{/interface/command['#1' == (@type=='environment' and '\e!start' or '') .. @name]/command(xml:setups:typeset)}%
      \stopelement
    \stopelement}
 
@@ -469,7 +470,7 @@
 %D Typesetting:
 
 \setupxml
-  [\c!method=mkiv,       % mixed mode
+  [%\c!method=mkiv,       % mixed mode
    \c!default=\v!hidden, % ignore elements that are not defined
    \c!compress=\v!yes,   % strip comment
    \c!entities=\v!yes]   % replace entities
@@ -499,37 +500,41 @@
             \xmlfilter{#1}{/sequence/first()}
             \ignorespaces
         \egroup
-        \xmldoif{#1}{/arguments} {
-            \bgroup
-                \enablemode[setups-pass-one]
-                \doglobal\newcounter\currentSETUPargument
-                \ignorespaces
-                \xmlfilter{#1}{/arguments/text()}
-            \egroup
-        }
-        \doif {\xmlatt{#1}{type}} {environment} {
-            \bgroup
-                \enablemode[setups-pass-one]%
-                \hskip.5em\unknown\hskip.5em
-                \doif {\xmlatt{#1}{generated}} {yes} {
-                    \ttsl
-                }
-                \tex{\e!stop}
-                \xmlfilter{#1}{/sequence/first()}
-                \ignorespaces
-            \egroup
-        }
-        \endgraf
-        \xmldoif{#1}{/arguments} {
-            \bgroup
-                \enablemode[setups-pass-two]
-                \doglobal\newcounter\currentSETUPargument
-               %\blank[\v!line] % packed mode (we could do \startunpacked ...)
-                \godown[.75\lineheight]
-                \switchtobodyfont[\v!small]
-                \ignorespaces\xmlfilter{#1}{/arguments/text()}\endgraf
-            \egroup
-        }
+        \ifshortsetup
+            % nothing
+        \else
+            \xmldoif{#1}{/arguments} {
+                \bgroup
+                    \enablemode[setups-pass-one]
+                    \doglobal\newcounter\currentSETUPargument
+                    \ignorespaces
+                    \xmlfilter{#1}{/arguments/text()}
+                \egroup
+            }
+            \doif {\xmlatt{#1}{type}} {environment} {
+                \bgroup
+                    \enablemode[setups-pass-one]%
+                    \hskip.5em\unknown\hskip.5em
+                    \doif {\xmlatt{#1}{generated}} {yes} {
+                        \ttsl
+                    }
+                    \tex{\e!stop}
+                    \xmlfilter{#1}{/sequence/first()}
+                    \ignorespaces
+                \egroup
+            }
+            \endgraf
+            \xmldoif{#1}{/arguments} {
+                \bgroup
+                    \enablemode[setups-pass-two]
+                    \doglobal\newcounter\currentSETUPargument
+                   %\blank[\v!line] % packed mode (we could do \startunpacked ...)
+                    \godown[.75\lineheight]
+                    \switchtobodyfont[\v!small]
+                    \ignorespaces\xmlfilter{#1}{/arguments/text()}\endgraf
+                \egroup
+            }
+        \fi
     \getvalue{\e!stop setuptext}
 \stopxmlsetups
 
diff --git a/tex/context/interface/keys-it.xml b/tex/context/interface/keys-it.xml
index 4382cc5e6..477fa9caf 100644
--- a/tex/context/interface/keys-it.xml
+++ b/tex/context/interface/keys-it.xml
@@ -844,7 +844,7 @@
 		<cd:constant name='middletext' value='testocentro'/>
 		<cd:constant name='midsentence' value='midsentence'/>
 		<cd:constant name='min' value='min'/>
-		<cd:constant name='mindepth' value='mindeoth'/>
+		<cd:constant name='mindepth' value='mindepth'/>
 		<cd:constant name='minheight' value='altezzamin'/>
 		<cd:constant name='minwidth' value='ampiezzamin'/>
 		<cd:constant name='moffset' value='moffset'/>
diff --git a/tex/context/interface/keys-nl.xml b/tex/context/interface/keys-nl.xml
index 5e8bab3ce..3807ae464 100644
--- a/tex/context/interface/keys-nl.xml
+++ b/tex/context/interface/keys-nl.xml
@@ -291,15 +291,15 @@
 		<cd:variable name='mathematics' value='wiskunde'/>
 		<cd:variable name='mathmatrix' value='wiskundematrix'/>
 		<cd:variable name='max' value='max'/>
-		<cd:variable name='maxdepth' value='maxdepth'/>
-		<cd:variable name='maxheight' value='maxheight'/>
-		<cd:variable name='maxwidth' value='maxwidth'/>
+		<cd:variable name='maxdepth' value='maxdiepte'/>
+		<cd:variable name='maxheight' value='maxhoogte'/>
+		<cd:variable name='maxwidth' value='maxbreedte'/>
 		<cd:variable name='may' value='mei'/>
 		<cd:variable name='mediaeval' value='mediaeval'/>
 		<cd:variable name='medium' value='middel'/>
 		<cd:variable name='middle' value='midden'/>
 		<cd:variable name='min' value='min'/>
-		<cd:variable name='mindepth' value='mindepth'/>
+		<cd:variable name='mindepth' value='mindiepte'/>
 		<cd:variable name='minheight' value='minhoogte'/>
 		<cd:variable name='minwidth' value='minbreedte'/>
 		<cd:variable name='mirrored' value='gespiegeld'/>
diff --git a/tex/generic/context/luatex/luatex-basics-gen.lua b/tex/generic/context/luatex/luatex-basics-gen.lua
index e7cdc7b39..c4d653604 100644
--- a/tex/generic/context/luatex/luatex-basics-gen.lua
+++ b/tex/generic/context/luatex/luatex-basics-gen.lua
@@ -15,8 +15,13 @@ local dummyfunction = function()
 end
 
 local dummyreporter = function(c)
-    return function(...)
-        (texio.reporter or texio.write_nl)(c .. " : " .. string.formatters(...))
+    return function(f,...)
+        local r = texio.reporter or texio.write_nl
+        if f then
+            r(c .. " : " .. string.formatters(f,...))
+        else
+            r("")
+        end
     end
 end
 
diff --git a/tex/generic/context/luatex/luatex-fonts-cbk.lua b/tex/generic/context/luatex/luatex-fonts-cbk.lua
index 414cafb25..ce19c8811 100644
--- a/tex/generic/context/luatex/luatex-fonts-cbk.lua
+++ b/tex/generic/context/luatex/luatex-fonts-cbk.lua
@@ -116,13 +116,14 @@ function nodes.handlers.nodepass(head)
         if basepass and #basefonts > 0 then
             for i=1,#basefonts do
                 local range = basefonts[i]
-                local start, stop = range[1], range[2]
+                local start = range[1]
+                local stop  = range[2]
                 if stop then
-                    ligaturing(start,stop)
-                    kerning(start,stop)
-                else
-                    ligaturing(start)
-                    kerning(start)
+                    start, stop = ligaturing(start,stop)
+                    start, stop = kerning(start,stop)
+                elseif start then
+                    start = ligaturing(start)
+                    start = kerning(start)
                 end
             end
         end
diff --git a/tex/generic/context/luatex/luatex-fonts-inj.lua b/tex/generic/context/luatex/luatex-fonts-inj.lua
index b1dce8cab..cb9ed891c 100644
--- a/tex/generic/context/luatex/luatex-fonts-inj.lua
+++ b/tex/generic/context/luatex/luatex-fonts-inj.lua
@@ -14,13 +14,12 @@ if not nodes.properties then return end
 
 local next, rawget = next, rawget
 local utfchar = utf.char
+local fastcopy = table.fastcopy
 
 local trace_injections = false  trackers.register("fonts.injections", function(v) trace_injections = v end)
 
 local report_injections = logs.reporter("fonts","injections")
 
-report_injections("using experimental injector")
-
 local attributes, nodes, node = attributes, nodes, node
 
 fonts                    = fonts
@@ -81,19 +80,42 @@ function injections.resetcounts()
     keepregisteredcounts  = false
 end
 
+-- We need to make sure that a possible metatable will not kick in
+-- unexpectedly.
+
 function injections.reset(n)
-    local p = rawget(properties,start)
-    if p and p.injections then
-        -- todo: decrement counters? tricky as we then need to change the nof* to not increment
-        -- when we change a property
-        p.injections = nil -- should we keep the liga index?
+    local p = rawget(properties,n)
+    if p and rawget(p,"injections") then
+        p.injections = nil
+    end
+end
+
+function injections.copy(target,source)
+    local sp = rawget(properties,source)
+    if sp then
+        local tp = rawget(properties,target)
+        local si = rawget(sp,"injections")
+        if si then
+            si = fastcopy(si)
+            if tp then
+                tp.injections = si
+            else
+                propertydata[target] = {
+                    injections = si,
+                }
+            end
+        else
+            if tp then
+                tp.injections = nil
+            end
+        end
     end
 end
 
 function injections.setligaindex(n,index)
     local p = rawget(properties,n)
     if p then
-        local i = p.injections
+        local i = rawget(p,"injections")
         if i then
             i.ligaindex = index
         else
@@ -113,9 +135,9 @@ end
 function injections.getligaindex(n,default)
     local p = rawget(properties,n)
     if p then
-        p = p.injections
-        if p then
-            return p.ligaindex or default
+        local i = rawget(p,"injections")
+        if i then
+            return i.ligaindex or default
         end
     end
     return default
@@ -134,7 +156,7 @@ function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmne
     --
     local p = rawget(properties,start)
     if p then
-        local i = p.injections
+        local i = rawget(p,"injections")
         if i then
             i.cursiveanchor = true
         else
@@ -151,7 +173,7 @@ function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmne
     end
     local p = rawget(properties,nxt)
     if p then
-        local i = p.injections
+        local i = rawget(p,"injections")
         if i then
             i.cursivex = dx
             i.cursivey = dy
@@ -185,14 +207,16 @@ function injections.setpair(current,factor,rlmode,r2lflag,spec,injection) -- r2l
             end
             local p = rawget(properties,current)
             if p then
-                local i = p.injections
+                local i = rawget(p,"injections")
                 if i then
-                    if leftkern ~= 0 or rightkern ~= 0 then
-                        i.leftkern  = i.leftkern  or 0 + leftkern
-                        i.rightkern = i.rightkern or 0 + rightkern
+                    if leftkern ~= 0 then
+                        i.leftkern  = (i.leftkern  or 0) + leftkern
+                    end
+                    if rightkern ~= 0 then
+                        i.rightkern = (i.rightkern or 0) + rightkern
                     end
                     if yoffset ~= 0 then
-                        i.yoffset = i.yoffset or 0 + yoffset
+                        i.yoffset = (i.yoffset or 0) + yoffset
                     end
                 elseif leftkern ~= 0 or rightkern ~= 0 then
                     p.injections = {
@@ -240,9 +264,9 @@ function injections.setkern(current,factor,rlmode,x,injection)
             injection = "injections"
         end
         if p then
-            local i = p[injection]
+            local i = rawget(p,injection)
             if i then
-                i.leftkern = dx + i.leftkern or 0
+                i.leftkern = dx + (i.leftkern or 0)
             else
                 p[injection] = {
                     leftkern = dx,
@@ -270,7 +294,7 @@ function injections.setmark(start,base,factor,rlmode,ba,ma,tfmbase) -- ba=basean
     end
     local p = rawget(properties,start)
     if p then
-        local i = p.injections
+        local i = rawget(p,"injections")
         if i then
             i.markx        = dx
             i.marky        = dy
@@ -313,18 +337,18 @@ local function show(n,what,nested,symbol)
     if n then
         local p = rawget(properties,n)
         if p then
-            local p = p[what]
-            if p then
-                local leftkern  = p.leftkern  or 0
-                local rightkern = p.rightkern or 0
-                local yoffset   = p.yoffset   or 0
-                local markx     = p.markx     or 0
-                local marky     = p.marky     or 0
-                local markdir   = p.markdir   or 0
-                local markbase  = p.markbase  or 0 -- will be markbasenode
-                local cursivex  = p.cursivex  or 0
-                local cursivey  = p.cursivey  or 0
-                local ligaindex = p.ligaindex or 0
+            local i = rawget(p,what)
+            if i then
+                local leftkern  = i.leftkern  or 0
+                local rightkern = i.rightkern or 0
+                local yoffset   = i.yoffset   or 0
+                local markx     = i.markx     or 0
+                local marky     = i.marky     or 0
+                local markdir   = i.markdir   or 0
+                local markbase  = i.markbase  or 0 -- will be markbasenode
+                local cursivex  = i.cursivex  or 0
+                local cursivey  = i.cursivey  or 0
+                local ligaindex = i.ligaindex or 0
                 local margin    = nested and 4 or 2
                 --
                 if rightkern ~= 0 or yoffset ~= 0 then
@@ -355,9 +379,9 @@ local function showsub(n,what,where)
     report_injections("end subrun")
 end
 
-local function trace(head)
-    report_injections("begin run: %s kerns, %s pairs, %s marks and %s cursives registered",
-        nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
+local function trace(head,where)
+    report_injections("begin run %s: %s kerns, %s pairs, %s marks and %s cursives registered",
+        where or "",nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
     local n = head
     while n do
         local id = getid(n)
@@ -414,10 +438,6 @@ local function collect_glyphs_1(head)
     local nf, tm = nil, nil
     for n in traverse_id(glyph_code,head) do -- only needed for relevant fonts
         if getsubtype(n) < 256 then
-            local pn = rawget(properties,n)
-            if pn then
-                pn = pn.injections
-            end
             local f = getfont(n)
             if f ~= nf then
                 nf = f
@@ -431,10 +451,14 @@ local function collect_glyphs_1(head)
                 glyphs[nofglyphs] = n
             end
             -- yoffsets can influence curs steps
-            if pn then
-                local yoffset = pn.yoffset
-                if yoffset and yoffset ~= 0 then
-                    setfield(n,"yoffset",yoffset)
+            local p = rawget(properties,n)
+            if p then
+                local i = rawget(p,"injections")
+                if i then
+                    local yoffset = i.yoffset
+                    if yoffset and yoffset ~= 0 then
+                        setfield(n,"yoffset",yoffset)
+                    end
                 end
             end
         end
@@ -470,21 +494,20 @@ local function inject_marks(marks,nofmarks)
         local n = marks[i]
         local pn = rawget(properties,n)
         if pn then
-            pn = pn.injections
-        end
-        if pn then
-         -- local markbase = pn.markbase
-         -- if markbase then
-         --     local p = markanchors[markbase]
+            pn = rawget(pn,"injections")
+            if pn then
                 local p = pn.markbasenode
                 if p then
                     local px = getfield(p,"xoffset")
                     local ox = 0
+                    local rightkern = nil
                     local pp = rawget(properties,p)
                     if pp then
-                        pp = pp.injections
+                        pp = rawget(pp,"injections")
+                        if pp then
+                            rightkern = pp.rightkern
+                        end
                     end
-                    local rightkern = pp and pp.rightkern
                     if rightkern then -- x and w ~= 0
                         if pn.markdir < 0 then
                             -- kern(w-x) glyph(p) kern(x) mark(n)
@@ -493,8 +516,13 @@ local function inject_marks(marks,nofmarks)
                         else
                             -- kern(x) glyph(p) kern(w-x) mark(n)
                          -- ox = px - getfield(p,"width") + pn.markx - pp.leftkern
-                            ox = px - pn.markx - pp.leftkern
-                         -- report_injections("l2r case 1: %p",ox)
+                            local leftkern = pp.leftkern
+                            if leftkern then
+                                ox = px - pn.markx
+                            else
+                                ox = px - pn.markx - leftkern
+                            end
+-- report_injections("l2r case 1: %p",ox)
                         end
                     else
                         -- we need to deal with fonts that have marks with width
@@ -528,10 +556,10 @@ local function inject_marks(marks,nofmarks)
                     end
                     setfield(n,"yoffset",oy)
                 else
-                 -- normally this can't happen (only when in trace mode which is a special case anyway)
+                    -- normally this can't happen (only when in trace mode which is a special case anyway)
                  -- report_injections("missing mark anchor %i",pn.markbase or 0)
                 end
-         -- end
+            end
         end
     end
 end
@@ -543,14 +571,14 @@ local function inject_cursives(glyphs,nofglyphs)
         local n = glyphs[i]
         local pn = rawget(properties,n)
         if pn then
-            pn = pn.injections
+            pn = rawget(pn,"injections")
         end
         if pn then
             local cursivex = pn.cursivex
             if cursivex then
                 if cursiveanchor then
                     if cursivex ~= 0 then
-                        pn.leftkern = pn.leftkern or 0 + cursivex
+                        pn.leftkern = (pn.leftkern or 0) + cursivex
                     end
                     if lastanchor then
                         if maxc == 0 then
@@ -625,16 +653,16 @@ local function inject_kerns(head,glyphs,nofglyphs)
         local n = glyphs[i]
         local pn = rawget(properties,n)
         if pn then
-            pn = pn.injections
-        end
-        if pn then
-            local leftkern = pn.leftkern
-            if leftkern ~= 0 then
-                insert_node_before(head,n,newkern(leftkern)) -- type 0/2
-            end
-            local rightkern = pn.rightkern
-            if rightkern and rightkern ~= 0 then
-                insert_node_after(head,n,newkern(rightkern)) -- type 0/2
+            local i = rawget(pn,"injections")
+            if i then
+                local leftkern = i.leftkern
+                if leftkern and leftkern ~= 0 then
+                    insert_node_before(head,n,newkern(leftkern)) -- type 0/2
+                end
+                local rightkern = i.rightkern
+                if rightkern and rightkern ~= 0 then
+                    insert_node_after(head,n,newkern(rightkern)) -- type 0/2
+                end
             end
         end
     end
@@ -643,7 +671,7 @@ end
 local function inject_everything(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"everything")
     end
     local glyphs, nofglyphs, marks, nofmarks
     if nofregisteredpairs > 0 then
@@ -655,7 +683,7 @@ local function inject_everything(head,where)
         if nofregisteredcursives > 0 then
             inject_cursives(glyphs,nofglyphs)
         end
-        if nofregisteredmarks > 0 then
+        if nofregisteredmarks > 0 then -- and nofmarks > 0
             inject_marks(marks,nofmarks)
         end
         inject_kerns(head,glyphs,nofglyphs)
@@ -674,7 +702,7 @@ end
 local function inject_kerns_only(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"kerns")
     end
     local n = head
     local p = nil
@@ -687,10 +715,10 @@ local function inject_kerns_only(head,where)
                     if p then
                         local d = getfield(p,"post")
                         if d then
-                            local pn = pn.postinjections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"postinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     local t = find_tail(d)
                                     insert_node_after(d,t,newkern(leftkern))
                                 end
@@ -698,28 +726,28 @@ local function inject_kerns_only(head,where)
                         end
                         local d = getfield(p,"replace")
                         if d then
-                            local pn = pn.replaceinjections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"replaceinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     local t = find_tail(d)
                                     insert_node_after(d,t,newkern(leftkern))
                                 end
                             end
                         else
-                            local pn = pn.injections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"injections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     setfield(p,"replace",newkern(leftkern))
                                 end
                             end
                         end
                     else
-                        local pn = pn.injections
-                        if pn then
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
+                        local i = rawget(pn,"injections")
+                        if i then
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
                                 head = insert_node_before(head,n,newkern(leftkern))
                             end
                         end
@@ -737,12 +765,12 @@ local function inject_kerns_only(head,where)
                     if getsubtype(n) < 256 then
                         local pn = rawget(properties,n)
                         if pn then
-                            pn = pn.preinjections
-                        end
-                        if pn then
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
+                            local i = rawget(pn,"preinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
                             end
                         end
                     else
@@ -760,12 +788,12 @@ local function inject_kerns_only(head,where)
                     if getsubtype(n) < 256 then
                         local pn = rawget(properties,n)
                         if pn then
-                            pn = pn.postinjections
-                        end
-                        if pn then
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
+                            local i = rawget(pn,"postinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
                             end
                         end
                     else
@@ -783,12 +811,12 @@ local function inject_kerns_only(head,where)
                     if getsubtype(n) < 256 then
                         local pn = rawget(properties,n) -- why can it be empty { }
                         if pn then
-                            pn = pn.replaceinjections
-                        end
-                        if pn then
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
+                            local i = rawget(pn,"replaceinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
                             end
                         end
                     else
@@ -817,7 +845,7 @@ end
 local function inject_pairs_only(head,where)
     head = tonut(head)
     if trace_injections then
-        trace(head)
+        trace(head,"pairs")
     end
     --
     local n = head
@@ -831,14 +859,14 @@ local function inject_pairs_only(head,where)
                     if p then
                         local d = getfield(p,"post")
                         if d then
-                            local pn = pn.postinjections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"postinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     local t = find_tail(d)
                                     insert_node_after(d,t,newkern(leftkern))
                                 end
-                             -- local rightkern = pn.rightkern
+                             -- local rightkern = i.rightkern
                              -- if rightkern and rightkern ~= 0 then
                              --     insert_node_after(head,n,newkern(rightkern))
                              --     n = getnext(n) -- to be checked
@@ -847,27 +875,27 @@ local function inject_pairs_only(head,where)
                         end
                         local d = getfield(p,"replace")
                         if d then
-                            local pn = pn.replaceinjections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"replaceinjections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     local t = find_tail(d)
                                     insert_node_after(d,t,newkern(leftkern))
                                 end
-                             -- local rightkern = pn.rightkern
+                             -- local rightkern = i.rightkern
                              -- if rightkern and rightkern ~= 0 then
                              --     insert_node_after(head,n,newkern(rightkern))
                              --     n = getnext(n) -- to be checked
                              -- end
                             end
                         else
-                            local pn = pn.injections
-                            if pn then
-                                local leftkern = pn.leftkern
-                                if leftkern ~= 0 then
+                            local i = rawget(pn,"injections")
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
                                     setfield(p,"replace",newkern(leftkern))
                                 end
-                             -- local rightkern = pn.rightkern
+                             -- local rightkern = i.rightkern
                              -- if rightkern and rightkern ~= 0 then
                              --     insert_node_after(head,n,newkern(rightkern))
                              --     n = getnext(n) -- to be checked
@@ -876,17 +904,17 @@ local function inject_pairs_only(head,where)
                         end
                     else
                         -- this is the most common case
-                        local pn = pn.injections
-                        if pn then
-                            local yoffset = pn.yoffset
+                        local i = rawget(pn,"injections")
+                        if i then
+                            local yoffset = i.yoffset
                             if yoffset and yoffset ~= 0 then
                                 setfield(n,"yoffset",yoffset)
                             end
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
                                 insert_node_before(head,n,newkern(leftkern))
                             end
-                            local rightkern = pn.rightkern
+                            local rightkern = i.rightkern
                             if rightkern and rightkern ~= 0 then
                                 insert_node_after(head,n,newkern(rightkern))
                                 n = getnext(n) -- to be checked
@@ -904,23 +932,23 @@ local function inject_pairs_only(head,where)
                 local h = d
                 for n in traverse_id(glyph_code,d) do
                     if getsubtype(n) < 256 then
-                        local pn = rawget(properties,n)
-                        if pn then
-                            pn = pn.preinjections
-                        end
-                        if pn then
-                            local yoffset = pn.yoffset
-                            if yoffset and yoffset ~= 0 then
-                                setfield(n,"yoffset",yoffset)
-                            end
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
-                            end
-                            local rightkern = pn.rightkern
-                            if rightkern and rightkern ~= 0 then
-                                insert_node_after(head,n,newkern(rightkern))
-                                n = getnext(n) -- to be checked
+                        local p = rawget(properties,n)
+                        if p then
+                            local i = rawget(p,"preinjections")
+                            if i then
+                                local yoffset = i.yoffset
+                                if yoffset and yoffset ~= 0 then
+                                    setfield(n,"yoffset",yoffset)
+                                end
+                                local leftkern = i.leftkern
+                                if leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
+                                local rightkern = i.rightkern
+                                if rightkern and rightkern ~= 0 then
+                                    insert_node_after(head,n,newkern(rightkern))
+                                    n = getnext(n) -- to be checked
+                                end
                             end
                         end
                     else
@@ -936,23 +964,23 @@ local function inject_pairs_only(head,where)
                 local h = d
                 for n in traverse_id(glyph_code,d) do
                     if getsubtype(n) < 256 then
-                        local pn = rawget(properties,n)
-                        if pn then
-                            pn = pn.postinjections
-                        end
-                        if pn then
-                            local yoffset = pn.yoffset
-                            if yoffset and yoffset ~= 0 then
-                                setfield(n,"yoffset",yoffset)
-                            end
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
-                            end
-                            local rightkern = pn.rightkern
-                            if rightkern and rightkern ~= 0 then
-                                insert_node_after(head,n,newkern(rightkern))
-                                n = getnext(n) -- to be checked
+                        local p = rawget(properties,n)
+                        if p then
+                            local i = rawget(p,"postinjections")
+                            if i then
+                                local yoffset = i.yoffset
+                                if yoffset and yoffset ~= 0 then
+                                    setfield(n,"yoffset",yoffset)
+                                end
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
+                                local rightkern = i.rightkern
+                                if rightkern and rightkern ~= 0 then
+                                    insert_node_after(head,n,newkern(rightkern))
+                                    n = getnext(n) -- to be checked
+                                end
                             end
                         end
                     else
@@ -968,23 +996,23 @@ local function inject_pairs_only(head,where)
                 local h = d
                 for n in traverse_id(glyph_code,d) do
                     if getsubtype(n) < 256 then
-                        local pn = rawget(properties,n)
-                        if pn then
-                            pn = pn.replaceinjections
-                        end
-                        if pn then
-                            local yoffset = pn.yoffset
-                            if yoffset and yoffset ~= 0 then
-                                setfield(n,"yoffset",yoffset)
-                            end
-                            local leftkern = pn.leftkern
-                            if leftkern ~= 0 then
-                                h = insert_node_before(h,n,newkern(leftkern))
-                            end
-                            local rightkern = pn.rightkern
-                            if rightkern and rightkern ~= 0 then
-                                insert_node_after(head,n,newkern(rightkern))
-                                n = getnext(n) -- to be checked
+                        local p = rawget(properties,n)
+                        if p then
+                            local i = rawget(pn,"replaceinjections")
+                            if i then
+                                local yoffset = i.yoffset
+                                if yoffset and yoffset ~= 0 then
+                                    setfield(n,"yoffset",yoffset)
+                                end
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    h = insert_node_before(h,n,newkern(leftkern))
+                                end
+                                local rightkern = i.rightkern
+                                if rightkern and rightkern ~= 0 then
+                                    insert_node_after(head,n,newkern(rightkern))
+                                    n = getnext(n) -- to be checked
+                                end
                             end
                         end
                     else
diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua
index c1951c8e7..6dba44785 100644
--- a/tex/generic/context/luatex/luatex-fonts-merged.lua
+++ b/tex/generic/context/luatex/luatex-fonts-merged.lua
@@ -1,6 +1,6 @@
 -- merged file : luatex-fonts-merged.lua
 -- parent file : luatex-fonts.lua
--- merge date  : 02/03/15 23:55:34
+-- merge date  : 03/09/15 19:27:36
 
 do -- begin closure to overcome local limits and interference
 
@@ -3374,8 +3374,13 @@ end
 local dummyfunction=function()
 end
 local dummyreporter=function(c)
-  return function(...)
-    (texio.reporter or texio.write_nl)(c.." : "..string.formatters(...))
+  return function(f,...)
+    local r=texio.reporter or texio.write_nl
+    if f then
+      r(c.." : "..string.formatters(f,...))
+    else
+      r("")
+    end
   end
 end
 statistics={
@@ -5794,13 +5799,13 @@ local function read_from_tfm(specification)
     properties.filename=specification.filename
     properties.format=fonts.formats.tfm 
     parameters.size=size
-    shared.rawdata={}
-    shared.features=features
-    shared.processes=next(features) and tfm.setfeatures(tfmdata,features) or nil
     tfmdata.properties=properties
     tfmdata.resources=resources
     tfmdata.parameters=parameters
     tfmdata.shared=shared
+    shared.rawdata={}
+    shared.features=features
+    shared.processes=next(features) and tfm.setfeatures(tfmdata,features) or nil
     parameters.slant=parameters.slant     or parameters[1] or 0
     parameters.space=parameters.space     or parameters[2] or 0
     parameters.space_stretch=parameters.space_stretch or parameters[3] or 0
@@ -9840,9 +9845,9 @@ if not modules then modules={} end modules ['font-inj']={
 if not nodes.properties then return end
 local next,rawget=next,rawget
 local utfchar=utf.char
+local fastcopy=table.fastcopy
 local trace_injections=false trackers.register("fonts.injections",function(v) trace_injections=v end)
 local report_injections=logs.reporter("fonts","injections")
-report_injections("using experimental injector")
 local attributes,nodes,node=attributes,nodes,node
 fonts=fonts
 local fontdata=fonts.hashes.identifiers
@@ -9889,15 +9894,36 @@ function injections.resetcounts()
   keepregisteredcounts=false
 end
 function injections.reset(n)
-  local p=rawget(properties,start)
-  if p and p.injections then
-    p.injections=nil 
+  local p=rawget(properties,n)
+  if p and rawget(p,"injections") then
+    p.injections=nil
+  end
+end
+function injections.copy(target,source)
+  local sp=rawget(properties,source)
+  if sp then
+    local tp=rawget(properties,target)
+    local si=rawget(sp,"injections")
+    if si then
+      si=fastcopy(si)
+      if tp then
+        tp.injections=si
+      else
+        propertydata[target]={
+          injections=si,
+        }
+      end
+    else
+      if tp then
+        tp.injections=nil
+      end
+    end
   end
 end
 function injections.setligaindex(n,index)
   local p=rawget(properties,n)
   if p then
-    local i=p.injections
+    local i=rawget(p,"injections")
     if i then
       i.ligaindex=index
     else
@@ -9916,9 +9942,9 @@ end
 function injections.getligaindex(n,default)
   local p=rawget(properties,n)
   if p then
-    p=p.injections
-    if p then
-      return p.ligaindex or default
+    local i=rawget(p,"injections")
+    if i then
+      return i.ligaindex or default
     end
   end
   return default
@@ -9935,7 +9961,7 @@ function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmne
   end
   local p=rawget(properties,start)
   if p then
-    local i=p.injections
+    local i=rawget(p,"injections")
     if i then
       i.cursiveanchor=true
     else
@@ -9952,7 +9978,7 @@ function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmne
   end
   local p=rawget(properties,nxt)
   if p then
-    local i=p.injections
+    local i=rawget(p,"injections")
     if i then
       i.cursivex=dx
       i.cursivey=dy
@@ -9985,14 +10011,16 @@ function injections.setpair(current,factor,rlmode,r2lflag,spec,injection)
       end
       local p=rawget(properties,current)
       if p then
-        local i=p.injections
+        local i=rawget(p,"injections")
         if i then
-          if leftkern~=0 or rightkern~=0 then
-            i.leftkern=i.leftkern or 0+leftkern
-            i.rightkern=i.rightkern or 0+rightkern
+          if leftkern~=0 then
+            i.leftkern=(i.leftkern or 0)+leftkern
+          end
+          if rightkern~=0 then
+            i.rightkern=(i.rightkern or 0)+rightkern
           end
           if yoffset~=0 then
-            i.yoffset=i.yoffset or 0+yoffset
+            i.yoffset=(i.yoffset or 0)+yoffset
           end
         elseif leftkern~=0 or rightkern~=0 then
           p.injections={
@@ -10034,9 +10062,9 @@ function injections.setkern(current,factor,rlmode,x,injection)
       injection="injections"
     end
     if p then
-      local i=p[injection]
+      local i=rawget(p,injection)
       if i then
-        i.leftkern=dx+i.leftkern or 0
+        i.leftkern=dx+(i.leftkern or 0)
       else
         p[injection]={
           leftkern=dx,
@@ -10062,7 +10090,7 @@ function injections.setmark(start,base,factor,rlmode,ba,ma,tfmbase)
   end
   local p=rawget(properties,start)
   if p then
-    local i=p.injections
+    local i=rawget(p,"injections")
     if i then
       i.markx=dx
       i.marky=dy
@@ -10102,18 +10130,18 @@ local function show(n,what,nested,symbol)
   if n then
     local p=rawget(properties,n)
     if p then
-      local p=p[what]
-      if p then
-        local leftkern=p.leftkern or 0
-        local rightkern=p.rightkern or 0
-        local yoffset=p.yoffset  or 0
-        local markx=p.markx   or 0
-        local marky=p.marky   or 0
-        local markdir=p.markdir  or 0
-        local markbase=p.markbase or 0 
-        local cursivex=p.cursivex or 0
-        local cursivey=p.cursivey or 0
-        local ligaindex=p.ligaindex or 0
+      local i=rawget(p,what)
+      if i then
+        local leftkern=i.leftkern or 0
+        local rightkern=i.rightkern or 0
+        local yoffset=i.yoffset  or 0
+        local markx=i.markx   or 0
+        local marky=i.marky   or 0
+        local markdir=i.markdir  or 0
+        local markbase=i.markbase or 0 
+        local cursivex=i.cursivex or 0
+        local cursivey=i.cursivey or 0
+        local ligaindex=i.ligaindex or 0
         local margin=nested and 4 or 2
         if rightkern~=0 or yoffset~=0 then
           report_injections("%w%s pair: lx %p, rx %p, dy %p",margin,symbol,leftkern,rightkern,yoffset)
@@ -10141,9 +10169,9 @@ local function showsub(n,what,where)
   end
   report_injections("end subrun")
 end
-local function trace(head)
-  report_injections("begin run: %s kerns, %s pairs, %s marks and %s cursives registered",
-    nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
+local function trace(head,where)
+  report_injections("begin run %s: %s kerns, %s pairs, %s marks and %s cursives registered",
+    where or "",nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
   local n=head
   while n do
     local id=getid(n)
@@ -10196,10 +10224,6 @@ local function collect_glyphs_1(head)
   local nf,tm=nil,nil
   for n in traverse_id(glyph_code,head) do 
     if getsubtype(n)<256 then
-      local pn=rawget(properties,n)
-      if pn then
-        pn=pn.injections
-      end
       local f=getfont(n)
       if f~=nf then
         nf=f
@@ -10212,10 +10236,14 @@ local function collect_glyphs_1(head)
         nofglyphs=nofglyphs+1
         glyphs[nofglyphs]=n
       end
-      if pn then
-        local yoffset=pn.yoffset
-        if yoffset and yoffset~=0 then
-          setfield(n,"yoffset",yoffset)
+      local p=rawget(properties,n)
+      if p then
+        local i=rawget(p,"injections")
+        if i then
+          local yoffset=i.yoffset
+          if yoffset and yoffset~=0 then
+            setfield(n,"yoffset",yoffset)
+          end
         end
       end
     end
@@ -10249,23 +10277,30 @@ local function inject_marks(marks,nofmarks)
     local n=marks[i]
     local pn=rawget(properties,n)
     if pn then
-      pn=pn.injections
-    end
-    if pn then
+      pn=rawget(pn,"injections")
+      if pn then
         local p=pn.markbasenode
         if p then
           local px=getfield(p,"xoffset")
           local ox=0
+          local rightkern=nil
           local pp=rawget(properties,p)
           if pp then
-            pp=pp.injections
+            pp=rawget(pp,"injections")
+            if pp then
+              rightkern=pp.rightkern
+            end
           end
-          local rightkern=pp and pp.rightkern
           if rightkern then 
             if pn.markdir<0 then
               ox=px-pn.markx-rightkern
             else
-              ox=px-pn.markx-pp.leftkern
+              local leftkern=pp.leftkern
+              if leftkern then
+                ox=px-pn.markx
+              else
+                ox=px-pn.markx-leftkern
+              end
             end
           else
               ox=px-pn.markx
@@ -10286,6 +10321,7 @@ local function inject_marks(marks,nofmarks)
           setfield(n,"yoffset",oy)
         else
         end
+      end
     end
   end
 end
@@ -10296,14 +10332,14 @@ local function inject_cursives(glyphs,nofglyphs)
     local n=glyphs[i]
     local pn=rawget(properties,n)
     if pn then
-      pn=pn.injections
+      pn=rawget(pn,"injections")
     end
     if pn then
       local cursivex=pn.cursivex
       if cursivex then
         if cursiveanchor then
           if cursivex~=0 then
-            pn.leftkern=pn.leftkern or 0+cursivex
+            pn.leftkern=(pn.leftkern or 0)+cursivex
           end
           if lastanchor then
             if maxc==0 then
@@ -10367,16 +10403,16 @@ local function inject_kerns(head,glyphs,nofglyphs)
     local n=glyphs[i]
     local pn=rawget(properties,n)
     if pn then
-      pn=pn.injections
-    end
-    if pn then
-      local leftkern=pn.leftkern
-      if leftkern~=0 then
-        insert_node_before(head,n,newkern(leftkern)) 
-      end
-      local rightkern=pn.rightkern
-      if rightkern and rightkern~=0 then
-        insert_node_after(head,n,newkern(rightkern)) 
+      local i=rawget(pn,"injections")
+      if i then
+        local leftkern=i.leftkern
+        if leftkern and leftkern~=0 then
+          insert_node_before(head,n,newkern(leftkern)) 
+        end
+        local rightkern=i.rightkern
+        if rightkern and rightkern~=0 then
+          insert_node_after(head,n,newkern(rightkern)) 
+        end
       end
     end
   end
@@ -10384,7 +10420,7 @@ end
 local function inject_everything(head,where)
   head=tonut(head)
   if trace_injections then
-    trace(head)
+    trace(head,"everything")
   end
   local glyphs,nofglyphs,marks,nofmarks
   if nofregisteredpairs>0 then
@@ -10396,7 +10432,7 @@ local function inject_everything(head,where)
     if nofregisteredcursives>0 then
       inject_cursives(glyphs,nofglyphs)
     end
-    if nofregisteredmarks>0 then
+    if nofregisteredmarks>0 then 
       inject_marks(marks,nofmarks)
     end
     inject_kerns(head,glyphs,nofglyphs)
@@ -10414,7 +10450,7 @@ end
 local function inject_kerns_only(head,where)
   head=tonut(head)
   if trace_injections then
-    trace(head)
+    trace(head,"kerns")
   end
   local n=head
   local p=nil
@@ -10427,10 +10463,10 @@ local function inject_kerns_only(head,where)
           if p then
             local d=getfield(p,"post")
             if d then
-              local pn=pn.postinjections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"postinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   local t=find_tail(d)
                   insert_node_after(d,t,newkern(leftkern))
                 end
@@ -10438,28 +10474,28 @@ local function inject_kerns_only(head,where)
             end
             local d=getfield(p,"replace")
             if d then
-              local pn=pn.replaceinjections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"replaceinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   local t=find_tail(d)
                   insert_node_after(d,t,newkern(leftkern))
                 end
               end
             else
-              local pn=pn.injections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"injections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   setfield(p,"replace",newkern(leftkern))
                 end
               end
             end
           else
-            local pn=pn.injections
-            if pn then
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
+            local i=rawget(pn,"injections")
+            if i then
+              local leftkern=i.leftkern
+              if leftkern and leftkern~=0 then
                 head=insert_node_before(head,n,newkern(leftkern))
               end
             end
@@ -10477,12 +10513,12 @@ local function inject_kerns_only(head,where)
           if getsubtype(n)<256 then
             local pn=rawget(properties,n)
             if pn then
-              pn=pn.preinjections
-            end
-            if pn then
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
+              local i=rawget(pn,"preinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
               end
             end
           else
@@ -10500,12 +10536,12 @@ local function inject_kerns_only(head,where)
           if getsubtype(n)<256 then
             local pn=rawget(properties,n)
             if pn then
-              pn=pn.postinjections
-            end
-            if pn then
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
+              local i=rawget(pn,"postinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
               end
             end
           else
@@ -10523,12 +10559,12 @@ local function inject_kerns_only(head,where)
           if getsubtype(n)<256 then
             local pn=rawget(properties,n) 
             if pn then
-              pn=pn.replaceinjections
-            end
-            if pn then
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
+              local i=rawget(pn,"replaceinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
               end
             end
           else
@@ -10555,7 +10591,7 @@ end
 local function inject_pairs_only(head,where)
   head=tonut(head)
   if trace_injections then
-    trace(head)
+    trace(head,"pairs")
   end
   local n=head
   local p=nil
@@ -10568,10 +10604,10 @@ local function inject_pairs_only(head,where)
           if p then
             local d=getfield(p,"post")
             if d then
-              local pn=pn.postinjections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"postinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   local t=find_tail(d)
                   insert_node_after(d,t,newkern(leftkern))
                 end
@@ -10579,35 +10615,35 @@ local function inject_pairs_only(head,where)
             end
             local d=getfield(p,"replace")
             if d then
-              local pn=pn.replaceinjections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"replaceinjections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   local t=find_tail(d)
                   insert_node_after(d,t,newkern(leftkern))
                 end
               end
             else
-              local pn=pn.injections
-              if pn then
-                local leftkern=pn.leftkern
-                if leftkern~=0 then
+              local i=rawget(pn,"injections")
+              if i then
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
                   setfield(p,"replace",newkern(leftkern))
                 end
               end
             end
           else
-            local pn=pn.injections
-            if pn then
-              local yoffset=pn.yoffset
+            local i=rawget(pn,"injections")
+            if i then
+              local yoffset=i.yoffset
               if yoffset and yoffset~=0 then
                 setfield(n,"yoffset",yoffset)
               end
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
+              local leftkern=i.leftkern
+              if leftkern and leftkern~=0 then
                 insert_node_before(head,n,newkern(leftkern))
               end
-              local rightkern=pn.rightkern
+              local rightkern=i.rightkern
               if rightkern and rightkern~=0 then
                 insert_node_after(head,n,newkern(rightkern))
                 n=getnext(n) 
@@ -10625,23 +10661,23 @@ local function inject_pairs_only(head,where)
         local h=d
         for n in traverse_id(glyph_code,d) do
           if getsubtype(n)<256 then
-            local pn=rawget(properties,n)
-            if pn then
-              pn=pn.preinjections
-            end
-            if pn then
-              local yoffset=pn.yoffset
-              if yoffset and yoffset~=0 then
-                setfield(n,"yoffset",yoffset)
-              end
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
-              end
-              local rightkern=pn.rightkern
-              if rightkern and rightkern~=0 then
-                insert_node_after(head,n,newkern(rightkern))
-                n=getnext(n) 
+            local p=rawget(properties,n)
+            if p then
+              local i=rawget(p,"preinjections")
+              if i then
+                local yoffset=i.yoffset
+                if yoffset and yoffset~=0 then
+                  setfield(n,"yoffset",yoffset)
+                end
+                local leftkern=i.leftkern
+                if leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
+                local rightkern=i.rightkern
+                if rightkern and rightkern~=0 then
+                  insert_node_after(head,n,newkern(rightkern))
+                  n=getnext(n) 
+                end
               end
             end
           else
@@ -10657,23 +10693,23 @@ local function inject_pairs_only(head,where)
         local h=d
         for n in traverse_id(glyph_code,d) do
           if getsubtype(n)<256 then
-            local pn=rawget(properties,n)
-            if pn then
-              pn=pn.postinjections
-            end
-            if pn then
-              local yoffset=pn.yoffset
-              if yoffset and yoffset~=0 then
-                setfield(n,"yoffset",yoffset)
-              end
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
-              end
-              local rightkern=pn.rightkern
-              if rightkern and rightkern~=0 then
-                insert_node_after(head,n,newkern(rightkern))
-                n=getnext(n) 
+            local p=rawget(properties,n)
+            if p then
+              local i=rawget(p,"postinjections")
+              if i then
+                local yoffset=i.yoffset
+                if yoffset and yoffset~=0 then
+                  setfield(n,"yoffset",yoffset)
+                end
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
+                local rightkern=i.rightkern
+                if rightkern and rightkern~=0 then
+                  insert_node_after(head,n,newkern(rightkern))
+                  n=getnext(n) 
+                end
               end
             end
           else
@@ -10689,23 +10725,23 @@ local function inject_pairs_only(head,where)
         local h=d
         for n in traverse_id(glyph_code,d) do
           if getsubtype(n)<256 then
-            local pn=rawget(properties,n)
-            if pn then
-              pn=pn.replaceinjections
-            end
-            if pn then
-              local yoffset=pn.yoffset
-              if yoffset and yoffset~=0 then
-                setfield(n,"yoffset",yoffset)
-              end
-              local leftkern=pn.leftkern
-              if leftkern~=0 then
-                h=insert_node_before(h,n,newkern(leftkern))
-              end
-              local rightkern=pn.rightkern
-              if rightkern and rightkern~=0 then
-                insert_node_after(head,n,newkern(rightkern))
-                n=getnext(n) 
+            local p=rawget(properties,n)
+            if p then
+              local i=rawget(pn,"replaceinjections")
+              if i then
+                local yoffset=i.yoffset
+                if yoffset and yoffset~=0 then
+                  setfield(n,"yoffset",yoffset)
+                end
+                local leftkern=i.leftkern
+                if leftkern and leftkern~=0 then
+                  h=insert_node_before(h,n,newkern(leftkern))
+                end
+                local rightkern=i.rightkern
+                if rightkern and rightkern~=0 then
+                  insert_node_after(head,n,newkern(rightkern))
+                  n=getnext(n) 
+                end
               end
             end
           else
@@ -11217,6 +11253,7 @@ local setcursive=injections.setcursive
 local setkern=injections.setkern
 local setpair=injections.setpair
 local resetinjection=injections.reset
+local copyinjection=injections.copy
 local setligaindex=injections.setligaindex
 local getligaindex=injections.getligaindex
 local cursonce=true
@@ -11299,10 +11336,13 @@ local function copy_glyph(g)
   if components then
     setfield(g,"components",nil)
     local n=copy_node(g)
+    copyinjection(n,g) 
     setfield(g,"components",components)
     return n
   else
-    return copy_node(g)
+    local n=copy_node(g)
+    copyinjection(n,g) 
+    return n
   end
 end
 local function markstoligature(kind,lookupname,head,start,stop,char)
@@ -15087,13 +15127,14 @@ function nodes.handlers.nodepass(head)
     if basepass and #basefonts>0 then
       for i=1,#basefonts do
         local range=basefonts[i]
-        local start,stop=range[1],range[2]
+        local start=range[1]
+        local stop=range[2]
         if stop then
-          ligaturing(start,stop)
-          kerning(start,stop)
-        else
-          ligaturing(start)
-          kerning(start)
+          start,stop=ligaturing(start,stop)
+          start,stop=kerning(start,stop)
+        elseif start then
+          start=ligaturing(start)
+          start=kerning(start)
         end
       end
     end
diff --git a/tex/generic/context/luatex/luatex-fonts-otn.lua b/tex/generic/context/luatex/luatex-fonts-otn.lua
index 32dc820d3..3f53078cc 100644
--- a/tex/generic/context/luatex/luatex-fonts-otn.lua
+++ b/tex/generic/context/luatex/luatex-fonts-otn.lua
@@ -6,6 +6,9 @@ if not modules then modules = { } end modules ['font-otn'] = {
     license   = "see context related readme files",
 }
 
+-- todo: looks like we have a leak somewhere (probably in ligatures)
+-- todo: copy attributes to disc
+
 -- this is a context version which can contain experimental code, but when we
 -- have serious patches we also need to change the other two font-otn files
 
@@ -243,6 +246,7 @@ local setcursive         = injections.setcursive
 local setkern            = injections.setkern
 local setpair            = injections.setpair
 local resetinjection     = injections.reset
+local copyinjection      = injections.copy
 local setligaindex       = injections.setligaindex
 local getligaindex       = injections.getligaindex
 
@@ -354,13 +358,19 @@ local function copy_glyph(g) -- next and prev are untouched !
     if components then
         setfield(g,"components",nil)
         local n = copy_node(g)
+        copyinjection(n,g) -- we need to preserve the lig indices
         setfield(g,"components",components)
         return n
     else
-        return copy_node(g)
+        local n = copy_node(g)
+        copyinjection(n,g) -- we need to preserve the lig indices
+        return n
     end
 end
 
+-- 
+
+
 -- start is a mark and we need to keep that one
 
 local function markstoligature(kind,lookupname,head,start,stop,char)