yarramate 1.19.0 → 1.19.1

package/dist/compiler.js

@@ -428,63 +428,95 @@ function compileWorkspaceResolved(parsed) {
                 continue;
             }
             const resolvedConceptKinds = new Map(parentProfile.conceptKinds);
-            for (const [index, kind] of value.conceptKinds.entries()) {
-                if (resolvedConceptKinds.has(kind.id)) {
-                    const position = positionFor(['conceptKinds', index, 'id']);
-                    profileDiagnostics.push({
-                        severity: 'error',
-                        code: 'YM409',
-                        message: `Concept kind "${kind.id}" conflicts with an inherited kind`,
-                        path: input.path,
-                        pointer: `/conceptKinds/${index}/id`,
-                        line: position.line,
-                        column: position.col,
-                    });
-                    continue;
-                }
-                const parent = conceptKindByIdentity.get(kind.parent);
-                if (parent === undefined) {
-                    const position = positionFor(['conceptKinds', index, 'parent']);
-                    profileDiagnostics.push({
-                        severity: 'error',
-                        code: 'YM407',
-                        message: `Concept parent "${kind.parent}" is not available`,
-                        path: input.path,
-                        pointer: `/conceptKinds/${index}/parent`,
-                        line: position.line,
-                        column: position.col,
-                    });
-                    continue;
-                }
-                // OntoClean: an anti-rigid kind cannot subsume a rigid one. The
-                // parent's lineage is the full ancestor chain, and subsumption is
-                // transitive, so an unannotated kind sitting in between does not
-                // launder the violation (ADR 0078).
-                if (kind.rigidity === 'rigid') {
-                    const antiRigidAncestor = parent.lineage.find((ancestor) => conceptKindByIdentity.get(ancestor)?.rigidity === 'anti-rigid');
-                    if (antiRigidAncestor !== undefined) {
-                        const position = positionFor(['conceptKinds', index, 'rigidity']);
+            // A profile is a SET of kind declarations, so a kind whose parent is
+            // declared below it resolves like any other (#470). This used to be one
+            // pass in declaration order, which made a forward reference
+            // indistinguishable from a parent that does not exist - and `YM407` says
+            // "not available", so an author went looking for a missing kind while the
+            // file in front of them already declared it three lines down.
+            //
+            // Rounds until one adds nothing. Everything that compiled before compiles
+            // now and resolves on the first round, because parent-first was the only
+            // order that worked.
+            let pendingKinds = [...value.conceptKinds.entries()];
+            for (;;) {
+                const deferred = [];
+                for (const [index, kind] of pendingKinds) {
+                    if (resolvedConceptKinds.has(kind.id)) {
+                        const position = positionFor(['conceptKinds', index, 'id']);
                         profileDiagnostics.push({
                             severity: 'error',
-                            code: 'YM413',
-                            message: `Rigid concept kind "${kind.id}" specializes anti-rigid kind "${antiRigidAncestor}"; nothing is essentially of an anti-rigid kind, so parent "${kind.id}" under an entity kind, or drop its "rigid" annotation`,
+                            code: 'YM409',
+                            message: `Concept kind "${kind.id}" conflicts with an inherited kind`,
                             path: input.path,
-                            pointer: `/conceptKinds/${index}/rigidity`,
+                            pointer: `/conceptKinds/${index}/id`,
                             line: position.line,
                             column: position.col,
                         });
                         continue;
                     }
+                    const parent = conceptKindByIdentity.get(kind.parent);
+                    if (parent === undefined) {
+                        // Might resolve in a later round. Whether it never resolves at all
+                        // is decided once the rounds stop, not here.
+                        deferred.push([index, kind]);
+                        continue;
+                    }
+                    // OntoClean: an anti-rigid kind cannot subsume a rigid one. The
+                    // parent's lineage is the full ancestor chain, and subsumption is
+                    // transitive, so an unannotated kind sitting in between does not
+                    // launder the violation (ADR 0078).
+                    if (kind.rigidity === 'rigid') {
+                        const antiRigidAncestor = parent.lineage.find((ancestor) => conceptKindByIdentity.get(ancestor)?.rigidity === 'anti-rigid');
+                        if (antiRigidAncestor !== undefined) {
+                            const position = positionFor(['conceptKinds', index, 'rigidity']);
+                            profileDiagnostics.push({
+                                severity: 'error',
+                                code: 'YM413',
+                                message: `Rigid concept kind "${kind.id}" specializes anti-rigid kind "${antiRigidAncestor}"; nothing is essentially of an anti-rigid kind, so parent "${kind.id}" under an entity kind, or drop its "rigid" annotation`,
+                                path: input.path,
+                                pointer: `/conceptKinds/${index}/rigidity`,
+                                line: position.line,
+                                column: position.col,
+                            });
+                            continue;
+                        }
+                    }
+                    const resolved = {
+                        identity: `${identity}#${kind.id}`,
+                        aspect: parent.aspect,
+                        layer: kind.layer ?? parent.layer,
+                        lineage: [...parent.lineage, `${identity}#${kind.id}`],
+                        ...(kind.rigidity === undefined ? {} : { rigidity: kind.rigidity }),
+                    };
+                    resolvedConceptKinds.set(kind.id, resolved);
+                    conceptKindByIdentity.set(resolved.identity, resolved);
                 }
-                const resolved = {
-                    identity: `${identity}#${kind.id}`,
-                    aspect: parent.aspect,
-                    layer: kind.layer ?? parent.layer,
-                    lineage: [...parent.lineage, `${identity}#${kind.id}`],
-                    ...(kind.rigidity === undefined ? {} : { rigidity: kind.rigidity }),
-                };
-                resolvedConceptKinds.set(kind.id, resolved);
-                conceptKindByIdentity.set(resolved.identity, resolved);
+                // No round can help what the last one could not.
+                if (deferred.length === 0 || deferred.length === pendingKinds.length) {
+                    pendingKinds = deferred;
+                    break;
+                }
+                pendingKinds = deferred;
+            }
+            // What survived every round names a parent that never arrives. Two
+            // causes, and they are different problems for the author: the parent is
+            // declared nowhere, or it is in a cycle with this kind and neither can
+            // ever have a lineage.
+            const unresolvableIds = new Set(pendingKinds.map(([, kind]) => `${identity}#${kind.id}`));
+            for (const [index, kind] of pendingKinds) {
+                const position = positionFor(['conceptKinds', index, 'parent']);
+                profileDiagnostics.push({
+                    severity: 'error',
+                    code: 'YM407',
+                    message: unresolvableIds.has(kind.parent)
+                        ? `Concept parent "${kind.parent}" cannot resolve: it is in a parent cycle with "${kind.id}", so neither kind has a lineage`
+                        : `Concept parent "${kind.parent}" is not available`,
+                    path: input.path,
+                    pointer: `/conceptKinds/${index}/parent`,
+                    line: position.line,
+                    column: position.col,
+                });
             }
             const resolvedRelationshipKinds = new Map(parentProfile.relationshipKinds);
             for (const [index, kind] of value.relationshipKinds.entries()) {

package/dist/visual-app-lib/editor.js

@@ -99301,75 +99301,87 @@ function KS(e) {
 				});
 				continue;
 			}
-			let f = new Map(d.conceptKinds);
-			for (let [e, t] of s.conceptKinds.entries()) {
-				if (f.has(t.id)) {
-					let n = u([
-						"conceptKinds",
-						e,
-						"id"
-					]);
-					l.push({
-						severity: "error",
-						code: "YM409",
-						message: `Concept kind "${t.id}" conflicts with an inherited kind`,
-						path: r.path,
-						pointer: `/conceptKinds/${e}/id`,
-						line: n.line,
-						column: n.col
-					});
-					continue;
-				}
-				let n = a.get(t.parent);
-				if (n === void 0) {
-					let n = u([
-						"conceptKinds",
-						e,
-						"parent"
-					]);
-					l.push({
-						severity: "error",
-						code: "YM407",
-						message: `Concept parent "${t.parent}" is not available`,
-						path: r.path,
-						pointer: `/conceptKinds/${e}/parent`,
-						line: n.line,
-						column: n.col
-					});
-					continue;
-				}
-				if (t.rigidity === "rigid") {
-					let i = n.lineage.find((e) => a.get(e)?.rigidity === "anti-rigid");
-					if (i !== void 0) {
-						let n = u([
+			let f = new Map(d.conceptKinds), p = [...s.conceptKinds.entries()];
+			for (;;) {
+				let e = [];
+				for (let [t, n] of p) {
+					if (f.has(n.id)) {
+						let e = u([
 							"conceptKinds",
-							e,
-							"rigidity"
+							t,
+							"id"
 						]);
 						l.push({
 							severity: "error",
-							code: "YM413",
-							message: `Rigid concept kind "${t.id}" specializes anti-rigid kind "${i}"; nothing is essentially of an anti-rigid kind, so parent "${t.id}" under an entity kind, or drop its "rigid" annotation`,
+							code: "YM409",
+							message: `Concept kind "${n.id}" conflicts with an inherited kind`,
 							path: r.path,
-							pointer: `/conceptKinds/${e}/rigidity`,
-							line: n.line,
-							column: n.col
+							pointer: `/conceptKinds/${t}/id`,
+							line: e.line,
+							column: e.col
 						});
 						continue;
 					}
+					let i = a.get(n.parent);
+					if (i === void 0) {
+						e.push([t, n]);
+						continue;
+					}
+					if (n.rigidity === "rigid") {
+						let e = i.lineage.find((e) => a.get(e)?.rigidity === "anti-rigid");
+						if (e !== void 0) {
+							let i = u([
+								"conceptKinds",
+								t,
+								"rigidity"
+							]);
+							l.push({
+								severity: "error",
+								code: "YM413",
+								message: `Rigid concept kind "${n.id}" specializes anti-rigid kind "${e}"; nothing is essentially of an anti-rigid kind, so parent "${n.id}" under an entity kind, or drop its "rigid" annotation`,
+								path: r.path,
+								pointer: `/conceptKinds/${t}/rigidity`,
+								line: i.line,
+								column: i.col
+							});
+							continue;
+						}
+					}
+					let o = {
+						identity: `${c}#${n.id}`,
+						aspect: i.aspect,
+						layer: n.layer ?? i.layer,
+						lineage: [...i.lineage, `${c}#${n.id}`],
+						...n.rigidity === void 0 ? {} : { rigidity: n.rigidity }
+					};
+					f.set(n.id, o), a.set(o.identity, o);
 				}
-				let i = {
-					identity: `${c}#${t.id}`,
-					aspect: n.aspect,
-					layer: t.layer ?? n.layer,
-					lineage: [...n.lineage, `${c}#${t.id}`],
-					...t.rigidity === void 0 ? {} : { rigidity: t.rigidity }
-				};
-				f.set(t.id, i), a.set(i.identity, i);
+				if (e.length === 0 || e.length === p.length) {
+					p = e;
+					break;
+				}
+				p = e;
+			}
+			let m = new Set(p.map(([, e]) => `${c}#${e.id}`));
+			for (let [e, t] of p) {
+				let n = u([
+					"conceptKinds",
+					e,
+					"parent"
+				]);
+				l.push({
+					severity: "error",
+					code: "YM407",
+					message: m.has(t.parent) ? `Concept parent "${t.parent}" cannot resolve: it is in a parent cycle with "${t.id}", so neither kind has a lineage` : `Concept parent "${t.parent}" is not available`,
+					path: r.path,
+					pointer: `/conceptKinds/${e}/parent`,
+					line: n.line,
+					column: n.col
+				});
 			}
-			let p = new Map(d.relationshipKinds);
+			let h = new Map(d.relationshipKinds);
 			for (let [e, t] of s.relationshipKinds.entries()) {
-				if (p.has(t.id)) {
+				if (h.has(t.id)) {
 					let n = u([
 						"relationshipKinds",
 						e,
@@ -99432,13 +99444,13 @@ function KS(e) {
 					sourceAspects: t.sourceAspects ?? n.sourceAspects,
 					targetAspects: t.targetAspects ?? n.targetAspects
 				};
-				p.set(t.id, a), o.set(a.identity, a);
+				h.set(t.id, a), o.set(a.identity, a);
 			}
 			i.set(c, {
 				identity: c,
 				lineage: [...d.lineage, c],
 				conceptKinds: f,
-				relationshipKinds: p
+				relationshipKinds: h
 			}), t = !0;
 		}
 		if (!t) {

package/docs/NATIVE-DOCUMENT.md

@@ -409,7 +409,7 @@ marked anywhere.
 | `YM1xx` | YAML parsing | `YM101` malformed YAML |
 | `YM2xx` | Document structure | `YM201` JSON Schema violation |
 | `YM3xx` | Identity and references | `YM301` duplicate local ID; `YM302` unresolved concept reference; `YM303` duplicate document ID; `YM304` unresolved owner or attestation authority; `YM305` unresolved constraint; `YM306` duplicate constraint ID; `YM307` unresolved architecture state; `YM308` unresolved subject reference; `YM309` duplicate reference ID; `YM310` unresolved distinct-from reference; `YM311` self-referential distinct-from; `YM312` unresolved succession reference; `YM313` self-referential succession; `YM314` cross-document duplicate ID; `YM315` unresolved or doubly-bound pattern part |
-| `YM4xx` | Profile conformance | `YM401` unknown concept kind; `YM402` unknown relationship kind; `YM403` unavailable profile; `YM404` incompatible endpoint; `YM405` misplaced controlled field; `YM406` unavailable parent profile; `YM407`/`YM408` unavailable semantic parent; `YM409`/`YM410` inherited-name collision; `YM411` duplicate profile; `YM412` broadened constraint; `YM413` rigid kind specializing an anti-rigid one; `YM414` mixed relationship kinds on one junction; `YM415` relationship forbidden by a declared constraint; `YM416` unbound required part; `YM417` part of the wrong kind; `YM418` relationship contradicting a pattern's wiring; `YM419` parts on a kind with no pattern, or an undeclared slot; `YM420` derived wiring or expansion id already taken; `YM421` macro edge with an unbound landing slot |
+| `YM4xx` | Profile conformance | `YM401` unknown concept kind; `YM402` unknown relationship kind; `YM403` unavailable profile; `YM404` incompatible endpoint; `YM405` misplaced controlled field; `YM406` unavailable parent profile; `YM407`/`YM408` unavailable semantic parent, or one in a parent cycle; `YM409`/`YM410` inherited-name collision; `YM411` duplicate profile; `YM412` broadened constraint; `YM413` rigid kind specializing an anti-rigid one; `YM414` mixed relationship kinds on one junction; `YM415` relationship forbidden by a declared constraint; `YM416` unbound required part; `YM417` part of the wrong kind; `YM418` relationship contradicting a pattern's wiring; `YM419` parts on a kind with no pattern, or an undeclared slot; `YM420` derived wiring or expansion id already taken; `YM421` macro edge with an unbound landing slot |
 | `YM5xx` | Claim consistency | `YM501` competing whole-part claims; `YM502` cyclic state ordering; `YM503` relationship present without an endpoint; `YM504` cyclic succession |
 | `YM6xx` | Adapter mapping integrity | `YM601` unknown native subject; `YM602` subject type mismatch; `YM603` duplicate native mapping; `YM604` duplicate external mapping; `YM605` duplicate versioned mapping |
 | `YM7xx` | Workspace resolution | `YM701` unsafe pattern; `YM702` unmatched pattern; `YM703` cross-category file |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {