fix(diagrams): #104 review — a name every object answers to is not a model, a version or a shape

Two findings from the Copilot review, both right, and a third of the same kind
that looking for them turned up.

stats.js — "IDs such as `constructor` resolve inherited properties". The
counters are plain objects keyed by model id, and a model id is whatever a
provider calls it. For a model called "constructor" the lookup found Object
itself: `calls++` wrote to Object, and the next line threw. For "__proto__" it
found the prototype every object shares, and `calls++` wrote there — every
object in the extension host had a `calls` of NaN — before it threw. The service
swallows a counter that throws, so the diagram was still drawn; the write was
not undone. An error class is a key too: "constructor" passes the class
pattern, and its count came out as "function Object() { [native code] }1".

A key is now read as an own property and written as one (defineProperty, so
"__proto__" is an entry and not a call to the prototype's setter). The store
stays an ordinary object: what is already in the editor's storage reads as
before, and it survives the JSON round trip it is stored through.

validate.js — "a crafted schema version such as `toString` resolves through
SCHEMAS' prototype". validate() promises a list of errors and threw instead:
SCHEMAS["toString"] is a function, so the version was "known", and the check
that followed read `.type` of undefined. prepare() threw with it, and so did
accept(), which is what reads a stored record back. A version is now looked up
only when it is one of the numbers this editor reads. That is deliberately
stricter than "an own key of the registry": no schema declares `v`, so the
string "1" passed as version 1 and was stored as a string, with nothing after
the lookup to object. On the ladder a version written as digits is still read
as the number, as before.

repair.js — the same lookup a third time, found by feeding those names through
every field. The synonym tables are objects, and `"shape": "constructor"`
found Object: the spec came out with a FUNCTION for a shape, and the model was
told "/nodes/0/shape: expected a string, got function" about a string it had
written. A line style of that name was read as solid without a word. A word is
now looked up as the table's own entry, so this one is unknown like any other
unknown word: drawn with the default, and said so.

Nothing else in these modules indexes an object with text from a spec: ids,
labels and groups are kept in Maps, and the schema is walked by its own field
names. The chat page keeps a table of its own, keyed by tool-call id; that one
is fixed with the page, two commits on.

Each has a test that fails on the code as reviewed: six such names as model
ids and one as an error class, with nothing written to Object or its
prototype, before and after a trip through JSON; fifteen things that are not
version 1 — the string "1" and the list [1] among them — as one error each and
never a throw, and four of them up the ladder and through accept(); seven such
words as a direction, a shape and a line style, with exactly the outcome of
"zigzag".

Author: ndemianc

extensions/levelcode-ai/diagram/repair.js

@@ -172,6 +172,9 @@
 	};
 	const WRAPPERS = ['spec', 'diagram', 'graph', 'input', 'json', 'arguments', 'data'];
 	const key = (s) => String(s == null ? '' : s).toLowerCase().trim().replace(/[\s_]+/g, '-');
+	// A synonym table is an object, and every object answers to "constructor": the word is looked up as
+	// the table's OWN entry, so a word it has never heard of is unknown whatever it happens to be.
+	const synonym = (table, word) => { const k = key(word); return Object.prototype.hasOwnProperty.call(table, k) ? table[k] : undefined; };
 	const pick = (obj, names) => { for (const n of names) { if (obj[n] !== undefined && obj[n] !== null) { return obj[n]; } } return undefined; };
 	const asBool = (v) => (v === true || v === 1 || (typeof v === 'string' && /^(true|yes|1)$/i.test(v.trim())));
 	const scalar = (v) => (typeof v === 'string' || typeof v === 'number') ? String(v) : undefined;
@@ -239,7 +242,7 @@
 		const dirRaw = pick(raw, ['direction', 'dir', 'rankdir', 'orientation', 'flow']);
 		if (dirRaw === undefined) { spec.direction = 'right'; }
 		else {
-			const d = DIRECTION_SYNONYMS[key(dirRaw)];
+			const d = synonym(DIRECTION_SYNONYMS, dirRaw);
 			if (d) { spec.direction = d; if (d !== dirRaw) { fix('/direction', 'synonym', JSON.stringify(dirRaw) + ' read as "' + d + '".'); } }
 			else { spec.direction = 'right'; fix('/direction', 'enum', JSON.stringify(dirRaw) + ' is not a direction; used "right".', { show: true }); }
 		}
