SLHotLinkMatrix.sleela
lib/hotlink/SLHotLinkMatrix.sleela · 251 line(s) · sleela
<< lib/hotlink/SLHotLinkMatrix.sleela
SLeeLa Standard Library Definition.
Definition: Defines SLHotLinkMatrix — the backing model of the hot-link
matrix: which types of class may be hot-loaded, and which types may be
connected to which. Everything is validated as it is added and a bad row or
link is refused (fail closed). seal() freezes the matrix; SLHotLinker only
accepts a sealed one. standard() seeds the matrix declared in
hotlink-matrix.xml, and tools/validate_hotlink_matrix.py checks the two
agree. >>
#sleela 3.0
material;
artifact;
pure;
gasoline;
< Family: hotlink. 32 rows, 64 links. The type graph is acyclic apart from >
< a contain self-link (a nested model may contain nested models). >
class SLHotLinkMatrix {
< ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
<< Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
or catalog can read and (where appropriate) override this record.
Values are faithful to the subject's real origin where publicly known. >>
String metaVersion = "1.0.0";
int metaId = 39222;
String metaAuthor = "Kiro Agent";
String metaDate = "2026-11-11";
String metaCopyright = "SLeeLa project";
String metaTrademark = "none";
String metaCorporation = "none";
< metaOrigin: National | <nation> | International | Galactic >
String metaOrigin = "International";
String metaBirthDate = "2026-11-11";
< metaScienceRating: maturity/robustness on a 1..10 scale >
int metaScienceRating = 9;
< metaNationalSchedule: a real, citable instrument or "none" >
String metaNationalSchedule = "none";
String getMetaVersion() { return metaVersion; }
void setMetaVersion(String v) { metaVersion = v; }
int getMetaId() { return metaId; }
void setMetaId(int v) { metaId = v; }
String getAuthor() { return metaAuthor; }
void setAuthor(String v) { metaAuthor = v; }
String getDate() { return metaDate; }
void setDate(String v) { metaDate = v; }
String getCopyright() { return metaCopyright; }
void setCopyright(String v) { metaCopyright = v; }
String getTrademark() { return metaTrademark; }
void setTrademark(String v) { metaTrademark = v; }
String getCorporation() { return metaCorporation; }
void setCorporation(String v) { metaCorporation = v; }
String getOrigin() { return metaOrigin; }
void setOrigin(String v) { metaOrigin = v; }
String getBirthDate() { return metaBirthDate; }
void setBirthDate(String v) { metaBirthDate = v; }
int getScienceRating() { return metaScienceRating; }
void setScienceRating(int v) { metaScienceRating = v; }
String getNationalSchedule() { return metaNationalSchedule; }
void setNationalSchedule(String v) { metaNationalSchedule = v; }
SLHotLinkRow[] rows;
int rowCount;
String[] edgeFrom;
String[] edgeTo;
String[] edgeMode;
int[] edgeFanout;
int edgeCount;
int frozen;
int refused;
void configure() {
rows = new SLHotLinkRow[32];
edgeFrom = new String[64]; edgeTo = new String[64]; edgeMode = new String[64];
edgeFanout = new int[64];
int i = 0;
while (i < 64) { edgeFrom[i] = ""; edgeTo[i] = ""; edgeMode[i] = ""; edgeFanout[i] = 0; i = i + 1; }
rowCount = 0; edgeCount = 0; frozen = 0; refused = 0;
}
int rowTotal() { return rowCount; }
int linkTotal() { return edgeCount; }
int refusedCount() { return refused; }
boolean isSealed() { return frozen == 1; }
void seal() { frozen = 1; }
int indexOf(String typeId) {
int i = 0;
while (i < rowCount) {
SLHotLinkRow r = rows[i];
if (r.getId() == typeId) { return i; }
i = i + 1;
}
return -1;
}
SLHotLinkRow find(String typeId) {
int i = indexOf(typeId);
if (i < 0) { return null; }
return rows[i];
}
SLHotLinkRow rowAt(int i) {
if (i < 0 || i >= rowCount) { return null; }
return rows[i];
}
< The type that realises an SLIntegrationKind ordinal, or "" if none. >
String typeForKind(int kind) {
int i = 0;
while (i < rowCount) {
SLHotLinkRow r = rows[i];
if (r.coversKind(kind)) { return r.getId(); }
i = i + 1;
}
return "";
}
boolean oneOf2(String v, String a, String b) { return v == a || v == b; }
boolean oneOf3(String v, String a, String b, String c) { return v == a || v == b || v == c; }
< Add a row. Refused (returns false, nothing changes) when sealed, when a >
< field is out of vocabulary or range, or when the combination is unsafe: >
< native code must require the authorizer and a host-pinned digest, and a >
< compartment row must name a kind range that no other row already covers. >
boolean addRow(String typeId, String code, String instance, String link,
int trust, int cap, int first, int last, int authorizer,
String digest, String state) {
if (frozen == 1 || rowCount >= 32) { refused = refused + 1; return false; }
if (typeId == null || typeId == "" || indexOf(typeId) >= 0) { refused = refused + 1; return false; }
if (!oneOf2(code, "linked", "native")) { refused = refused + 1; return false; }
if (!oneOf2(instance, "hot", "cold")) { refused = refused + 1; return false; }
if (!oneOf3(link, "port", "compartment", "native-abi")) { refused = refused + 1; return false; }
if (!oneOf2(digest, "none", "host-pinned")) { refused = refused + 1; return false; }
if (!oneOf3(state, "verified", "declared", "unverified")) { refused = refused + 1; return false; }
if (trust < 0 || trust > 2 || cap < 1 || cap > 64) { refused = refused + 1; return false; }
if (authorizer != 0 && authorizer != 1) { refused = refused + 1; return false; }
if (code == "native") {
if (authorizer != 1 || digest != "host-pinned" || link != "native-abi") {
refused = refused + 1; return false;
}
}
if (link == "native-abi" && code != "native") { refused = refused + 1; return false; }
if (link == "compartment") {
if (first < 0 || last > 16 || first > last) { refused = refused + 1; return false; }
int k = first;
while (k <= last) {
if (typeForKind(k) != "") { refused = refused + 1; return false; }
k = k + 1;
}
} else {
if (first != -1 || last != -1) { refused = refused + 1; return false; }
}
SLHotLinkRow r = new SLHotLinkRow();
r.configure(typeId, code, instance, link, trust, cap, first, last, authorizer, digest, state);
rows[rowCount] = r;
rowCount = rowCount + 1;
return true;
}
int edgeIndex(String from, String to) {
int i = 0;
while (i < edgeCount) {
if (edgeFrom[i] == from && edgeTo[i] == to) { return i; }
i = i + 1;
}
return -1;
}
< Does the type graph already reach `to` from `from`? (self-links ignored) >
boolean typeReaches(String from, String to) {
int n = rowCount;
int[] seen = new int[32];
int[] stack = new int[32];
int i = 0;
while (i < 32) { seen[i] = 0; stack[i] = 0; i = i + 1; }
int sp = 0;
int start = indexOf(from);
if (start < 0) { return false; }
stack[sp] = start; sp = sp + 1; seen[start] = 1;
while (sp > 0) {
sp = sp - 1;
int cur = stack[sp];
SLHotLinkRow cr = rows[cur];
if (cr.getId() == to) { return true; }
int e = 0;
while (e < edgeCount) {
if (edgeFrom[e] == cr.getId() && edgeTo[e] != cr.getId()) {
int nx = indexOf(edgeTo[e]);
if (nx >= 0 && seen[nx] == 0 && sp < 32) { seen[nx] = 1; stack[sp] = nx; sp = sp + 1; }
}
e = e + 1;
}
}
return false;
}
< Add a permitted connection. Both ends must be hot types. Refused when >
< sealed, unknown, duplicate, out of range, cycle-making, or a self-link >
< in any mode other than contain. >
boolean addEdge(String from, String to, String mode, int fanout) {
if (frozen == 1 || edgeCount >= 64) { refused = refused + 1; return false; }
SLHotLinkRow a = find(from);
SLHotLinkRow b = find(to);
if (a == null || b == null) { refused = refused + 1; return false; }
if (!a.isHot() || !b.isHot()) { refused = refused + 1; return false; }
if (!oneOf3(mode, "feed", "subscribe", "contain")) { refused = refused + 1; return false; }
if (fanout < 1 || fanout > 14) { refused = refused + 1; return false; }
if (edgeIndex(from, to) >= 0) { refused = refused + 1; return false; }
if (from == to) {
if (mode != "contain") { refused = refused + 1; return false; }
} else {
if (typeReaches(to, from)) { refused = refused + 1; return false; }
}
edgeFrom[edgeCount] = from; edgeTo[edgeCount] = to;
edgeMode[edgeCount] = mode; edgeFanout[edgeCount] = fanout;
edgeCount = edgeCount + 1;
return true;
}
boolean edgeAllowed(String from, String to) { return edgeIndex(from, to) >= 0; }
int fanoutLimit(String from, String to) {
int e = edgeIndex(from, to);
return (e >= 0) ? edgeFanout[e] : 0;
}
String edgeModeOf(String from, String to) {
int e = edgeIndex(from, to);
return (e >= 0) ? edgeMode[e] : "";
}
< Seed the matrix declared in hotlink-matrix.xml and seal it. Returns the >
< number of seeds that were refused (0 when everything is consistent). >
int standard() {
addRow("observer.responder", "linked", "hot", "port", 1, 14, -1, -1, 0, "none", "verified");
addRow("vi.nested-model", "linked", "hot", "compartment", 2, 4, 0, 0, 0, "none", "verified");
addRow("vi.onion", "linked", "hot", "compartment", 1, 8, 1, 1, 0, "none", "verified");
addRow("vi.engineering-bay", "linked", "hot", "compartment", 1, 8, 2, 2, 0, "none", "verified");
addRow("vi.trial", "linked", "hot", "compartment", 1, 8, 3, 3, 0, "none", "verified");
addRow("vi.newton-tray", "linked", "hot", "compartment", 1, 8, 4, 4, 0, "none", "verified");
addRow("vi.plain", "linked", "hot", "compartment", 1, 16, 5, 16, 0, "none", "verified");
addRow("native.extension", "native", "hot", "native-abi", 2, 2, -1, -1, 1, "host-pinned", "unverified");
addRow("extends.module", "linked", "cold", "port", 1, 14, -1, -1, 0, "none", "declared");
addEdge("observer.responder", "vi.plain", "feed", 4);
addEdge("observer.responder", "vi.onion", "feed", 4);
addEdge("observer.responder", "vi.engineering-bay", "feed", 4);
addEdge("observer.responder", "vi.trial", "feed", 4);
addEdge("observer.responder", "vi.newton-tray", "feed", 4);
addEdge("vi.engineering-bay", "vi.trial", "feed", 2);
addEdge("vi.trial", "vi.newton-tray", "feed", 2);
addEdge("vi.nested-model", "vi.nested-model", "contain", 2);
addEdge("vi.nested-model", "vi.plain", "contain", 4);
addEdge("vi.nested-model", "vi.engineering-bay", "contain", 4);
addEdge("native.extension", "observer.responder", "feed", 2);
seal();
return refused;
}
}