@dforge-core/dforge-mcp 0.2.44 → 0.2.46-next

package/skills/dforge-1c-import/scripts/lib/printgen.py

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+"""Write a module's ported 1C print forms from one compact spec, and preview them.
+
+A print form reads its data from the module's stored procedures (a print template's
+`datasets`, each a procedure keyed by the record): the procedures' signatures and columns go
+in `logic/stored_procedures.json`, the rights to run them in `security/roles.json`, the
+template in `ui/print_templates.json` beside its HTML and CSS under `print_templates/`. This
+writes the first three from one spec into the project's `authored/<module>/` tree, which
+`genmodule` lays over the generated module; the template's HTML and CSS are the project's own
+files there. A procedure's columns are read off its `RETURNS TABLE` in the module's SQL, so the
+declaration cannot drift from the function.
+
+`ui/print_templates.json` is written only when the platform takes `datasets` on a template
+(PRINT_DATASETS=1): until then the schema refuses the key, and a template without its data
+would print empty, so the forms wait and the procedures are installed and runnable on their
+own.
+
+A spec module (tools/project/prints_<module>.py) defines MODULE, ROLES, SQL (the files that
+declare its procedures) and PRINTS, a list of `print_form(...)`.
+
+    python tools/lib/printgen.py tools/project/prints_warehouse.py
+    python tools/1c.py printgen preview tools/project/prints_warehouse.py <form> <key>
+                                                  # render one record with LiquidJS, screenshot it
+"""
+from __future__ import print_function
+
+import codecs
+import collections
+import decimal
+import imp
+import io
+import json
+import os
+import re
+import subprocess
+import sys
+
+O = collections.OrderedDict
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+# a procedure column's pg type -> (fieldTypeCd, baseDatatypeCd)
+PG = {"text": ("text", "string"), "integer": ("number", "number"), "numeric": ("number", "number"),
+      "boolean": ("checkbox", "bool"), "date": ("date", "date"), "timestamptz": ("datetime", "timestamp"),
+      "uuid": ("text", "string")}
+
+
+def dataset(name, sp, single=False):
+	"""A template's dataset: its name in the template, the procedure, one row or many."""
+	return dict(name=name, sp=sp, single=single)
+
+
+def print_form(code, entity, en, uk, file, datasets, key, css=None, orientation="portrait",
+               size="A4", source=None):
+	"""A print form on `entity` (the module's own, or `module.entity`), its procedures called
+	with the record's `key` column."""
+	return dict(code=code, entity=entity, en=en, uk=uk, file=file, css=css, datasets=datasets,
+	            key=key, orientation=orientation, size=size, source=source)
+
+
+def _read(path):
+	if not os.path.isfile(path):
+		return O()
+	with codecs.open(path, "r", "utf-8") as f:
+		return json.load(f, object_pairs_hook=O)
+
+
+def _write(path, doc):
+	directory = os.path.dirname(path)
+	if not os.path.isdir(directory):
+		os.makedirs(directory)
+	with codecs.open(path, "w", "utf-8") as f:
+		f.write(json.dumps(doc, ensure_ascii=False, indent="\t") + "\n")
+
+
+def signatures(sql_paths):
+	"""{function name: (params [(name, pg type)], columns [(name, pg type)])} off the SQL."""
+	out = {}
+	pattern = re.compile(r"CREATE OR REPLACE FUNCTION\s+\w+\.(\w+)\s*\(([^)]*)\)\s*RETURNS TABLE\s*\((.*?)\)\s*LANGUAGE",
+	                     re.S | re.I)
+	for path in sql_paths:
+		with io.open(path, encoding="utf-8") as f:
+			text = f.read()
+		for name, params, columns in pattern.findall(text):
+			def pairs(spec):
+				return [tuple(part.strip().split()[:2]) for part in spec.split(",") if part.strip()]
+			out[name] = (pairs(params), pairs(columns))
+	return out
+
+
+def build(spec, root):
+	sql = [os.path.join(root, p) for p in spec.SQL]
+	sigs = signatures(sql)
+	sps = _read(os.path.join(root, "logic", "stored_procedures.json"))
+	for k in [k for k in sps if k.startswith("prn_")]:
+		del sps[k]
+	rights = O()
+	templates = O()
+	uk = O()
+	for form in spec.PRINTS:
+		for ds in form["datasets"]:
+			if ds["sp"] not in sigs:
+				raise SystemExit("printgen: %s is not declared in %s" % (ds["sp"], ", ".join(spec.SQL)))
+			params, columns = sigs[ds["sp"]]
+			sps[ds["sp"]] = O([
+				("description", "%s: %s" % (form["en"], ds["name"])), ("functionName", ds["sp"]),
+				("params", [O([("paramCd", p), ("pgType", t), ("fieldTypeCd", PG.get(t, PG["text"])[0]),
+				               ("label", p), ("required", True)]) for p, t in params]),
+				("columns", [O([("columnCd", c), ("label", c), ("fieldTypeCd", PG.get(t, PG["text"])[0]),
+				                ("baseDatatypeCd", PG.get(t, PG["text"])[1])]) for c, t in columns])])
+			rights["sp:" + ds["sp"]] = "E"
+		entry = O([("entityCd", form["entity"]), ("description", form["uk"]), ("file", form["file"])])
+		if form["css"]:
+			entry["css"] = form["css"]
+		entry["pageSettings"] = O([("size", form["size"]), ("orientation", form["orientation"]),
+		                           ("margins", O([("top", "8mm"), ("right", "8mm"), ("bottom", "8mm"), ("left", "8mm")]))])
+		entry["datasets"] = O((ds["name"], O([("sp", ds["sp"]), ("params", O([(sigs[ds["sp"]][0][0][0], form["key"])])),
+		                                      ("single", ds["single"])])) for ds in form["datasets"])
+		templates[form["code"]] = entry
+		uk[form["code"]] = {"label": form["uk"]}
+
+	_write(os.path.join(root, "logic", "stored_procedures.json"), sps)
+	path = os.path.join(root, "security", "roles.json")
+	doc = _read(path)
+	for role in spec.ROLES:
+		r = doc.setdefault(role, O([("rights", O())]))
+		r.setdefault("rights", O())
+		for key in [k for k in r["rights"] if k.startswith("sp:prn_")]:
+			del r["rights"][key]
+		r["rights"].update(rights)
+	_write(path, doc)
+	path = os.path.join(root, "translations", "uk-UA.json")
+	translations = _read(path)
+	translations["print_templates"] = uk
+	_write(path, translations)
+	target = os.path.join(root, "ui", "print_templates.json")
+	if os.environ.get("PRINT_DATASETS") == "1":
+		_write(target, templates)
+	elif os.path.isfile(target):
+		os.remove(target)
+	return templates
+
+
+# --------------------------------------------------------------------------- preview
+
+RENDER_JS = r"""
+const { Liquid } = require('liquidjs');
+const fs = require('fs');
+const [tpl, css, data, out] = process.argv.slice(2);
+const engine = new Liquid();
+const nf = (v, d) => (v === null || v === undefined || v === '') ? '' :
+	Number(v).toLocaleString('uk-UA', { minimumFractionDigits: d || 0, maximumFractionDigits: d || 0 });
+engine.registerFilter('format_number', (v, d) => nf(v, d));
+engine.registerFilter('format_currency', (v, c, d) => nf(v, d === undefined ? 2 : d) + (c ? ' ' + c : ''));
+engine.registerFilter('format_date', (v) => v === null || v === undefined ? '' : String(v));
+const ctx = JSON.parse(fs.readFileSync(data, 'utf8'));
+engine.parseAndRender(fs.readFileSync(tpl, 'utf8'), ctx).then(html => {
+	fs.writeFileSync(out, '<!doctype html><html><head><meta charset="utf-8"><style>' +
+		(css ? fs.readFileSync(css, 'utf8') : '') + '</style></head><body>' + html + '</body></html>');
+});
+"""
+
+EDGE = r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
+
+
+def _plain(value):
+	if isinstance(value, decimal.Decimal):
+		return float(value)
+	if hasattr(value, "isoformat"):
+		return value.isoformat()
+	return value
+
+
+def preview(spec, root, code, key, out_dir, node_dir):
+	"""Render one record's form with LiquidJS (the editor's engine) to HTML and a PNG."""
+	import migrate
+	migrate.load_env()
+	form = [f for f in spec.PRINTS if f["code"] == code][0]
+	pg = migrate.pg_connect()
+	pg.autocommit = True
+	cur = pg.cursor()
+	# the module's SQL as written, in a transaction rolled back after the read: the functions the
+	# installer owns are left as they are
+	cur.execute("BEGIN")
+	for path in spec.SQL:
+		with io.open(os.path.join(root, path), encoding="utf-8") as f:
+			cur.execute(f.read())
+	ctx = {}
+	for ds in form["datasets"]:
+		cur.execute("SELECT * FROM %s.%s(%%s)" % (spec.SCHEMA, ds["sp"]), (key,))
+		names = [d[0] for d in cur.description]
+		rows = [dict((n, _plain(v)) for n, v in zip(names, r)) for r in cur.fetchall()]
+		ctx[ds["name"]] = (rows[0] if rows else None) if ds["single"] else rows
+	cur.execute("ROLLBACK")
+	if not os.path.isdir(out_dir):
+		os.makedirs(out_dir)
+	data = os.path.join(out_dir, code + ".json")
+	with io.open(data, "w", encoding="utf-8") as f:
+		f.write(json.dumps(ctx, ensure_ascii=False))
+	script = os.path.join(node_dir, "render.js")
+	with io.open(script, "w", encoding="utf-8") as f:
+		f.write(RENDER_JS)
+	html = os.path.join(out_dir, code + ".html")
+	tpl = os.path.join(root, "print_templates", form["file"])
+	css = os.path.join(root, "print_templates", form["css"]) if form["css"] else ""
+	subprocess.check_call(["node", script, tpl, css, data, html], cwd=node_dir)
+	png = os.path.join(out_dir, code + ".png")
+	width = 1400 if form["orientation"] == "landscape" else 1000
+	subprocess.call([EDGE, "--headless=new", "--disable-gpu", "--screenshot=" + png,
+	                 "--window-size=%d,1300" % width, "file:///" + html.replace("\\", "/")],
+	                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+	return html, png
+
+
+def load(spec_path):
+	return imp.load_source(os.path.splitext(os.path.basename(spec_path))[0], spec_path)
+
+
+def main(argv):
+	if len(argv) > 1 and argv[1] == "preview":
+		spec = load(argv[2])
+		root = os.path.normpath(os.path.join(HERE, "..", "project", "authored", spec.MODULE))
+		out = os.environ.get("PRINT_PREVIEW_DIR") or os.path.join(HERE, "..", "..", "out", "prints")
+		node = os.environ.get("PRINT_NODE_DIR")
+		if not node:
+			raise SystemExit("printgen preview: set PRINT_NODE_DIR to a folder with liquidjs installed")
+		for path in preview(spec, root, argv[3], argv[4], os.path.normpath(out), node):
+			print(path)
+		return 0
+	for spec_path in argv[1:]:
+		spec = load(spec_path)
+		root = os.path.normpath(os.path.join(HERE, "..", "project", "authored", spec.MODULE))
+		templates = build(spec, root)
+		print("%s: %d print form(s)%s" % (spec.MODULE, len(templates),
+		      "" if os.environ.get("PRINT_DATASETS") == "1" else ", templates held until the platform takes datasets"))
+	return 0
+
+
+if __name__ == "__main__":
+	sys.exit(main(sys.argv))

package/skills/dforge-1c-import/scripts/lib/rebuild.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Rebuild a tenant from nothing: install every module, then load every contour.
+
+Written the day `docker/reset.sh` wiped the tenant and the recipe turned out to live in
+one person's head and one section of a status document. Both are worse than a command:
+the order is computed rather than remembered, each step says what it did, and a failure
+stops at the module that failed instead of leaving half a tenant behind.
+
+    python tools/1c.py rebuild --code <tenant>              # install, then load, everything
+    python tools/1c.py rebuild --code <tenant> --install    # modules only
+    python tools/1c.py rebuild --code <tenant> --load       # data only
+    python tools/1c.py rebuild --code <tenant> --from production   # resume at a module
+    python tools/1c.py rebuild --code <tenant> --only planning     # one module, on its own
+    python tools/1c.py rebuild --code <tenant> --plan       # print the order and stop
+
+**Install-then-load is the wrong order for a register that caches its totals.** A `totals`
+cache is rebuilt when the register is installed or its shape changes, and never again - there
+is no rebuild command - so rows loaded afterwards never reach it and `getBalance` as of a date
+comes back short with no error at all. None of the registers declared here has a `totals`
+cache, which is the only reason this order is safe; the day one does, its contour has to be
+loaded before the module that declares it is installed.
+
+It does NOT create the tenant. That needs an admin user to exist first and is one
+command in the platform's own CLI, which says plainly what it wants:
+
+    curl -s -X POST http://localhost:5002/api/auth/register -H "Content-Type: application/json" \\
+         -d '{"email":"...","password":"...","firstName":"...","lastName":"..."}'
+    npx -y @dforge-core/dforge-cli@latest tenant create \\
+         --code <code> --name <name> --admin <email>
+
+Installing runs the platform's published CLI on this machine (tools/lib/cli.py), straight
+from this repository's module directories.
+"""
+from __future__ import print_function
+
+import argparse
+import os
+import subprocess
+import sys
+import time
+
+import cli
+import deps
+import paths
+
+def install_order():
+	"""Every generated module, in an order where nothing precedes what it depends on."""
+	sequence, stuck = deps.order(deps.graph())
+	if stuck:
+		raise SystemExit("rebuild: %s cannot be ordered - a cycle in the manifests"
+		                 % ", ".join(sorted(stuck)))
+	return [code for code in sequence
+	        if os.path.isdir(os.path.join(paths.MODULES, code))]
+
+
+def remote(tenant):
+	"""`--url` and `--token` for an install through the running API, when DFORGE_URL is set.
+
+	A local install writes the tenant's metadata straight to the database, and the running
+	dforge-api never hears of it: it goes on serving the old action scripts and register
+	bindings until its cache expires or it restarts - two engine replays on 2026-10-19 ran
+	the previous code. Through the API the same request invalidates them. A new tenant has
+	no session to sign in with yet, so this stays opt-in.
+	"""
+	url = os.environ.get("DFORGE_URL")
+	if not url:
+		return []
+	import posting
+	named = os.environ.get("DF_TENANT")
+	os.environ["DF_TENANT"] = tenant
+	try:
+		return ["--url", url, "--token", posting.token()]
+	finally:
+		if named is None:
+			del os.environ["DF_TENANT"]
+		else:
+			os.environ["DF_TENANT"] = named
+
+
+def install(tenant, code, verbose=False):
+	rc, out = cli.run(["module", "install", "--code", tenant,
+	                   "--path", os.path.join(paths.MODULES, code), "--force"] + remote(tenant))
+	if verbose:
+		print(out)
+	# a local install reports in prose, one through the API in JSON
+	if rc != 0 or not ("installed successfully" in out or '"success":true' in out):
+		tail = [line for line in out.splitlines() if line.strip()][-12:]
+		raise SystemExit("rebuild: installing %s failed\n   %s"
+		                 % (code, "\n   ".join(tail)))
+	# The one line worth keeping from a hundred: what the registrar actually did.
+	return next((l.strip() for l in out.splitlines() if "Registers:" in l), "")
+
+
+def load(tenant, code, verbose=False):
+	"""Copy the contour's rows. `migrate` reads the tenant's own shape, so it must run
+	after the install rather than beside it.
+
+	**The tenant has to be handed over explicitly.** `migrate` picks its target from
+	`DF_TENANT`, which has no default, and it takes no tenant argument - so a `load` that
+	only passed the module loaded whatever `.env` pointed at while reporting the tenant
+	named on the command line. It truncates as it goes, so the wrong tenant is not a
+	no-op: `rebuild --code <other> --load` emptied and reloaded whatever DF_TENANT named and left the other empty.
+	"""
+	command = [sys.executable, os.path.join(paths.ROOT, "tools", "1c.py"),
+	           "migrate", "run", code, "--truncate"]
+	# Both names, and both pinned rather than cleared. `migrate.load_env()` fills from `.env`
+	# with `setdefault`, so an unset variable is not a safe default - it is an invitation:
+	# clearing DF_PG_DB would let a DF_PG_DB in `.env` win over the DF_TENANT set here, and
+	# the load would truncate that database while reporting this tenant.
+	env = dict(os.environ, PYTHONIOENCODING="utf-8",
+	           DF_TENANT=tenant, DF_PG_DB="dforge_%s" % tenant)
+	proc = subprocess.Popen(command, cwd=paths.ROOT, env=env,
+	                        stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+	out = proc.communicate()[0].decode("utf-8", "replace")
+	if verbose:
+		print(out)
+	if proc.returncode != 0:
+		tail = [line for line in out.splitlines() if line.strip()][-12:]
+		raise SystemExit("rebuild: loading %s failed\n   %s" % (code, "\n   ".join(tail)))
+	# A balance register whose journal was just reloaded has a state nothing else rebuilds:
+	# 1C has no state table to copy, and the platform only moves it by posting.
+	seeded = subprocess.Popen(
+		[sys.executable, os.path.join(paths.ROOT, "tools", "1c.py"), "seedstate", "run", code],
+		cwd=paths.ROOT, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+	seed_out = seeded.communicate()[0].decode("utf-8", "replace")
+	if verbose:
+		print(seed_out)
+	if seeded.returncode != 0:
+		raise SystemExit("rebuild: seeding the balance state of %s failed\n   %s"
+		                 % (code, seed_out.strip()))
+	for line in reversed(out.splitlines()):
+		parts = line.split()
+		if len(parts) >= 2 and parts[1] == "entities":
+			return line.strip()
+	return ""
+
+
+def run(codes, doing, action, verbose=False):
+	started = time.time()
+	for index, code in enumerate(codes, 1):
+		mark = time.time()
+		note = action(code, verbose)
+		print("   %2d/%d  %-12s %6.1fs  %s"
+		      % (index, len(codes), code, time.time() - mark, note))
+		sys.stdout.flush()
+	print("   %s: %d module(s) in %.0fs" % (doing, len(codes), time.time() - started))
+
+
+def main():
+	parser = argparse.ArgumentParser(description=__doc__.strip().splitlines()[0])
+	parser.add_argument("--code", required=True, help="tenant code, as the platform knows it")
+	parser.add_argument("--install", action="store_true", help="modules only")
+	parser.add_argument("--load", action="store_true", help="data only")
+	parser.add_argument("--from", dest="start", help="resume at this module")
+	parser.add_argument("--only", help="this module alone, dependencies assumed installed")
+	parser.add_argument("--plan", action="store_true", help="print the order and stop")
+	parser.add_argument("--verbose", action="store_true")
+	args = parser.parse_args()
+
+	codes = install_order()
+	if args.only and args.start:
+		raise SystemExit("rebuild: --only and --from ask for different things")
+	if args.only:
+		# One module, after a declaration changed. Its dependencies are already installed -
+		# reinstalling them would be an upgrade in place, which is safe but not free, and
+		# reloading their rows would be minutes of nothing.
+		if args.only not in codes:
+			raise SystemExit("rebuild: %r is not one of %s" % (args.only, ", ".join(codes)))
+		codes = [args.only]
+	if args.start:
+		if args.start not in codes:
+			raise SystemExit("rebuild: %r is not one of %s" % (args.start, ", ".join(codes)))
+		codes = codes[codes.index(args.start):]
+
+	print("[i] tenant %s, modules from %s" % (args.code, paths.MODULES))
+	print("[i] %d module(s): %s" % (len(codes), " -> ".join(codes)))
+	if args.plan:
+		return
+
+	both = not (args.install or args.load)
+	if args.install or both:
+		print("\ninstalling")
+		run(codes, "installed",
+		    lambda code, verbose: install(args.code, code, verbose), args.verbose)
+	if args.load or both:
+		print("\nloading into %s" % args.code)
+		run(codes, "loaded",
+		    lambda code, verbose: load(args.code, code, verbose), args.verbose)
+
+
+if __name__ == "__main__":
+	main()

package/skills/dforge-1c-import/scripts/lib/recorded.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+u"""What each document type actually wrote: register rows by recorder type, every register.
+
+The call graph (`callgraph.py`) says what the code CAN write. This says what 1C DID write,
+and the difference between the two is the call graph's error, measured rather than argued:
+
+  * a register the code reaches but no document of that type ever wrote is either a branch
+    this client never took or an over-reach of the analysis - the chain in callgraph.json
+    tells which;
+  * a register a document wrote that the code does not reach is a miss, always a defect.
+
+A register with several recorder types carries `_RecorderTRef`, whose low two bytes are the
+recorder's document table number. One with a single recorder type has no TRef; its type is
+the one document table whose keys its recorders match.
+
+    python tools/1c.py recorded            # writes out/recorded.json
+    python tools/1c.py recorded --compare  # and scores out/callgraph.json against it
+
+Read-only, and `NOLOCK`: a count does not need to wait for anyone.
+"""
+from __future__ import print_function
+
+import codecs
+import collections
+import io
+import json
+import os
+import sys
+
+import meta
+import migrate
+import paths
+
+TARGET = os.path.join(paths.OUT, "recorded.json")
+
+
+def registers():
+	"""(family, name, physical table) for every register in the configuration."""
+	with io.open(os.path.join(paths.OUT, "objects.json"), encoding="utf-8") as f:
+		objects = json.load(f)
+	index = meta.dbnames_index()
+	found = []
+	for obj in objects:
+		if obj.get("family") not in ("AccumRg", "InfoRg", "AccRg", "CRg"):
+			continue
+		entry = index.get(obj["guid"])
+		if entry and entry["type"] == obj["family"]:
+			found.append((obj["family"], obj["name"], entry["physical"]))
+	return sorted(found)
+
+
+def documents():
+	"""Document table number -> (name, physical table)."""
+	with io.open(os.path.join(paths.OUT, "objects.json"), encoding="utf-8") as f:
+		objects = json.load(f)
+	index = meta.dbnames_index()
+	found = {}
+	for obj in objects:
+		if obj.get("family") != "Document":
+			continue
+		entry = index.get(obj["guid"])
+		if entry and entry["type"] == "Document":
+			found[int(entry["number"])] = (obj["name"], entry["physical"])
+	return found
+
+
+def columns(cur, table):
+	cur.execute("SELECT name FROM sys.columns WHERE object_id = OBJECT_ID(?)", "dbo." + table)
+	return set(row[0] for row in cur.fetchall())
+
+
+def single_recorder(cur, table, docs):
+	"""The one document type a TRef-less register's recorders belong to."""
+	cur.execute("SELECT DISTINCT TOP (20) _RecorderRRef FROM dbo.[%s] WITH (NOLOCK)" % table)
+	refs = [bytes(r[0]) for r in cur.fetchall()]
+	if not refs:
+		return None
+	marks = ",".join("?" * len(refs))
+	for number, (name, physical) in sorted(docs.items()):
+		cur.execute("SELECT COUNT(*) FROM dbo.[%s] WHERE _IDRRef IN (%s)" % (physical, marks),
+		            *refs)
+		if cur.fetchone()[0]:
+			return number
+	return None
+
+
+def measure():
+	migrate.load_env()
+	cur = migrate.mssql_connect().cursor()
+	docs = documents()
+	result = collections.defaultdict(dict)       # document -> register -> rows
+	unmatched = []
+	for family, name, table in registers():
+		cols = columns(cur, table)
+		if "_RecorderRRef" not in cols:
+			continue                             # not subordinate to a recorder
+		if "_RecorderTRef" in cols:
+			cur.execute("SELECT _RecorderTRef, COUNT_BIG(*) FROM dbo.[%s] WITH (NOLOCK)"
+			            " GROUP BY _RecorderTRef" % table)
+			for tref, rows in cur.fetchall():
+				number = int.from_bytes(bytes(tref), "big") & 0xFFFF
+				if number in docs:
+					result[docs[number][0]][name] = int(rows)
+				else:
+					unmatched.append((name, number, int(rows)))
+		else:
+			cur.execute("SELECT COUNT_BIG(*) FROM dbo.[%s] WITH (NOLOCK)" % table)
+			rows = int(cur.fetchone()[0])
+			if not rows:
+				continue
+			number = single_recorder(cur, table, docs)
+			if number is None:
+				unmatched.append((name, None, rows))
+			else:
+				result[docs[number][0]][name] = rows
+		sys.stderr.write(".")
+	sys.stderr.write("\n")
+	return dict(result), unmatched
+
+
+def compare(recorded, out):
+	"""Score the call graph against what 1C wrote, per document that wrote anything."""
+	with io.open(os.path.join(paths.OUT, "callgraph.json"), encoding="utf-8") as f:
+		graph = dict((r["document"], set(r["registers"])
+		              ) for r in json.load(f)["documents"])
+	hit = miss = extra = 0
+	lines = []
+	for document in sorted(recorded):
+		actual = set(recorded[document])
+		static = graph.get(document, set())
+		missed = actual - static
+		over = static - actual
+		hit += len(actual & static)
+		miss += len(missed)
+		extra += len(over)
+		if missed or over:
+			lines.append((document, sorted(missed), sorted(over)))
+	out.write(u"%d documents wrote registers in 1C. Register pairs: %d found by the call "
+	          u"graph, %d missed, %d reached by code but never written\n\n"
+	          % (len(recorded), hit, miss, extra))
+	for document, missed, over in lines:
+		if missed:
+			out.write(u"%-44s MISSED %s\n" % (document[:44], u", ".join(missed)))
+	out.write(u"\n")
+	for document, missed, over in lines:
+		if over:
+			out.write(u"%-44s never written: %s\n" % (document[:44], u", ".join(over)[:150]))
+
+
+def main():
+	out = codecs.getwriter("utf-8")(sys.stdout.buffer)
+	if os.path.exists(TARGET) and "--measure" not in sys.argv:
+		with io.open(TARGET, encoding="utf-8") as f:
+			saved = json.load(f)
+		recorded = saved["documents"]
+	else:
+		recorded, unmatched = measure()
+		with codecs.open(TARGET, "w", "utf-8") as f:
+			json.dump({"documents": recorded, "unmatched": unmatched}, f,
+			          ensure_ascii=False, indent="\t", sort_keys=True)
+		out.write(u"%d document types wrote registers; %d register/type pairs unmatched\n"
+		          % (len(recorded), len(unmatched)))
+		out.write(u"written %s\n" % TARGET)
+	if "--compare" in sys.argv:
+		compare(recorded, out)
+
+
+if __name__ == "__main__":
+	main()