@@ -317,7 +320,7 @@
 				if (sub) { out.sub = sub; }
 				const shapeRaw = pick(n, ['shape', 'type', 'kind']);
 				if (shapeRaw !== undefined) {
-					const s = SHAPE_SYNONYMS[key(shapeRaw)];
+					const s = synonym(SHAPE_SYNONYMS, shapeRaw);
 					if (s) { if (s !== 'box') { out.shape = s; } if (s !== shapeRaw) { fix(at + '/shape', 'synonym', JSON.stringify(shapeRaw) + ' read as "' + s + '".'); } }
 					else { fix(at + '/shape', 'enum', JSON.stringify(shapeRaw) + ' is not a shape; drew a box.', { show: true }); }
 				}
@@ -409,7 +412,7 @@
 				if (label !== undefined && cleanText(label)) { out.label = cleanText(label); }
 				const styleRaw = pick(e, ['style', 'type', 'line', 'kind']);
 				if (styleRaw !== undefined) {
-					const s = STYLE_SYNONYMS[key(styleRaw)];
+					const s = synonym(STYLE_SYNONYMS, styleRaw);
 					if (s === 'dashed') { out.style = 'dashed'; }
 					if (!s) { fix(at + '/style', 'enum', JSON.stringify(styleRaw) + ' is not a line style; drew it solid.', { show: true }); }
 					else if (s !== styleRaw) { fix(at + '/style', 'synonym', JSON.stringify(styleRaw) + ' read as "' + s + '".'); }
@@ -523,7 +526,7 @@
 		else { out.title = 'Untitled diagram'; notes.push('no title given'); }
 		if (typeof spec.tip === 'string') { out.tip = truncate(spec.tip, HARD.tip); }
 		// A spec from a NEWER editor than this one: draw what this schema understands, and say so.
-		if (spec.v !== undefined && !schema.SCHEMAS[spec.v]) { notes.push('written for schema v' + String(spec.v).slice(0, 8) + '; drawn as v' + schema.VERSION); }
+		if (spec.v !== undefined && !schema.schemaFor(spec.v)) { notes.push('written for schema v' + String(spec.v).slice(0, 8) + '; drawn as v' + schema.VERSION); }
 
 		// nodes: keep the well-formed ones, up to the hard ceiling
 		const ids = new Set();
@@ -679,7 +682,7 @@
 		if (r.ok) {
 			// Valid — but the validator checks the fields it knows and is silent about any others, and a
 			// record from a session file can carry anything. What is handed on is the declared shape only.
-			const declared = schema.project(schema.SCHEMAS[m.v].hard, m);
+			const declared = schema.project(schema.schemaFor(m.v).hard, m);
 			return { ok: true, spec: Object.assign({ v: m.v }, declared), notes: [] };
 		}
 		const p = prepare(spec, { final: true });

extensions/levelcode-ai/diagram/schema.js

@@ -139,6 +139,16 @@
 		1: { house: build('house'), hard: build('hard') }
 	});
 	const KNOWN_VERSIONS = Object.keys(SCHEMAS).map(Number);
+	/**
+	 * The registry entry for a version — or null. `v` is INPUT (a model wrote it, or a session file
+	 * holds it), and a plain lookup answers to names every object has: SCHEMAS["toString"] is a
+	 * function, not a schema, and SCHEMAS["__proto__"] is the prototype. So it is looked up only when
+	 * it IS one of the versions this editor reads — a number, which also means the string "1" is not
+	 * version 1: no schema declares `v`, so nothing after this would say so.
+	 */
+	function schemaFor(v) {
+		return KNOWN_VERSIONS.indexOf(v) >= 0 ? SCHEMAS[v] : null;
+	}
 
 	// ---- a JSON-Schema-subset interpreter -------------------------------------------------------
 	// Exactly the keywords build() uses, and no more: type, properties, required, items, enum,
@@ -249,5 +259,5 @@
 		return value;
 	}
 
-	return { VERSION, KNOWN_VERSIONS, SHAPES, DIRECTIONS, EDGE_STYLES, ID_RE, ID_PATTERN, HOUSE, HARD, SCHEMAS, build, check, project, typeOf, seg };
+	return { VERSION, KNOWN_VERSIONS, SHAPES, DIRECTIONS, EDGE_STYLES, ID_RE, ID_PATTERN, HOUSE, HARD, SCHEMAS, schemaFor, build, check, project, typeOf, seg };
 }));

extensions/levelcode-ai/diagram/stats.js

