Index: clib/compose.c
==================================================================
--- clib/compose.c
+++ clib/compose.c
@@ -9,13 +9,13 @@
 
    TODO add macro to use homebrew strlen instead of
         dragging in <string.h> */
 
 #ifdef k_header // only emit the declarations
-#	define fn(x)
+#	define k_impl(x)
 #else
-#	define fn(x) x
+#	define k_impl(x) x
 #endif
 
 #include <string.h>
 
 typedef struct pstr { size_t len; union {
@@ -34,25 +34,25 @@
 #	endif
 	size_t len;
 } safestr;
 
 #ifndef k_static
-	void delstr(safestr s) fn ({
+	void delstr(safestr s) k_impl ({
 		if (s.heap) { free(s.mutptr); }
 	});
 #endif
 
-void clrstr(safestr* s) fn ({
+void clrstr(safestr* s) k_impl ({
 #	ifndef k_static
 		delstr(*s);
 		s->heap = false;
 #	endif
 	s->ptr = NULL;
 	s->len = 0;
 })
 
-size_t pstrsum(pstr* lst,size_t ct) fn({
+size_t pstrsum(pstr* lst,size_t ct) k_impl ({
 	size_t len = 0;
 	for (size_t i = 0; i < ct; ++i) {
 		if (lst[i].len == 0) {
 			if (lst[i].ptr == NULL) continue;
 			lst[i].len = strlen(lst[i].ptr);
@@ -60,21 +60,21 @@
 		len += lst[i].len;
 	}
 	return len;
 })
 
-char* pstrcoll(pstr* lst, size_t ct, char* ptr) fn({
+char* pstrcoll(pstr* lst, size_t ct, char* ptr) k_impl ({
 	for (size_t i = 0; i < ct; ++i) {
 		if (lst[i].len == 0) continue;
 		strncpy(ptr,lst[i].ptr,lst[i].len);
 		ptr += lst[i].len;
 	}
 	return ptr;
 })
 
 #ifndef k_static
-char* compose(pstr* lst,size_t ct, size_t* strsz) fn({
+char* compose(pstr* lst,size_t ct, size_t* strsz) k_impl ({
 	size_t len = pstrsum(lst,ct)
 	if (strsz != NULL) *strsz = len;
 	if (len == 0) return NULL;
 	
 	char* str = malloc(len + 1);
@@ -82,25 +82,25 @@
 	*ptr = 0;
 	return str;
 });
 #endif
 
-char* impose(pstr* lst,size_t ct, size_t* strsz, char* buf) fn({
+char* impose(pstr* lst,size_t ct, size_t* strsz, char* buf) k_impl({
 	size_t len = pstrsum(lst,ct);
 	if (strsz != NULL) *strsz = len;
 	if (len == 0) return NULL;
 	
 	char* ptr = pstrcoll(lst, ct, buf);
 	*ptr = 0;
 	return ptr;
 });
 
-char* imprint(pstr lst, size_t* strsz, char* buf) fn({
+char* imprint(pstr lst, size_t* strsz, char* buf) k_impl({
 	size_t len = pstrsum(&lst,1);
 	if (strsz != NULL) *strsz = len;
 	if (len == 0) return NULL;
 	
 	char* ptr = pstrcoll(&lst,1,buf);
 	*ptr = 0;
 	return ptr;
 });
-#undef fn
+#undef k_impl

Index: parvan.lua
==================================================================
--- parvan.lua
+++ parvan.lua
@@ -8,10 +8,55 @@
 --      SSD  Social Sciences Directorate
 --       ELS External Linguistics Subdirectorate
 --    +WSO   Worlds Security Overdirectorate
 --      EID  External Influence Directorate ]
 
+--# parvan
+--
+--## orthographies
+-- parvan supports encoding words using multiple
+-- orthographies. every database has a "primary"
+-- orthography, which must be Unicode- or ASCII-
+-- compatible, and which is used as the basis of the
+-- uniform object paths. other orthographies can be
+-- managed with the [$script] command, which can set
+-- how they are displayed to the user. every word
+-- can have zero or more representations mapped to a
+-- particular orthography.
+--
+--## file format
+-- parvan defines two separate file formats, both
+-- representations of a dictionary. one, the "working
+-- format", is binary; the other, the "exchange format"
+-- is comprised of UTF8 codepoint sequences and can be
+-- (to some degree) written and read by human beings,
+-- tho its primary purpose is as a line-based format
+-- that allows parvan dictionaries to be managed with
+-- conventional source control solutions like fossil
+-- or git
+--
+--## magic numbers
+-- all parvan files share the same 4-byte header. it
+-- is comprised of the sequence
+--   [$ 0x50 0x56 $VERS $SUBTYPE ]
+-- where [$$VERS] is a byte that is altered whenever a
+-- breaking change is made to the format. [$$SUBTYPE]
+-- indicates whether the file is binary- or text-based.
+-- the byte 0x20 indicates an exchange file, while
+-- 0x02 indicates a binary database.
+--
+--## extensions
+-- parvan recommends the use of the extension [$*.pv]
+-- for its binary databases, and [$*.pvx] for the
+-- exchange format.
+--
+--## styled text
+-- text in parvan documents should be written using
+-- cortav syntax. at some future time this will
+-- hopefully be used to generate styled output where
+-- possible
+
 local function implies(a,b) return a==b or not(a) end
 
 local function map(lst,fn)
 	local new = {}
 	for k,v in pairs(lst) do
@@ -52,10 +97,22 @@
 		for j=1,sc do dest[i+j] = src[j] end
 		i = i + sc
 		iter(...)
 	end
 	iter(...)
+end
+local function mergeD(dest, tbl, ...)
+	if tbl == nil then return dest end
+	for k,v in pairs(tbl) do dest[k] = v end
+	return mergeD(dest, ...)
+end
+local function merge(...)
+	local t = {}
+	return mergeD(t, ...)
+end
+local function copy(t,...)
+	return merge(t), copy(...)
 end
 local function fastDelete(table,idx)
 -- delete without preserving table order
 	local l = #table
 	table[idx] = table[l]
@@ -65,10 +122,24 @@
 local function tcat(...)
 	local new = {}
 	tcatD(new, ...)
 	return new
 end
+local function iota(n,m)
+	if not m then return iota(1,n) end
+	if n == m then return n end
+	return n, iota(n+1,m)
+end
+local function keys(m)
+	local i,ks = 1,{}
+	for k in next, m do
+		ks[i] = k
+		i = i + 1
+	end
+	return ks
+end
+
 local ansi = {
 	levels = {
 		plain = 0;
 		ansi = 1;
 		color = 2;
@@ -114,25 +185,31 @@
 	local f = {}
 	for k,v in pairs(ansi.seqs) do
 		local lvl, on, off = table.unpack(v)
 		if lvl <= cl then
 			f[k] = function(s)
-				return esc..on .. s .. esc..off
+				return (esc..on) .. s .. (esc..off)
 			end
 		else f[k] = id end
 	end
 	local function ftoi(r,g,b)
 		return math.ceil(r*0xff),
 		       math.ceil(g*0xff),
 		       math.ceil(b*0xff)
 	end
 	local reset = "\27[39m"
-	function f.color(str, n, br)
-		return string.format("\27[%s%cm",
-			(bg and 4 or 3) +
-			(br and 6 or 0), 0x30+n)
-			.. str .. reset
+	function f.color(str, n, bright)
+		if n<=15 then
+			return string.format("\27[%s%cm",
+				(bg and 4 or 3) +
+				(br and 6 or 0), 0x30+n)
+				.. str .. reset
+		else
+			return string.format("\27[%c8;5;%sm",
+				(bg and 0x34 or 0x33), n)
+				.. str .. reset
+		end
 	end
 	function f.resetLine()
 		return '\27[1K\13'
 	end
 	if cl == ansi.levels.color24b then
@@ -297,10 +374,43 @@
 			end
 			return vals
 		end;
 	}
 end
+
+fmt.any = function(struct)
+	local map, keylist = {},{}
+	for i,v in ipairs(struct) do
+		if type(v) ~= 'string' then
+			map[v[1]] = v[2]
+			v = v[1]
+		else
+			map[v] = true
+		end
+		table.insert(keylist, v)
+	end
+	local tdisc = fmt.enum(table.unpack(keylist))
+	return {
+		encode = function(a)
+			if type(a) == 'string' and map[a] == true then
+				return marshal(tdisc, a)
+			else
+				local tname, obj = table.unpack(a)
+				assert(map[tname] ~= true, '`any` enumeration '..tostring(tname)..' has no associated struct')
+				return marshal(tdisc, tname) ..
+					marshal(map[tname], obj)
+			end
+		end;
+		decode = function(s)
+			local tname = parse(tdisc, s)
+			if map[tname] ~= true then
+				local obj = parse(map[tname], s)
+				return {tname,obj}
+			else return tname end
+		end;
+	}
+end
 
 fmt.map = function(from,to,ity)
 	local ent = fmt.list({
 		{'key', from},
 		{'val', to}
@@ -317,10 +427,11 @@
 			local lst = ent.decode(s)
 			local m = {}
 			for _,p in pairs(lst) do m[p.key] = p.val end
 			return m
 		end;
+		null = function() return {} end;
 	}
 end
 
 fmt.enum = function(...)
 	local vals,rmap = {...},{}
@@ -340,10 +451,11 @@
 		end;
 	}
 end
 
 fmt.uid = fmt.u32
+fmt.blob = fmt.string
 
 fmt.relatable = function(ty)
 	return tcat(ty,{
 		{'rels',fmt.list(fmt.uid,fmt.u16)};
 	})
@@ -367,21 +479,59 @@
 
 fmt.phrase = fmt.relatable {
 	{'str',fmt.label};
 	{'means',fmt.list(fmt.meaning,fmt.u8)};
 }
+
+fmt.ortho = fmt.map(fmt.uid, fmt.blob, fmt.u8)
+-- UID <0> is always the UTF-8 representation of the primary ortho
+
+fmt.writing = {
+	{'enc',fmt.ortho}; -- if empty, print the morphs in sequence
+	{'info',fmt.label};
+	{'morphs',fmt.list(fmt.uid,fmt.u16)};
+}
 
 fmt.def = fmt.relatable {
+	{'writings', fmt.list(fmt.writing,fmt.u8)};
+	-- for japanese-like languages where words that are
+	-- pronounced/written the same under the indexing
+	-- orthography have alternate writings that are
+	-- definition-specific. e.g. words よう and さま
+	-- would both have a definition written as 様
+	-- ordinary languages will have only 1 writing
 	{'part', fmt.u8};
 	{'branch', fmt.list(fmt.label,fmt.u8)};
 	{'means', fmt.list(fmt.meaning,fmt.u8)};
 	{'forms', fmt.map(fmt.u16,fmt.label,fmt.u16)};
 	{'phrases', fmt.list(fmt.phrase,fmt.u16)};
 }
 
 fmt.word = fmt.relatable {
 	{'defs', fmt.list(fmt.def,fmt.u8)};
+	-- store secondary encodings of this word
+	{'enc', fmt.ortho};
+}
+
+fmt.orthography = {
+	{'uid', fmt.uid};
+	{'name', fmt.tag};
+	{'repr', fmt.any{
+		 'utf8'; -- display as utf-8 compatible text
+		 'opaque'; -- do not display at all; used only by other tools
+		 'bytes'; -- display as raw hexadecimal bytes
+		{'int',fmt.u8}; -- display as a series of integers (n=byte len)
+		{'glyphs',{ -- map to a palette of custom glyphs.
+			-- treated as 'opaque' in text-only environments
+			{'glyphs', fmt.list {
+				{'image',fmt.blob};
+				{'name',fmt.tag};
+			}};
+			{'encoding', fmt.u8}; -- number of bytes per codepoint
+			{'format',fmt.enum('svg','bmp','png')};
+		}};
+	}};
 }
 
 fmt.dictHeader = {
 	{'lang', fmt.tag};
 	{'meta', fmt.string};
@@ -392,10 +542,11 @@
 		{'desc', fmt.string};
 		{'parts', fmt.list(fmt.tag,fmt.u8)};
 		-- which parts of speech does this form apply to?
 		-- leave empty if not relevant
 	},fmt.u16)};
+	{'orthographies', fmt.list(fmt.orthography,fmt.u8)}
 }
 
 fmt.relSet = {
 	{'uid', fmt.uid};
 		-- IDs are persistent random values so they can be used
@@ -403,44 +554,67 @@
 		-- a parvan-unaware VCS
 	{'kind', fmt.enum('syn','ant','met')};
 	-- membership is stored in individual objects, using a field
 	-- attached by the 'relatable' template
 }
+
+fmt.pair = function(k,v) return {
+	{'key',k or fmt.tag};
+	{'val', v or fmt.blob};
+} end
+
+fmt.morph = {
+	{'name',fmt.tag};
+	{'enc', fmt.ortho};
+	{'meta', fmt.list(fmt.pair(nil,fmt.string),fmt.u16)};
+	{'rads', fmt.list(fmt.uid,fmt.u16)};
+}
 
 fmt.dict = {
 	{'header', fmt.dictHeader};
 	{'words', fmt.map(fmt.string,fmt.word)};
 	{'relsets', fmt.list(fmt.relSet)};
+	{'morphs', fmt.map(fmt.uid,fmt.morph)};
 }
 
-function marshal(ty, val)
+function marshal(ty, val, pvers)
+	pvers = pvers or 0
 	if ty.encode then
 		return ty.encode(val)
 	end
 	local ac = {}
 
 	for idx,fld in ipairs(ty) do
-		local name, fty = table.unpack(fld)
-		table.insert(ac, marshal(fty,
-			assert(val[name],
-				string.format('marshalling error: missing field %s', name)
-			)
-		))
+		local name, fty, vers = table.unpack(fld)
+		vers = vers or 0
+		if pvers >= vers then
+			table.insert(ac, marshal(fty,
+				assert(val[name],
+					string.format('marshalling error: missing field %s', name)
+				),
+			pvers))
+		end
 	end
 
 	return table.concat(ac)
 end
 
-function parse(ty, stream)
+function parse(ty, stream, pvers)
+	pvers = pvers or 0
 	if ty.decode then
 		return ty.decode(stream)
 	end
 
 	local obj = {}
 	for idx,fld in ipairs(ty) do
-		local name, fty = table.unpack(fld)
-		obj[name] = parse(fty, stream)
+		local name, fty, vers, dflt = table.unpack(fld)
+		vers = vers or 0
+		if pvers >= vers then
+			obj[name] = parse(fty, stream, pvers)
+		else
+			obj[name] = dflt
+		end
 	end
 	return obj
 end
 
 local function
@@ -507,12 +681,14 @@
 
 local function
 readDict(file)
 	local s = stream(file)
 	local magic = s:next 'c4'
-	if magic ~= 'PV0\2' then
-		id10t 'not a parvan file'
+	if magic == 'PV0 ' then
+		id10t 'text-based dictionaries must be translated to binary using the `import` command before they can be used'
+	elseif magic ~= 'PV0\2' then
+		id10t 'not a parvan0 file'
 	end
 	local d = parse(fmt.dict, s)
 	-- handle atoms
 	for lit,w in pairs(d.words) do
 		for j,def in ipairs(w.defs) do
@@ -526,11 +702,11 @@
 	rebuildRelationCache(d)
 	return d
 end
 
 
-local function strwords(str) -- here be dragons
+local function strwords(str,maxwords) -- here be dragons
 	local wds = {}
 	local w = {}
 	local state, d, quo, dquo = 0,0
 	local function flush(n,final)
 		if next(w) or state ~= 0 and state < 10 then
@@ -541,10 +717,13 @@
 		end
 		state = n
 		quo = nil
 		dquo = nil
 		d = 0
+		if #wds == maxwords then
+			state = 100
+		end
 	end
 	local function isws(c)
 		return c == 0x20 or c == 0x09 or c == 0x0a
 	end
 	for p,cp in utf8.codes(str) do
@@ -596,21 +775,60 @@
 				table.insert(w,0x0a)
 			else
 				table.insert(w,cp)
 			end
 			state = state - 10
+		elseif state == 100 then -- word limit reached
+			-- triggered from flush
+			table.insert(wds, string.sub(str, p))
+			return wds
 		end
 	end
 	flush(nil,true)
 	return wds
 end
+
+local function strsan(str)
+	local d,m = 0,0
+	local r = {}
+	local unclosed = {}
+	local i = 1
+	for bytepos,cp in utf8.codes(str) do
+		-- insert backslashes for characters that would
+		-- disrupt strwords() parsing
+		if cp == 0x0a then
+			table.insert(r, 0x5c)
+			table.insert(r, 0x6e) i=i+2
+		else
+			if cp == 0x5b then
+				d = d + 1
+				table.insert(unclosed,i)
+			elseif cp == 0x5d then
+				if d >= 1 then
+					d = d - 1
+					unclosed[rawlen(unclosed)] = nil
+				else
+					table.insert(r, 0x5c) i=i+1
+				end
+			end
+			table.insert(r, cp) i=i+1
+		end
+	end
+	for j=#unclosed,1,-1 do
+		table.insert(r,unclosed[j],0x5c)
+	end
+	return '[' .. utf8.char(table.unpack(r)) .. ']'
+end
 
 local predicates
 local function parsefilter(str)
 	local f = strwords(str)
 	if #f == 1 then return function(e) return predicates.lit.fn(e,f[1]) end end
-	if not predicates[f[1]] then
+	if not next(f) then
+		-- null predicate matches all
+		return function() return true end
+	elseif not predicates[f[1]] then
 		id10t('no such predicate %s',f[1])
 	else
 		local p = predicates[f[1]].fn
 		return function(e)
 			return p(e, table.unpack(f,2))
@@ -635,18 +853,32 @@
 		if pred == nil then return true end
 		pred = parsefilter(pred)
 		if pred(e) then return false end
 		return p_none(e,...)
 	end;
-	local function p_some(e,count,pred,...)
-		if count == 0 then return true end
-		if pred == nil then return false end
-		pred = parsefilter(pred)
-		if pred(e) then
-			count = count-1
+	local function p_some(e,cmp,count,...)
+		local cfn = {
+			eq = function(a,b) return a == b end;
+			ne = function(a,b) return a ~= b end;
+			lt = function(a,b) return a < b end;
+			gt = function(a,b) return a > b end;
+		}
+		if not cfn[cmp] then
+			id10t('[some %s]: invalid comparator', cmp)
 		end
-		return p_some(e,count,...)
+		count = tonumber(count)
+		local function rec(n,pred,...)
+			if pred == nil then
+				return cfn[cmp](n,count)
+			end
+			pred = parsefilter(pred)
+			if pred(e) then
+				n=n+1
+			end
+			return rec(n,...)
+		end
+		return rec(0,...)
 	end;
 
 	local function prepScan(...)
 		local map = {}
 		local tgt = select('#',...)
@@ -655,26 +887,97 @@
 	end
 	predicates = {
 		all = {
 			fn = p_all;
 			syntax = '<pred>…';
-			help = 'every sub-<pred> matches'
+			help = 'every sub-<pred> matches';
 		};
 		any = {
 			fn = p_any;
 			syntax = '<pred>…';
-			help = 'any sub-<pred> matches'
+			help = 'any sub-<pred> matches';
 		};
 		none = {
 			fn = p_none;
 			syntax = '<pred>…';
-			help = 'no sub-<pred> matches'
+			help = 'no sub-<pred> matches (also useful to force evaluation for side effects without creates matches)';
 		};
 		some = {
 			fn = p_some;
-			syntax = '<count> <pred>…';
-			help = '<count> or more sub-<pred>s match'
+			syntax = '(eq|ne|lt|gt) <count> <pred>…';
+			help = '<count> [or more/less] sub-<pred>s match';
+		};
+		seq = {
+			syntax = "<wrap> '[' <arg>… ']' <pred>…";
+			help = 'reuse the same stack of arguments';
+			fn = function(e,wrap,args,...)
+				local lst = {}
+				local function eval(pred,...)
+					if not pred then return end
+					table.insert(lst, pred .. ' ' .. args)
+					eval(...)
+				end
+				eval(...)
+				local filter = wrap .. ' ' ..table.concat(map(lst, strsan), ' ')
+				return parsefilter(filter)(e)
+			end;
+		};
+		mark = {
+			syntax = '<mark> [<pred>]';
+			help = 'apply <mark> to the words that match <pred>, or all the words that are tested if no <pred> is supplied. use to visually indicate the reason that a given term matched the query';
+			fn = function(e, val, pred)
+				if pred == nil or parsefilter(pred)(e) then
+					e.mark = e.mark or {}
+					for k,v in pairs(e.mark) do
+						if v==val then return true end
+					end
+					table.insert(e.mark, val)
+					return true
+				end
+			end;
+		};
+		clear = {
+			syntax = '<mark> [<pred>]';
+			help = 'like [mark] but clears marks instead of setting them';
+			fn = function(e, val, pred)
+				if pred == nil or parsefilter(pred)(e) then
+					e.mark = e.mark or {}
+					for k,v in pairs(e.mark) do
+						if v==val then
+							table.remove(e.mark,k)
+							return true
+						end
+					end
+					return true
+				end
+			end;
+		};
+		marked = {
+			syntax = '(by <mark> [pred]|in <pred>)';
+			help = 'tests for an existing <mark> on the result';
+			fn = function(e, mode, val, pred)
+				if     mode == 'in' then
+					pred = val val = nil
+					if pred == nil then
+						id10t '[marked in <pred>] requires a predicate'
+					end
+				elseif mode == 'by' then
+					if val == nil then
+						id10t '[marked by <mark>] requires a mark'
+					end
+				else id10t('invalid form [marked %s]', mode) end
+
+				if pred == nil or parsefilter(pred)(e) then
+					if e.mark == nil or not next(e.mark)
+						then return false end
+					if val then
+						for k,v in pairs(e.mark) do
+							if v==val then return true end
+						end
+					else return true end
+				end
+			end;
 		};
 		def = {
 			help = 'word has at least one definition that contains all <keyword>s';
 			syntax = '<keyword>…';
 			fn = function(e,...)
@@ -692,28 +995,126 @@
 				end
 				return false
 			end;
 		};
 		lit = {
-			help = 'word is, begins with, or ends with <word>';
-			syntax = '<word> [(pfx|sfx)]';
-			fn = function(e,val,op)
+			help = 'word is, begins with, matches, or ends with <search> in <script> or the primary orthography ("also" enables searching the primary as well as the listed scripts)';
+			syntax = '<search> [(pfx|sfx|match)] [any|(in|also) <script>…]';
+			fn = function(e,val,...)
+				local opts,oc = {...},1
+				local scripts, op = {0}
+				if opts[oc] == 'pfx' or opts[oc] == 'sfx' or opts[oc] == 'match' then
+					op = opts[oc]
+					oc = oc + 1
+				end
+				if opts[oc] then
+					if opts[oc] == 'any' then
+						scripts = nil
+					else
+						if opts[oc] == 'in' then
+							scripts = {}
+						elseif opts[oc] ~= 'also' then
+							id10t('[lit … %s]: invalid spec', opts[oc])
+						end
+						if #opts < oc+1 then
+							id10t('[lit … %s]: missing argument', opts[oc])
+						end
+						for i=oc+1,#opts do
+							table.insert(scripts, opts[oc])
+						end
+					end
+				end
 				if not op then
 					return e.lit == val
 				elseif op == 'pfx' then
 					return val == string.sub(e.lit,1,#val)
 				elseif op == 'sfx' then
 					return val == string.sub(e.lit,(#e.lit) - #val + 1)
+				elseif op == 'match' then
+					return string.find(e.lit, val) ~= nil
 				else
-					id10t('[lit %s %s] is not a valid filter, “%s” should be either “pfx” or “sfx”',val,op,op)
+					id10t('[lit %s %s] is not a valid filter, “%s” should be “pfx”, “sfx”, or “match”',val,op,op)
 				end
 			end;
 		};
+		morph = {
+			help = 'find words with specific morphs';
+			syntax = "(any|all|only) <script> [seq] ((lit|rec) <repr>|rad '[' <repr>… ']')…";
+		};
 		form = {
 			help = 'match against word\'s inflected forms';
-			syntax = '(<inflect> | <form> (set | is <inflect> | (pfx|sfx|match) <affix>))';
-			fn = function(e, k, op, v)
+			syntax = '(<inflect> | (of <form>|has) [any] ([un]set | is <inflect> | (pfx|sfx|sub) <affix>)…)';
+			fn = function(e, k, mode, ...)
+				if k == nil then -- eq [form has set]
+					for _,d in pairs(e.word.defs) do
+						if next(d.forms) then return true end
+					end
+				elseif mode == 'of' or mode == 'has' then
+					local match,mc = {...},1
+					if not next(match) then
+						id10t('[form %s]: missing spec',mode)
+					end
+
+					local any = match[1]=='any'
+					local eval = function()return true end;
+					if any then
+						nc = 2
+						eval = function()return false end;
+					end
+
+					local ok = false
+					local fns = {
+						set   = function(a) return a~=nil end;
+						unset = function(a) return a==nil end;
+						is  = function(a,b)return a and a==b   end;
+						pfx = function(a,b)return a and string.sub(a,1,#b) == b end;
+						sfx = function(a,b)return a and string.sub(a,0-#b) == b end;
+						sub = function(a,b)return a and string.find(a,b) ~= nil end;
+					}
+					repeat local n, op, arg = 1, table.unpack(match,mc)
+						print(op,arg)
+						if not op then id10t "missing argument for [form]" end
+						if not fns[op] then
+							id10t('[form … %s] is not a valid filter', op)
+						end
+						if op ~= "set" and op ~= 'unset' then
+							n = 2
+							if not arg then
+								id10t('[form … %s]: missing argument', op)
+							end
+						end
+						local oe = eval
+						eval = any and function(a,b)
+							return fns[op](a,b) or oe(a,b)
+						end or function(a,b)
+							return fns[op](a,b) and oe(a,b)
+						end
+						ok = true
+					mc = mc + n until mc > #match
+					if not ok then
+						id10t '[form]: incomplete spec'
+					end
+
+					for _,d in pairs(e.word.defs) do
+						if mode=='has' then
+							for cat,infd in pairs(d.forms) do
+								if eval(infd) then return true end
+							end
+						else
+							if eval(d.forms[k]) then return true end
+						end
+					end
+				elseif mode ~= nil then
+					id10t('[form %s]: invalid mode', mode)
+				else
+					for _,d in pairs(e.word.defs) do
+						for _,v in pairs(d.forms) do
+							if v == k then return true end
+						end
+					end
+				end
+				return false
 			end;
 		};
 		part = {
 			help = 'word has definitions for every <part> of speech';
 			syntax = '<part>…';
@@ -725,11 +1126,11 @@
 				end
 				return matches == tgt
 			end
 		};
 		root = {
-			help = 'match a word that derives from every <word>';
+			help = 'match an entry that derives from every <word>';
 			syntax = '<word>…';
 			fn = function(e,...)
 				local map, tgt = prepScan(...)
 				for i,d in ipairs(e.word.defs) do
 					local matches = 0
@@ -738,12 +1139,21 @@
 					end
 					if matches == tgt then return true end
 				end
 			end
 		};
+		phrase = {
+			syntax = '<pred>…';
+			help = 'match only words with phrases';
+		};
+		ex = {
+			syntax= '[by <source>] [(any|all) <term>…]';
+			help = 'entry has an example by <source> with any/all of <term>s';
+			fn = function() end;
+		};
 		note = {
-			help = 'word has a matching note';
+			help = 'entry has a matching note';
 			syntax = '([kind <kind> [<term>]] | term <term> | (min|max|count) <n>)';
 			fn = function(e, op, k, t)
 				if op == 'kind' or op == 'term' then
 					if op == 'term' and t then
 						id10t('too many arguments for [note term <term>]')
@@ -786,16 +1196,10 @@
 	else
 		return file
 	end
 end
 
-local function copy(tab)
-	local new = {}
-	for k,v in pairs(tab) do new[k] = v end
-	return new
-end
-
 local function pathParse(p)
 -- this is cursed, rewrite without regex pls TODO
 	if p == '.' then return {} end
 	local function comp(pfx)
 		return pfx .. '([0-9]+)'
@@ -826,11 +1230,11 @@
 		end
 	end
 	if not w then w=p:match('^(.-)%.?$') end
 	return {w = w, dn = tonumber(dn), mn = tonumber(mn), pn=tonumber(pn); nn = tonumber(nn), xn = tonumber(xn)}
 end
-local function pathString(p,styler)
+local function pathString(p,styler,display)
 	local function s(s, st, ...)
 		if styler then
 			return styler[st](tostring(s),...)
 		else return s end
 	end
@@ -844,11 +1248,11 @@
 	if p.dn then t[2] = string.format(".%s", s(p.dn,'br')) end
 	if p.pn then t[#t+1] = comp('p',p.pn,4,true) end
 	if p.mn then t[#t+1] = comp('m',p.mn,5,true) end
 	if p.xn then t[#t+1] = comp('x',p.xn,6,true)
 	elseif p.nn then t[#t+1] = comp('n',p.nn,4) end
-	if t[2] == nil then
+	if t[2] == nil and not display then
 		return p.w .. '.' --make sure paths are always valid
 	end
 	return s(table.concat(t),'em')
 end
 local function pathMatch(a,b)
@@ -876,11 +1280,13 @@
 	res.def = lookup('definition', res.word.defs, a.dn)
 	if (not a.pn) and (not a.mn) then return res end
 
 	local m if a.pn then
 		res.phrase = lookup('phrase', res.def.phrases, a.pn)
-		res.meaning = lookup('meaning', res.phrase.means, a.mn)
+		if a.mn then
+			res.meaning = lookup('meaning', res.phrase.means, a.mn)
+		else return res end
 	else
 		res.meaning = lookup('meaning', res.def.means, a.mn)
 	end
 
 	if a.xn then
@@ -921,10 +1327,32 @@
 		if sub.nn ~= super.nn then return false end
 	end
 
 	return true
 end
+
+function ansi.formatMarkup(text, sty)
+	return (string.gsub(text, '(.?)(%b[])', function(esc,seg)
+		if esc == '\\' then return seg end
+		local mode, text = seg:match('^%[(.)%s*(.-)%]$')
+		local r
+		if mode == '\\' then
+			r = text
+		elseif mode == '*' then
+			r = sty.br(ansi.formatMarkup(text,sty))
+		elseif mode == '!' then
+			r = sty.em(ansi.formatMarkup(text,sty))
+		elseif mode == '_' then
+			r = sty.ul(ansi.formatMarkup(text,sty))
+		elseif mode == '$' then
+			r = sty.color(ansi.formatMarkup(text,sty),6,true)
+		elseif mode == '>' then
+			r = pathString(pathParse(text),sty,true)
+		else return seg end
+		return esc..r
+	end))
+end
 
 local cmds = {
 	create = {
 		help = "initialize a new dictionary file";
 		syntax = "<lang>";
@@ -938,13 +1366,15 @@
 				header = {
 					lang = lang;
 					meta = "";
 					partsOfSpeech = {};
 					inflectionForms = {};
+					orthographies = {};
 				};
 				words = {};
 				relsets = {};
+				morphs = {};
 			}
 			local o = writeDict(new);
 			fd:write(o)
 			fd:close()
 		end;
@@ -955,11 +1385,11 @@
 		write = true;
 		exec = function(ctx,word)
 			if ctx.dict.words[word] then
 				id10t "word already coined"
 			end
-			ctx.dict.words[word] = {defs={},rels={}}
+			ctx.dict.words[word] = {defs={},rels={},enc={}}
 		end;
 	};
 	def = {
 		help = "define a word";
 		syntax = "<word> <part-of-speech> [<meaning> [<root>…]]";
@@ -968,15 +1398,16 @@
 			local etym = {...}
 			if (not word) or not part then
 				id10t 'bad definition'
 			end
 			if not ctx.dict.words[word] then
-				ctx.dict.words[word] = {defs={},rels={}}
+				ctx.dict.words[word] = {defs={},rels={},enc={}}
 			end
 			local n = #(ctx.dict.words[word].defs)+1
 			ctx.dict.words[word].defs[n] = {
 				part = part;
+				writings = {};
 				branch = etym;
 				means = {means and {
 					lit=means;
 					examples={};
 					notes={};
@@ -992,12 +1423,12 @@
 	mean = {
 		help = "add a meaning to a definition";
 		syntax = "<word> <def#> <meaning>";
 		write = true;
 		exec = function(ctx,word,dn,m)
-			local t = pathResolve(ctx,{w=word,dn=dn})
-			table.insert(t.d.means, {lit=m,notes={}})
+			local t = pathResolve(ctx,{w=word,dn=tonumber(dn)})
+			table.insert(t.def.means, {lit=m,notes={},examples={},rels={}})
 		end;
 	};
 	rel = {
 		help = "manage groups of related words";
 		syntax = {
@@ -1132,19 +1563,30 @@
 		end;
 	};
 	mod = {
 		help = "move, merge, split, or delete words or definitions";
 		syntax = {
-			"<path> (drop | [move|merge|clobber] <path> | out [<part> [<root>…]])";
-			"path ::= <word>[(@<def#>[/<meaning#>[:<note#>]]|.)]";
+			"<path> (drop | [(to|move)|merge|clobber] <path>)";
+			"path ::= <word>[.[<def#>[/p<phrase#>][/m<meaning#>[(/n<note#>|/x<example#>)]]]]";
 		};
 		write = true;
+	};
+	morph = {
+		help = "manage and attach morphs (morphemes/composable glyphs)";
+		syntax = {
+			"(<ls>|<define>|<mod>)";
+			"define ::= def (id <name>|as) [<form>]… [from <morph>…]";
+			"ls ::= ls (<morph>|meta <key> <value>|has <key>)…";
+			"mod ::= <morph> (drop|[un]link <path>|meta <key> [<value>]|inc [<morph>])";
+			"morph ::= (id <name>|enc <form>)";
+			"form ::= [<script>]=<repr>";
+		};
 	};
 	note = {
 		help = "add a note to a definition or a paragraph to a note";
 		syntax = {"(<m-path> (add|for) <kind> | <m-path>:<note#>) <para>…";
-			"m-path ::= <word>@<def#>/<meaning#>"};
+			"m-path ::= <word>.<def#>[/p<phrase#]/m<meaning#>"};
 		write = true;
 		exec = function(ctx,path,...)
 			local paras, mng
 			local dest = pathParse(path)
 			local t = pathResolve(ctx,path)
@@ -1228,19 +1670,20 @@
 end
 
 function cmds.ls.exec(ctx,...)
 	local filter = nil
 	local out = {}
-	for i,f in ipairs{...} do
+	local args = {...}
+	for i=#args,1,-1 do local f <const> = args[i]
 		local fn = parsefilter(f)
 		local of = filter or function() return false end
 		filter = function(e)
 			return fn(e) or of(e)
 		end
 	end
 	for lit,w in pairs(ctx.dict.words) do
-		local e = {lit=lit, word=w}
+		local e = {lit=lit, word=w, dict=ctx.dict}
 		if filter == nil or filter(e) then
 			table.insert(out, e)
 		end
 	end
 	table.sort(out, function(a,b) return a.lit < b.lit end)
@@ -1287,11 +1730,11 @@
 			ant = flatten(antonymSets);
 			met = flatten(metonymSets);
 		}
 	end
 
-	local function formatRels(rls, padlen)
+	local function formatRels(lines, rls, padlen)
 		-- optimize for the common case
 		if next(rls.syn) == nil and
 		   next(rls.ant) == nil and
 			next(rls.met) == nil then return {} end
 		local pad = string.rep(' ',padlen)
@@ -1303,85 +1746,98 @@
 				if e.mn then str = string.format('%s§%u',str,e.mn) end
 				return str
 			end)
 			return fo.em(string.format("%s%s %s",pad,label,table.concat(each,', ')))
 		end
-		local lines = {}
 		local function add(l,c,lst)
 			table.insert(lines, format(fo.color(l,c,true),lst))
 		end
 		if next(rls.syn) then add('synonyms:',2,rls.syn) end
 		if next(rls.ant) then add('antonyms:',1,rls.ant) end
 		if next(rls.met) then add('metonyms:',4,rls.met) end
 		return lines
 	end
 
-	local function meanings(w,d,md,n)
-		local start = md and 2 or 1
-		local part = string.format('(%s)', d.part)
-		local pad = md and string.rep(' ', #part) or ''
-		local function note(n,insert)
+	local function formatMeaning(m, obj, path, indent) -- m = dest tbl
+		local pad = string.rep(' ', indent)
+		local function note(j,n,markup)
 			if not next(n.paras) then return end
 			local pad = string.rep(' ',#(n.kind) + 9)
-			insert('      ' .. fo.hl(' ' .. n.kind .. ' ') .. ' ' .. n.paras[1])
+
+			local nid = ''
+			if ctx.flags.ident then
+				nid='‹'..pathString(merge(path,{nn=j}), fo)..'›'
+			end
+			table.insert(m, nid..'      ' .. fo.hl(' ' .. n.kind .. ' ') .. ' ' .. markup(n.paras[1]))
 			for i=2,#n.paras do
-				insert(pad..n.paras[2])
-			end
-		end
-		local m = { (function()
-			if d.means[1] then
-				if md then
-					local id = ''
-					if ctx.flags.ident then
-						id=' ['..pathString({w=w.lit,dn=n,mn=1}, fo)..']'
-					end
-					return string.format(" %s %s 1. %s", id, fo.em(part), d.means[1].lit)
-				end
-			else return
-				fo.em(string.format('  %s [empty definition #%u]', part,n))
-			end
-		end)() }
-		tcatD(m, formatRels(gatherRelSets{w=w.lit,dn=n,mn=1}, 6))
-		for i=start,#d.means do local v = d.means[i]
-			local id = ''
-			if ctx.flags.ident then id='['..pathString({w=w.lit,dn=n,mn=n}, fo)..']' end
-			table.insert(m, string.format('  %s%s %u. %s', pad, id, i, v.lit))
-			tcatD(m, formatRels(gatherRelSets{w=w.lit,dn=n,mn=i}, 6))
-			for j,n in ipairs(v.notes) do
-				note(n, function(v) table.insert(m, v) end)
-			end
-		end
-		return table.concat(m,'\n')
-	end
-	local function autobreak(str)
-		if str ~= '' then return str..'\n' else return str end
-	end
+				table.insert(m, pad..markup(n.paras[2]))
+			end
+		end
+		local id = ''
+		if ctx.flags.ident then id='‹'..pathString(path, fo)..'›' end
+		table.insert(m, string.format('%s%s %u. %s', pad, id, path.mn, ansi.formatMarkup(obj.lit,fo)))
+		formatRels(m,gatherRelSets(path), 6)
+		for j,n in ipairs(obj.notes) do
+			note(j,n, function(v) return ansi.formatMarkup(v,fo) end)
+		end
+	end
+
+	local function defnMeanings(m, w,def,path,indent)
+		local part = ''
+		for i=1,#def.means do local v = def.means[i]
+			formatMeaning(m, v, merge(path,{mn=i}),indent)
+		end
+	end
+	local function parthead(def)
+		local str = string.format('(%s)', def.part)
+		return fo.color(fo.em(str), 199), #str
+	end
+	local markcolor, markcolors, markmap = 0, {
+		117, 75, 203, 48, 200, 190, 26, 48, 226, 198
+	}, {}
 	for i, w in ipairs(out) do
-		local d = fo.ul(fo.br(w.lit))
-		local wordrels = autobreak(table.concat(
-				formatRels(gatherRelSets{w=w.lit}, 2),
-				'\n'
-			))
-		if #w.word.defs == 1 then
-			d=d .. ' '
-			    .. fo.rgb(fo.em('('..(w.word.defs[1].part)..')'),.8,.5,1) .. '\n'
-			    .. meanings(w,w.word.defs[1],false,1) .. '\n'
-			    .. autobreak(table.concat(formatRels(gatherRelSets{w=w.lit,dn=1}, 4), '\n'))
-				 .. wordrels .. '\n'
-		else
-			for j, def in ipairs(w.word.defs) do
-				local syn if wsc and wsc[j] then syn = wsc[j] end
-				d=d .. '\n'
-				    .. meanings(w,syn,def,true,j) .. '\n'
-				    .. autobreak(table.concat(
-						 formatRels(gatherRelSets{w=w.lit,dn=j}, 4),
-						 '\n'
-					 ))
-			end
-			d=d .. wordrels .. '\n'
-		end
-		io.stdout:write(d)
+		local lines = { fo.ul(fo.br(w.lit)) }
+		local pad = 4
+		local ndefs = #w.word.defs
+		if ndefs == 1 then
+			local header = parthead(w.word.defs[1])
+			lines[1] = lines[1] .. ' ' .. header
+		end
+		local mark
+		local markline
+		if w.mark then
+			local marks = {}
+			for _,m in pairs(w.mark) do
+				if not markmap[m] then
+					markmap[m] = markcolors[markcolor+1]
+					markcolor = (markcolor+1)%#markcolors
+				end
+				local c = markmap[m]
+				table.insert(marks, fo.hl(fo.color(string.format(' %s ',m),c)))
+			end
+			mark = table.concat(marks, ' ')
+			markline = #lines
+		end
+
+		for j, d in ipairs(w.word.defs) do
+			local top = #lines -- :/
+			local header, hdln = parthead(d)
+			defnMeanings(lines, w, d, {w=w.lit, dn=j}, ndefs==1 and 0 or hdln+1)
+			if ctx.flags.rels then
+				 formatRels(lines, gatherRelSets{w=w.lit,dn=j}, 0)
+			end
+			if ndefs > 1 then
+				lines[top+1] = ' ' .. header .. string.sub(lines[top+1],hdln+2)
+			end
+		end
+		if ctx.flags.rels then
+			formatRels(lines,gatherRelSets{w=w.lit}, 2)
+		end
+		if markline then
+			lines[markline] = mark .. ' ' .. lines[markline]
+		end
+		io.stdout:write(table.concat(lines,'\n')..'\n')
 	end
 end
 
 function cmds.import.exec(ctx,file)
 	local ifd = io.stdin
@@ -1393,19 +1849,24 @@
 		header = {
 			lang = lang;
 			meta = "";
 			partsOfSpeech = {};
 			inflectionForms = {};
+			orthographies = {};
 		};
 		words = {};
 		relsets = {};
+		morphs = {};
 	}
 
 	local state = 0
 	local relsets = {}
 	local path = {}
 	local inflmap, lastinfl = {}
+	local orthoIDs, lastOrtho = {}
+	local morphIDs, lastMorph = {}
+	local lastWriting
 	for l in ifd:lines() do
 		local words = strwords(l)
 		local c = words[1]
 		local function syn(mn,mx)
 			local nw = #words - 1
@@ -1414,14 +1875,23 @@
 					id10t('command %s needs between %u~%u words',c,mn,mx)
 				else
 					id10t('command %s needs at least %u words',c,mn)
 				end
 			end
+		end
+		local function getuid(tbl, uid)
+			if tonumber(uid,16) == nil then
+				if not tbl[uid] then
+					tbl[uid] = math.random(0,0xffffFFFF)
+				end
+				return tbl[uid]
+			end
+			return tonumber(uid,16)
 		end
 		if c ~= '*' and c~='meta' then -- comments
 			if state == 0 then
-				if c ~= 'pv0' then
+				if c ~= 'PV0' then
 					id10t "not a parvan export"
 				end
 				new.header.lang = words[2]
 				new.header.meta = words[3]
 				state = 1
@@ -1432,13 +1902,14 @@
 					T.def,
 					T.phrase,
 					T.meaning,
 					T.note,
 					T.ex
-				if c == 'w' then syn(1) state = 2
+				if c == 'w' then syn(1) state = 10
 					path = {w=words[2]}
-					new.words[words[2]] = {defs={},rels={}}
+					new.words[words[2]] = {defs={},rels={},enc={}}
+					lastMorph = nil
 				elseif c == 'f' then syn(1)
 					local nf = {
 						name = words[2];
 						abbrev = words[3] or "";
 						desc = words[4] or "";
@@ -1452,64 +1923,146 @@
 						id10t 'fp can only be used after f' end
 					table.insert(lastinfl.parts,words[2])
 				elseif c == 's' then syn(2)
 					relsets[words[3]] = relsets[words[3]] or {}
 					relsets[words[3]].kind = words[2]
-					relsets[words[3]].uid = tonumber(words[3])
+					relsets[words[3]].uid = tonumber(words[3],16)
 					relsets[words[3]].members = relsets[words[3]].members or {}
-				elseif state >= 2 and c == 'r' then syn(1)
+				elseif c == 'mo' then syn(1)
+					local uid,name = table.unpack(words,2)
+					uid = getuid(morphIDs, uid)
+					new.morphs[uid] = {
+						name = name or '';
+						enc = {};
+						meta = {};
+						rads = {};
+					}
+					lastMorph = new.morphs[uid]
+				elseif lastMorph and state < 10 and c == 'M' then syn(2)
+					local key, val = table.unpack(words,2)
+					table.insert(lastMorph.meta, {key=key,val=val})
+				elseif lastMorph and state < 10 and c == 'r' then syn(1)
+					local r = getuid(morphIDs, words[2])
+					table.insert(lastMorph.rads, r)
+				elseif c == 'e' then syn(2)
+					local scr, blob = table.unpack(words,2)
+					scr = getuid(orthoIDs, scr)
+					if state <= 10 and lastMorph then
+						lastMorph.enc[scr] = blob
+					elseif state == 10 then
+						W.enc[scr] = blob
+					elseif state >= 11 and lastWriting then
+						lastWriting.enc[scr] = blob
+					else
+						id10t('encoding “%s” declared at bad position', blob)
+					end
+				elseif c == 'o' then syn(3)
+					local uid, name, repr = table.unpack(words,2)
+					repr = strwords(repr)
+					uid = getuid(orthoIDs, uid)
+					if #repr > 1 then
+						local kind, p1,p2 = table.unpack(repr)
+						repr = {kind,{}}
+						if kind == 'glyphs' then
+							repr[2].format = p1
+							repr[2].glyphs = {}
+							repr[2].encoding = p2
+						elseif kind == 'int' then
+							repr[2] = tonumber(p1,16)
+						end
+					else repr=repr[1] end
+					table.insert(new.header.orthographies, {
+						uid = uid;
+						name = name;
+						repr = repr;
+					})
+					lastOrtho = new.header.orthographies[#(new.header.orthographies)]
+				elseif c == 'og' then syn(2)
+					if not lastOrtho then
+						id10t '`og` must follow an orthography declaration'
+					elseif lastOrtho.repr[1] ~= 'glyphs' then
+						id10t('orthography declares %s representation', lastOrtho.repr[1])
+					end
+					local name, data = table.unpack(words,2)
+					table.insert(lastOrtho.repr[2].glyphs, {
+						-- TODO decode base?? data for binary encodings
+						name = name, image = data
+					})
+				elseif state >= 10 and c == 'r' or c == 'rh' then syn(1)
 					local rt
-					if state == 2 then
+					if state == 10 then
 						rt = W.rels
-					elseif state == 3 then
+					elseif state == 11 then
 						rt = D.rels
-					elseif state == 4 then
+					elseif state == 12 then
 						rt = D.rels
 					elseif state == 14 then
 						rt = P.rels
 					end
 					relsets[words[2]] = relsets[words[2]] or {
-						uid = tonumber(words[2]) or math.random(0,0xffffFFFF);
+						uid = tonumber(words[2],16) or math.random(0,0xffffFFFF);
 						members={};
 					}
-					table.insert(relsets[words[2]].members, path)
-				elseif state >= 2 and c == 'd' then syn(1) state = 3
+					local mems = relsets[words[2]].members
+					if c == 'rh' and next(mems) then
+						mems[#mems+1] = mems[1]
+						mems[1] = path
+					else
+						table.insert(mems,path)
+					end
+				elseif state >= 10 and c == 'd' then syn(1) state = 11
 					table.insert(W.defs, {
 						part = words[2];
+						writings = {};
 						branch = {};
 						means = {};
 						forms = {};
 						phrases = {};
 						rels = {};
 					})
 					path = {w = path.w, dn = #(W.defs)}
-				elseif state >= 3 and c == 'dr' then syn(1)
+				elseif state >= 11 and c == 'dr' then syn(1)
 					table.insert(D.branch, words[2])
-				elseif state >= 3 and c == 'df' then syn(2)
+				elseif state >= 11 and c == 'df' then syn(2)
 					if not inflmap[words[2]] then
 						id10t('no inflection form %s defined', words[2])
 					end
 					D.forms[inflmap[words[2]]] = words[3]
-				elseif state >= 3 and c == 'p' then syn(1) state = 14
+				elseif state >= 11 and c == 'p' then syn(1) state = 12
 					table.insert(D.phrases, {
 						str = words[2];
 						means = {};
 						rels = {};
 					})
 					path = {w = path.w, dn = path.dn, pn = #(D.phrases)}
-				elseif state >= 3 and c == 'm' then syn(1) state = 4
-					table.insert(D.means, {
+				elseif state >= 11 and c == 'm' then syn(1) state = 13
+					table.insert((P or D).means, {
 						lit = words[2];
 						notes = {};
 						examples = {};
 						rels = {};
 					});
-					path = {w = path.w, dn = path.dn, pn=path.pn, mn = #(D.means)}
-				elseif state >= 4 and c == 'n' then syn(1) state = 5
+					path = {w = path.w, dn = path.dn, pn=path.pn, mn = #((P or D).means)}
+				elseif state >= 11 and c == 'W' then
+					table.insert(D.writings, {
+						info = words[2] or '';
+						enc = {};
+						morphs = {};
+					})
+					lastWriting = D.writings[#(D.writings)]
+				elseif state >= 11 and lastWriting and c == 'Wmo' then syn(1)
+					local morph = getuid(morphIDs, words[2])
+					table.insert(lastWriting.morphs, morph)
+				elseif state >= 13 and c == 'x' then syn(1)
+					table.insert(M.examples, {
+						quote = words[2];
+						src = words[3] or '';
+					})
+				elseif state >= 13 and c == 'n' then syn(1) state = 14
 					table.insert(M.notes, {kind=words[2], paras={}})
 					path = {w = path.w, dn = path.dn, pn = path.pn, mn = path.mn, nn = #(M.notes)};
-				elseif state >= 5 and c == 'np' then syn(1)
+				elseif state >= 14 and c == 'np' then syn(1)
 					table.insert(N.paras, words[2])
 				end
 				-- we ignore invalid ctls, for sake of forward-compat
 			end
 		end
@@ -1534,85 +2087,105 @@
 end
 
 function cmds.export.exec(ctx,file)
 	local ofd = io.stdout
 	if file then ofd = safeopen(file, 'w+') end
-	local function san(str)
-		local d = 0
-		local r = {}
-		for i,cp in utf8.codes(str) do
-			-- insert backslashes for characters that would
-			-- disrupt strwords() parsing
-			if cp == 0x0a then
-				table.insert(r, 0x5c)
-				table.insert(r, 0x6e)
-			else
-				if cp == 0x5b then
-					d = d + 1
-				elseif cp == 0x5d then
-					if d >= 1 then
-						d = d - 1
-					else
-						table.insert(r, 0x5c)
-					end
-				end
-				table.insert(r, cp)
-			end
-		end
-		return '[' .. utf8.char(table.unpack(r)) .. ']'
-	end
+	local san = strsan
 	local function o(lvl,...)
 		local pfx = ''
 		if ctx.flags.human and lvl > 0 then
 			pfx = string.rep('\t', lvl)
 		end
 		ofd:write(pfx..string.format(...)..'\n')
 	end
 	local d = ctx.dict
-	o(0,'pv0 %s %s', san(d.header.lang), san(d.header.meta))
+	o(0,'PV0 %s %s', san(d.header.lang), san(d.header.meta))
 	local function checksyn(obj,lvl)
 		for k,v in pairs(obj.rels) do
-			o(lvl,'r %u',s.uid)
+			if d._relCache[v].mems[1].obj == obj
+				then o(lvl,'rh %x',v)
+				else o(lvl,'r %x',v)
+			end
 		end
 	end
 	for i,f in pairs(d.header.inflectionForms) do
 		o(0,'f %s %s %s', san(f.name), san(f.abbrev), san(f.desc))
 		for j,p in pairs(f.parts) do
 			o(1,'fp %s', san(p))
 		end
 	end
-	local function scanMeans(tbl,path,lvl)
-		for j,m in ipairs(def.means) do
+	for i,s in pairs(d.header.orthographies) do
+		local repr
+		if type(s.repr) == 'string'
+			then repr = s.repr
+			else repr = s.repr[1] end
+		if repr == 'int' then
+			repr = repr .. ' ' .. tostring(s.repr[2])
+		elseif repr == 'glyphs' then
+			repr = repr .. ' ' .. s.repr[2].format .. ' ' .. tostring(s.repr[2].encoding)
+		end
+		o(0, 'o %x %s %s', s.uid, san(s.name), san(repr))
+		if s.repr[1] == 'glyphs' then
+			for _,g in ipairs(s.repr[2].glyphs) do
+				o(1, 'og %s %s', san(g.name), san(g.image))
+			end
+		end
+	end
+	local function scanMeans(tbl,lvl)
+		for j,m in ipairs(tbl) do
 			o(lvl,'m %s', san(m.lit))
-			local lp = copy(path)
-			lp.mn = j
-			checksyn(m,lp,lvl+1)
+			checksyn(m,lvl+1)
+			for k,x in ipairs(m.examples) do
+				o(lvl+1,'x %s %s', san(x.quote,x.src))
+			end
 			for k,n in ipairs(m.notes) do
 				o(lvl+1,'n %s', san(n.kind))
 				for a,p in ipairs(n.paras) do
 					o(lvl+2,'np %s', san(p))
 				end
 			end
 		end
+	end
+	local function scanMeta(n, meta)
+		for i,m in ipairs(meta) do
+			o(n, 'M %s %s', san(m.key), san(m.val)) end
+	end
+	local function scanEnc(n, tbl)
+		for uid,enc in pairs(tbl)
+			do o(n, 'e %x %s',uid,san(enc)) end
+	end
+	for uid, m in pairs(d.morphs) do
+		o(0, 'mo %x %s', uid, san(m.name))
+		scanMeta(1, m.meta)
+		scanEnc(1, m.enc)
 	end
 	for lit, w in pairs(d.words) do
 		o(0,'w %s',san(lit))
-		checksyn(w,{w=lit},1)
+		checksyn(w,1)
+		scanEnc(1, w.enc)
 		for i,def in ipairs(w.defs) do
 			o(1,'d %s',san(def.part))
-			checksyn(def,{w=lit,dn=i},2)
+			for _, writ in ipairs(def.writings) do
+				if writ.info == '' then o(2,'W') else
+					o(2,'W %s',san(writ.info)) end
+				for mid,uid in pairs(writ.morphs) do
+					o(3, 'Wmo %x', uid) end
+				for uid,enc in pairs(writ.enc)
+					do o(3, 'e %x %s',uid,san(enc)) end
+			end
+			checksyn(def,2)
 			for j,r in ipairs(def.branch) do
 				o(2,'dr %s',san(r))
 			end
+			scanMeans(def.means, 2)
 			for j,p in ipairs(def.phrases) do
 				o(2,'p %s',san(p.str))
-				scanMeans(p.means, {w=lit,dn=i,pn=j}, 3)
+				scanMeans(p.means, 3)
 			end
-			scanMeans(def.means, {w=lit,dn=i}, 2)
 		end
 	end
-	for _,s in ipairs(d.relsets) do o(0,'s %s %u', s.kind, s.uid) end
+	for _,s in ipairs(d.relsets) do o(0,'s %s %x', s.kind, s.uid) end
 end
 
 local function filterD(lst, fn)
 -- cheap algorithm to destructively filter a list
 -- DOES NOT preserve order!!
@@ -1626,10 +2199,65 @@
 	end
 	return lst
 end
 
 function cmds.mod.exec(ctx, orig, oper, dest, ...)
+	local ops = {
+		word = {
+			mask = {
+				word = {move=true,merge=true,clobber=true};
+			};
+			move = function(from,to) end;
+			merge = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+		def = {
+			mask = {
+				word = {move=true};
+				def = {merge=true,clobber=true};
+			};
+			move = function(from,to) end;
+			merge = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+		phrase = {
+			mask = {
+				def = {move=true};
+				phrase = {clobber=true};
+			};
+			move = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+		meaning = {
+			mask = {
+				def = {move=true};
+				phrase = {move=true};
+				meaning = {merge=true,clobber=true};
+			};
+			move = function(from,to) end;
+			merge = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+		example = {
+			mask = {
+				meaning={move=true};
+				example={merge=true,clobber=true};
+			};
+			move = function(from,to) end;
+			merge = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+		note = {
+			mask = {
+				meaning={move=true};
+				note={merge=true,clobber=true};
+			};
+			move = function(from,to) end;
+			merge = function(from,to) end;
+			clobber = function(from,to) end;
+		};
+	}
 	rebuildRelationCache(ctx.dict)
 end
 
 local function fileLegible(file)
 	-- check if we can access the file
@@ -1761,11 +2389,12 @@
 	end
 end
 
 local globalFlags <const> = {
 	human = {'h','human','enable human-readable exports'};
-	ident = {'i','ident','show identifier paths for all items'}
+	ident = {'i','ident','show identifier paths for all items'};
+	rels  = {'r','rels', 'show relationships between words'};
 }
 
 local function
 usage(me,ctx)
 	local ln = 0
@@ -1795,10 +2424,11 @@
 	return 64
 end
 
 local function
 dispatch(argv, ctx)
+	local loglevel = 2
 	local ferr = ctx.sty[io.stderr]
 	local args = {}
 	local flags = {}
 	local i = 1 while i <= #argv do
 		local a = argv[i]
@@ -1817,10 +2447,17 @@
 			end
 		else table.insert(args, a) end
 	i = i + 1 end
 	for j=i,#argv do table.insert(args,argv[j]) end
 
+
+	do local ll = os.getenv('parvan_log')
+		if ll then loglevel = tonumber(ll) end
+		if flags[quiet] then loglevel=0
+		elseif flags[debug] then loglevel=4 end
+	end
+
 	local file, cmd = table.unpack(args)
 	if cmd and cmds[cmd] then
 		local c,fd,dict = cmds[cmd]
 		if (not c.raw) and not c.nofile then
 			fd = safeopen(file, "rb")
@@ -1829,14 +2466,25 @@
 			-- lua io has no truncate method, so we must
 			-- rely on the clobbering behavior of the open()
 			-- call instead :(
 		end
 
+		local function log(lvl,...)
+			local loglevels = {
+				fatal = 1,
+				warn = 2,
+				info = 3,
+				debug = 4
+			}
+			if loglevels[lvl] <= loglevel then
+				ctx.log(lvl,...)
+			end
+		end
 		cmds[cmd].exec({
 			sty = ctx.sty;
 			try = ctx.try;
-			log = ctx.log;
+			log = log;
 
 			flags = flags;
 			file = file;
 			fd = fd;
 			dict = dict;

ADDED   termcolors.lua
Index: termcolors.lua
==================================================================
--- termcolors.lua
+++ termcolors.lua
@@ -0,0 +1,76 @@
+-- [ʞ] termcolors.lua
+--  ~ lexi hale <lexi@hale.su>
+--  © AGPLv3
+--  ? print grids comparing truecolor output to 256-color output 
+
+function conv(a)
+	return 16 + math.floor(a.r*5)*36 + math.floor(a.g*5)*6 + math.floor(a.b*5)
+end
+local S = 32
+local M = 33 * 4
+local grid = {}
+
+local X,Y = 0,0
+for R=0,S do for G=0,S do
+	for B=0,S do
+		local r,g,b = R/S, G/S, B/S
+		grid[Y*M + X] = {r=r,g=g,b=b}
+		X = X + 1
+		if X == M then
+			X = 0
+			Y = Y + 1
+		end
+	end
+end end
+
+local function show(setcolor)
+	for y=0,#grid/M - 1,2 do
+	for x=0,M - 1 do
+		local top,bot = grid[y*M + x], grid[(y+1)*M + x]
+		setcolor(top, false)
+		setcolor(bot, true)
+		io.write(string.format('▀'))
+	end print('\27[m') end
+end
+
+print "-- using 256-color escapes"
+show(function(clr,bottom)
+	local tpl
+	if clr then
+		if bottom then tpl = '\27[48;5;%um'
+		else tpl = '\27[38;5;%um' end
+		io.write(string.format(tpl, conv(clr)))
+	else
+		if bottom
+			then io.write('\27[49m')
+			else io.write('\27[39m')
+		end
+	end
+end)
+
+print "-- using truecolor escapes"
+-- if false then
+show(function(clr,bottom)
+	local tpl
+	if clr then
+		if bottom then tpl = '\27[48;2;%u;%u;%um'
+		else tpl = '\27[38;2;%u;%u;%um' end
+		io.write(string.format(tpl,
+			math.floor(clr.r*0xff),
+			math.floor(clr.g*0xff),
+			math.floor(clr.b*0xff)))
+	else
+		if bottom
+			then io.write('\27[49m')
+			else io.write('\27[39m')
+		end
+	end
+end)
+-- end
+
+-- for R=0,S do for G=0,S do for B=0,S do
+-- 	local r,g,b = R/S, G/S, B/S
+-- 	io.write(string.format('\27[48;2;%u;%u;%um   ', math.ceil(r*0xff), math.ceil(g*0xff), math.ceil(b*0xff)))
+-- end print('\27[m') end end
+--
+-- print()