fix(xsd): make Phase 3d content-model ingest idempotent

Compositors / child_edges / group_edges have no natural unique key
(a complexType can hold sibling sequences/choices), so the prior pass
unconditionally inserted on every run, doubling rows on the second
ingest. CT_Tbl content lookups against a re-ingested DB returned 0
rows because the order_index ranges no longer matched what queries
expected.

Switching to delete-and-rewrite per profile at the start of pass 3:
  DELETE FROM xsd_compositors  WHERE profile_id = ?
  DELETE FROM xsd_group_edges  WHERE profile_id = ?
xsd_child_edges cleans up automatically via FK CASCADE on
compositor_id. Inheritance / symbols / memberships stay upsert-only
since they have natural keys.

Idempotency test now also asserts compositor / child-edge / group-ref
counts in the DB match the first-run insert counts after a second run.

Verified: two consecutive `bun run xsd:ingest` against the WML closure
both produce 585 compositors / 2098 child edges / 161 group refs and
the DB ends at exactly those counts.

Author: caiopizzol

scripts/ingest-xsd/ingest.ts

@@ -195,6 +195,16 @@ export async function ingestSchemaSet(opts: IngestSchemaSetOptions): Promise<Ing
 		// emit xsd_compositors / xsd_child_edges / xsd_group_edges. Local element
 		// declarations are deduped under (owner-vocab, name, element); cross-CT
 		// reuse of a local name collapses to one symbol.
+		//
+		// Idempotency strategy: content-model rows have no natural unique key
+		// (a single complexType can hold multiple sibling compositors of the same
+		// kind), so we delete-and-rewrite per profile. xsd_child_edges FK on
+		// xsd_compositors with ON DELETE CASCADE handles child_edges cleanup.
+		// Assumes one source per profile, which holds today; revisit when
+		// multiple sources contribute to the same profile.
+		await sql`DELETE FROM xsd_compositors WHERE profile_id = ${profileId}`;
+		await sql`DELETE FROM xsd_group_edges WHERE profile_id = ${profileId}`;
+
 		for (const decls of parseResult.declarationsByQName.values()) {
 			for (const decl of decls) {
 				if (decl.kind !== "complexType" && decl.kind !== "group") continue;

tests/ingest-xsd/ingest.test.ts

@@ -175,15 +175,25 @@ test("ingest is idempotent: re-running adds no new symbols/edges", async () => {
 	expect(second.symbolsExisting).toBeGreaterThan(0);
 	expect(second.profileMembershipsInserted).toBe(0);
 	expect(second.inheritanceEdgesInserted).toBe(0);
+	// Content-model passes use delete-and-rewrite, so insert counts equal
+	// the first run on every re-run; DB row counts stay stable.
+	expect(second.compositorsInserted).toBe(first.compositorsInserted);
+	expect(second.childEdgesInserted).toBe(first.childEdgesInserted);
+	expect(second.groupRefsInserted).toBe(first.groupRefsInserted);
 
 	// Row counts unchanged between first and second runs.
 	const [c1] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_symbols`;
 	const [c2] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_symbol_profiles`;
 	const [c3] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_inheritance_edges`;
+	const [c4] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_compositors`;
+	const [c5] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_child_edges`;
+	const [c6] = await db.sql`SELECT COUNT(*)::int AS c FROM xsd_group_edges`;
 	expect(c1.c).toBe(first.symbolsInserted);
-	// One membership per symbol per profile.
 	expect(c2.c).toBe(first.profileMembershipsInserted);
 	expect(c3.c).toBe(first.inheritanceEdgesInserted);
+	expect(c4.c).toBe(first.compositorsInserted);
+	expect(c5.c).toBe(first.childEdgesInserted);
+	expect(c6.c).toBe(first.groupRefsInserted);
 });
 
 test("ingest writes compositors and child edges for nested content models", async () => {