@@ -31,7 +31,17 @@ function empty(since) {
 	return { v: VERSION, since: since || null, calls: 0, byModel: {}, errors: {}, fixes: {}, tokens: TOKEN_BUCKETS.map(() => 0).concat([0]), renderMs: MS_BUCKETS.map(() => 0).concat([0]), rendered: 0, renderFailed: 0, flipped: 0, asciiLeaks: 0, answers: 0, linkClicks: 0, exports: {} };
 }
 const bucket = (bounds, value) => { let i = 0; while (i < bounds.length && value > bounds[i]) { i++; } return i; };
-const inc = (obj, key, cap) => { if (obj[key] !== undefined || Object.keys(obj).length < cap) { obj[key] = (obj[key] || 0) + 1; } };
+// The stores below are keyed by names that arrive from outside — a model id is whatever a provider
+// calls it. A plain `map[key]` answers to names every object has: map["constructor"] is Object, and
+// map["__proto__"] is the prototype all objects share, which a careless `++` then writes to. So a key
+// is only ever READ as an own property, and only ever WRITTEN as one (assignment to "__proto__" would
+// go to the prototype setter instead).
+const own = (map, key) => (Object.prototype.hasOwnProperty.call(map, key) ? map[key] : undefined);
+const put = (map, key, value) => { Object.defineProperty(map, key, { value, writable: true, enumerable: true, configurable: true }); return value; };
+const inc = (map, key, cap) => {
+	const cur = own(map, key);
+	if (cur !== undefined || Object.keys(map).length < cap) { put(map, key, (cur || 0) + 1); }
+};
 
 /**
  * Fold one event in.
@@ -49,10 +59,13 @@ function record(stats, ev) {
 		if (!outcome) { return s; }
 		s.calls++;
 		const model = String(ev.model || 'unknown').slice(0, 80);
-		if (!s.byModel[model] && Object.keys(s.byModel).length >= MAX_MODELS) { return s; }
-		const m = s.byModel[model] || (s.byModel[model] = { calls: 0, outcomes: {}, errors: {} });
+		let m = own(s.byModel, model);
+		if (m === undefined) {
+			if (Object.keys(s.byModel).length >= MAX_MODELS) { return s; }
+			m = put(s.byModel, model, { calls: 0, outcomes: {}, errors: {} });
+		}
 		m.calls++;
-		m.outcomes[outcome] = (m.outcomes[outcome] || 0) + 1;
+		m.outcomes[outcome] = (m.outcomes[outcome] || 0) + 1;   // (`outcome` is one of OUTCOMES: no name to collide with)
 		for (const cls of Object.keys(ev.errorClasses || {})) { if (CLASS_RE.test(cls)) { inc(s.errors, cls, MAX_CLASSES); inc(m.errors, cls, MAX_CLASSES); } }
 		for (const cls of Object.keys(ev.fixClasses || {})) { if (CLASS_RE.test(cls)) { inc(s.fixes, cls, MAX_CLASSES); } }
 		if (Number.isFinite(ev.tokens) && ev.tokens > 0) { s.tokens[bucket(TOKEN_BUCKETS, ev.tokens)]++; }

extensions/levelcode-ai/diagram/validate.js

@@ -152,7 +152,7 @@
 			return { ok: false, errors };
 		}
 		const v = spec.v === undefined ? schema.VERSION : spec.v;
-		const known = schema.SCHEMAS[v];
+		const known = schema.schemaFor(v);
 		if (!known) {
 			errors.push({ pointer: '/v', cls: 'version', message: 'unknown schema version ' + JSON.stringify(spec.v) + '. This editor reads: ' + schema.KNOWN_VERSIONS.join(', ') + '.' });
 			return { ok: false, errors };

extensions/levelcode-ai/test/diagramRepair.test.js

@@ -337,6 +337,56 @@ test('SAFETY: a spec cannot reach Object.prototype', () => {
 	for (const x of r.spec.nodes) { assert.deepStrictEqual(Object.keys(x).sort(), ['id', 'label']); }
 });
 
+test('VERSION: a crafted version goes up the ladder like any other mistake — an error for the model, then drawn as v1 with a note', () => {
+	for (const v of ['toString', '__proto__', 'constructor', 'hasOwnProperty']) {
+		const input = Object.assign(JSON.parse('{"v":' + JSON.stringify(v) + '}'), jev(), { v });
+		const first = R.prepare(input);
+		assert.strictEqual(first.status, 'errors', v);
+		assert.deepStrictEqual(first.errors.map((e) => e.cls), ['version'], v);
+		const last = R.prepare(input, { final: true });
+		assert.strictEqual(last.status, 'degraded', v);
+		assert.strictEqual(last.spec.v, 1, 'it is drawn as the version this editor reads');
+		assert.ok(last.notes.some((n) => /written for schema v/.test(n)), JSON.stringify(last.notes));
+		// and a stored record that claims such a version is read the same way, not thrown on
+		const stored = R.accept(input);
+		assert.strictEqual(stored.ok, true, v);
+		assert.strictEqual(stored.spec.v, 1);
+		assert.strictEqual(stored.spec.nodes.length, 4);
+	}
+	// a version written as a string of digits is still just a tidy-up
+	const asText = R.prepare(Object.assign(jev(), { v: '1' }));
+	assert.strictEqual(asText.spec.v, 1);
+	assert.ok(asText.status === 'ok' || asText.status === 'fixed', asText.status);
+});
+
+test('SYNONYMS: a word every object answers to is an unknown word like any other — "constructor" is not a shape', () => {
+	// The synonym tables are objects. Looked up by name alone, `constructor` finds Object itself: the
+	// spec came out with a FUNCTION for a direction, and the model was told "expected a string, got
+	// function" about a string it had written.
+	const outcomeOf = (word) => {
+		const input = jev();
+		input.direction = word; input.nodes[0].shape = word; input.edges[0].style = word;
+		const first = R.prepare(JSON.parse(JSON.stringify(input)));
+		return {
+			status: first.status,
+			errors: first.errors.map((e) => e.pointer + ' ' + e.cls),
+			fixes: first.fixes.map((f) => f.pointer + ' ' + f.cls + ' ' + f.message.split(word).join('<word>')).sort(),
+			spec: first.spec ? [first.spec.direction, first.spec.nodes[0].shape, first.spec.edges[0].style] : null
+		};
+	};
+	const unknown = outcomeOf('zigzag');
+	assert.strictEqual(unknown.status, 'fixed', 'an unknown word is drawn with the default, and says so');
+	assert.deepStrictEqual(unknown.spec, ['right', undefined, undefined]);
+	assert.deepStrictEqual(unknown.fixes, ['/direction enum "<word>" is not a direction; used "right".', '/edges/0/style enum "<word>" is not a line style; drew it solid.', '/nodes/0/shape enum "<word>" is not a shape; drew a box.']);
+	for (const word of ['constructor', 'Constructor', '__proto__', 'toString', 'hasOwnProperty', 'valueOf', 'prototype']) {
+		assert.deepStrictEqual(outcomeOf(word), unknown, word);
+	}
+	// and the real synonyms are still read
+	const real = jev(); real.direction = 'TB'; real.nodes[0].shape = 'Diamond'; real.edges[0].style = 'dotted';
+	const read = R.prepare(real);
+	assert.deepStrictEqual([read.spec.direction, read.spec.nodes[0].shape, read.spec.edges[0].style], ['down', 'decision', 'dashed']);
+});
+
 test('ROBUST: prepare() never throws and always names a status — seeded junk, both attempts', () => {
 	let seed = 20261004;
 	const rnd = () => { seed = (seed * 1664525 + 1013904223) >>> 0; return seed / 4294967296; };

extensions/levelcode-ai/test/diagramSchema.test.js

@@ -181,6 +181,22 @@ test('VERSION: an unknown version is refused by name; no version reads as v1', (
 	assert.strictEqual(none.v, undefined, 'migrate() returns a copy');
 });
 
+test('VERSION: a version is one of the NUMBERS this editor reads — "toString" is on every object, and is not a schema', () => {
+	const spec = (v) => ({ v, title: 'T', nodes: [{ id: 'a', label: 'A' }], edges: [] });
+	// (the string "1" and the list [1] are here too: both spell the key of v1, and neither is version 1)
+	for (const v of ['toString', '__proto__', 'constructor', 'hasOwnProperty', 'valueOf', '1', [1], 1.5, 0, -1, 2, true, null, [], {}]) {
+		let r;
+		assert.doesNotThrow(() => { r = V.validate(spec(v)); }, 'v = ' + JSON.stringify(v));
+		assert.deepStrictEqual(r.errors.map((e) => [e.pointer, e.cls]), [['/v', 'version']], 'v = ' + JSON.stringify(v));
+		assert.match(r.errors[0].message, /^unknown schema version .*\. This editor reads: 1\.$/);
+		assert.strictEqual(V.validate(spec(v), { tier: 'hard' }).ok, false);
+	}
+	assert.strictEqual(V.validate(spec(1)).ok, true);
+	assert.strictEqual(V.validate(spec(undefined)).ok, true, 'and a spec that names no version is read as the current one');
+	assert.strictEqual(schema.schemaFor(1), schema.SCHEMAS[1]);
+	for (const v of ['1', [1], 'toString', '__proto__', 'constructor', 2, undefined, null]) { assert.strictEqual(schema.schemaFor(v), null, JSON.stringify(v)); }
+});
+
 test('VERSION: every schema version in the registry has both tiers and still reads the example (NFR-4)', () => {
 	assert.ok(schema.KNOWN_VERSIONS.includes(schema.VERSION));
 	for (const v of schema.KNOWN_VERSIONS) {

extensions/levelcode-ai/test/diagramStats.test.js

@@ -105,6 +105,40 @@ test('BOUNDED: a flood of model ids or class names cannot grow the store without
 	assert.ok(JSON.stringify(s).length < 2000);
 });
 
+test('NAMES EVERY OBJECT ANSWERS TO: a model called "__proto__" or "constructor" is one more model — counted, and nothing else is touched', () => {
+	// A model id is whatever the user's provider calls it. Looked up carelessly in a plain object,
+	// "constructor" finds Object itself and "__proto__" finds the prototype every object shares.
+	const hostile = ['__proto__', 'constructor', 'toString', 'hasOwnProperty', 'valueOf', 'prototype'];
+	try {
+		let s = S.empty('2026-10-05');
+		for (const model of hostile) { s = S.record(s, call(model, 'clean')); s = S.record(s, call(model, 'degraded', { errorClasses: { constructor: 1, 'unknown-node': 1 } })); }
+		assert.strictEqual(({}).calls, undefined, 'the prototype every object shares was written to');
+		assert.strictEqual(/** @type {any} */ (Object).calls, undefined, 'Object itself was written to');
+		assert.strictEqual(Object.getPrototypeOf(s.byModel), Object.prototype, 'and the store is still an ordinary object');
+		assert.deepStrictEqual(Object.keys(s.byModel).sort(), hostile.slice().sort(), 'each is an entry of its own');
+		for (const model of hostile) {
+			const m = Object.getOwnPropertyDescriptor(s.byModel, model).value;
+			assert.deepStrictEqual([m.calls, m.outcomes.clean, m.outcomes.degraded], [2, 1, 1], model);
+			assert.strictEqual(m.errors.constructor, 1, 'an error class with such a name is a count too, not text glued to a function');
+		}
+		assert.strictEqual(s.calls, 12);
+		assert.deepStrictEqual(Object.getOwnPropertyDescriptor(s.errors, 'constructor').value, 6);
+		const sum = S.summarize(s);
+		assert.deepStrictEqual(sum.byModel.map((m) => m.model), hostile.slice().sort());
+		assert.ok(sum.byModel.every((m) => m.verdicts === 2 && m.firstPassValid === 50 && m.degraded === 50));
+		assert.deepStrictEqual(sum.topErrors.map((e) => [e.cls, e.count]), [['constructor', 6], ['unknown-node', 6]]);
+		// …and it survives the trip through the editor's storage, which is JSON
+		let back = JSON.parse(JSON.stringify(s));
+		assert.deepStrictEqual(Object.keys(back.byModel).sort(), hostile.slice().sort());
+		back = S.record(back, call('__proto__', 'clean'));
+		assert.strictEqual(Object.getOwnPropertyDescriptor(back.byModel, '__proto__').value.calls, 3);
+		assert.strictEqual(({}).calls, undefined);
+	} finally {
+		// if this test fails it must not take every later one down with it
+		delete (/** @type {any} */ (Object.prototype)).calls; delete (/** @type {any} */ (Object)).calls;
+	}
+});
+
 test('ROBUST: junk events are ignored; an unknown outcome is not counted; an old store starts over', () => {
 	let s = S.empty('2026-10-04');
 	for (const junk of [null, undefined, 3, 'call', {}, { type: 'call' }, { type: 'call', outcome: 'exploded' }, { type: 'render', ms: NaN }, { type: 'render', ms: -4 }, { type: 'nope' }]) { s = S.record(s, junk); }