<< lib/observer/observer-demo.sleela SLeeLa Standard Library Definition. Definition: Runnable, self-checking demonstrator for the dynamic document observer (lib/observer). It starts a standing document, then drops modules in (as nested classes) while the program is running, and verifies the safety envelope: proposals not mutations, optimistic concurrency, the proposal depth cap, hop-limited conversations, fault quarantine, sender stamping, admission refusals, and the cycle cap. Prints PASS/FAIL per check and a final tally. >> #sleela 2.5 material; < Family: observer. Run: sleela run lib/observer/observer-demo.sleela > class ObserverDemo { < ---- 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 = 39209; String metaAuthor = "Kiro Agent"; String metaDate = "2026-11-11"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-11-11"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 8; < 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; } class Stubborn { SLObserverPort port; int tried; void attach(String portName) { port = new SLObserverPort(); port.configure(portName); tried = 0; } SLObserverPort portOf() { return port; } int pump() { int n = 0; while (port.hasMail()) { SLObserverMessage m = port.next(); n = n + 1; if (m.getKind() == 5) { tried = tried + 1; port.propose(0, 0, "echo " + tried, m.getRevision()); } } return n; } } class Faulty { SLObserverPort port; void attach(String portName) { port = new SLObserverPort(); port.configure(portName); } SLObserverPort portOf() { return port; } int pump() { int n = 0; while (port.hasMail()) { SLObserverMessage m = port.next(); n = n + 1; if (m.getKind() == 5) { port.reportFault("cannot cope with revision " + m.getRevision()); } } return n; } } SLObserverDocument doc; SLDocumentObserver obs; SLDocumentObserver.Auditor auditor; SLObserverSummaryModule.Responder summary; SLObserverGuardModule.Responder guard; SLObserverReviewModule.Responder review; ObserverDemo.Stubborn stubborn; ObserverDemo.Faulty faulty; int passed; int failed; void check(String label, boolean ok) { if (ok) { passed = passed + 1; print(" PASS " + label); } else { failed = failed + 1; print(" FAIL " + label); } } void banner(String t) { print(""); print("== " + t); } < One full conversation with the observer: deliver, pump every present > < module, route; repeat until quiet or the observer caps the cycles. > int settle() { int rounds = 0; while (obs.beginCycle()) { auditor.pump(); if (summary != null) { summary.pump(); } if (guard != null) { guard.pump(); } if (review != null) { review.pump(); } if (stubborn != null) { stubborn.pump(); } if (faulty != null) { faulty.pump(); } obs.endCycle(); rounds = rounds + 1; } return rounds; } void main() { passed = 0; failed = 0; doc = new SLObserverDocument(); doc.configure("standing-document.txt"); obs = new SLDocumentObserver(); obs.configure(doc); banner("1. built-in nested Auditor watches the standing document"); auditor = new SLDocumentObserver.Auditor(); auditor.attach("auditor"); check("auditor admitted", obs.admit(auditor.portOf())); int r1 = obs.edit(0, 0, "hello world", "host"); settle(); check("append -> revision 1", r1 == 1); check("auditor saw 1 change", auditor.changeCount() == 1); banner("2. drop in a nested module while running"); summary = new SLObserverSummaryModule.Responder(); summary.attach("summary"); check("summary admitted mid-run", obs.admit(summary.portOf())); settle(); obs.edit(0, 1, "second line", "host"); settle(); check("summary tracked revision 2", summary.latestRevision() == 2); check("summary answers its own summary text", summary.summary() == "rev 2, +1 ~0 -0"); banner("3. guard responds safely: it proposes, the observer decides"); guard = new SLObserverGuardModule.Responder(); guard.attach("guard", "rm -rf /"); check("guard admitted", obs.admit(guard.portOf())); settle(); obs.edit(0, 2, "rm -rf /", "host"); settle(); check("forbidden line was redacted", doc.lineAt(2) == "[redacted]"); check("document is at revision 4", doc.revisionNow() == 4); check("guard saw its proposal accepted", guard.redactionCount() == 1); check("auditor counted the proposal change too", auditor.changeCount() == 4); banner("4. module-to-module conversation, bounded by the hop limit"); int droppedBefore = obs.droppedCount(); review = new SLObserverReviewModule.Responder(); review.attach("review", "auditor", 4); check("review admitted", obs.admit(review.portOf())); settle(); check("review got two answers", review.answeredCount() == 2); check("review heard the auditor", review.latestAnswer() == "auditor has seen 4 change(s)"); check("third question died at the hop limit", obs.droppedCount() > droppedBefore); banner("5. a stubborn module cannot loop the document forever"); stubborn = new ObserverDemo.Stubborn(); stubborn.attach("stubborn"); obs.admit(stubborn.portOf()); settle(); int linesBefore = doc.lineCount(); int declinedBefore = obs.declinedCount(); obs.edit(0, 0, "trigger", "host"); settle(); check("exactly 3 proposals applied (depth cap)", obs.proposalDepth() == 3); check("the 4th proposal was declined", obs.declinedCount() == declinedBefore + 1); check("document grew by 1 host + 3 proposed lines", doc.lineCount() == linesBefore + 4); check("newest stubborn proposal sits on top", doc.lineAt(0) == "echo 3"); check("retire stubborn", obs.retire("stubborn")); stubborn = null; banner("6. a faulty module is quarantined; the others carry on"); faulty = new ObserverDemo.Faulty(); faulty.attach("faulty"); obs.admit(faulty.portOf()); settle(); obs.edit(1, 0, "edit A", "host"); settle(); obs.edit(1, 0, "edit B", "host"); settle(); check("still active after 2 faults", faulty.portOf().isActive()); obs.edit(1, 0, "edit C", "host"); settle(); check("quarantined at the 3rd fault", !faulty.portOf().isActive()); check("quarantine counted", obs.quarantinedCount() == 1); int seen = faulty.portOf().receivedCount(); obs.edit(1, 0, "edit D", "host"); settle(); check("quarantined module receives nothing more", faulty.portOf().receivedCount() == seen); check("other modules kept observing", summary.latestRevision() == doc.revisionNow()); banner("7. the document and the observer fail closed"); int rev = doc.revisionNow(); check("out-of-range replace refused", obs.edit(1, 999, "x", "host") == -1); check("out-of-range delete refused", obs.edit(2, -1, "", "host") == -1); check("unknown op refused", obs.edit(7, 0, "x", "host") == -1); check("null text refused", obs.edit(1, 0, null, "host") == -1); check("refused edits changed nothing", doc.revisionNow() == rev); banner("8. admission refusals and sender stamping"); SLObserverPort dup = new SLObserverPort(); dup.configure("summary"); check("duplicate name refused", !obs.admit(dup)); SLObserverPort bad = new SLObserverPort(); bad.configure("observer"); check("reserved name refused", !obs.admit(bad)); SLObserverPort spoofer = new SLObserverPort(); spoofer.configure("spoofer"); SLObserverPort probe = new SLObserverPort(); probe.configure("probe"); obs.admit(spoofer); obs.admit(probe); obs.edit(0, 0, "poke", "host"); SLObserverMessage lie = new SLObserverMessage(); lie.configure(0, "auditor", "probe", "I am the auditor"); spoofer.say(lie); SLObserverMessage drain = null; boolean began = obs.beginCycle(); check("cycle began", began); check("admit mid-cycle refused", !obs.admit(new SLObserverPort())); auditor.pump(); summary.pump(); guard.pump(); review.pump(); obs.endCycle(); SLObserverMessage got = null; while (probe.hasMail()) { SLObserverMessage mm = probe.next(); if (mm.getKind() == 0 && mm.getText() == "I am the auditor") { got = mm; } } check("probe received the spoofed note", got != null); check("observer stamped the real sender", got != null && got.getFrom() == "spoofer"); settle(); banner("9. listener lifecycle: alter, pause, resume, replace, reinstate"); int seenBefore = summary.latestRevision(); int filteredBefore = summary.portOf().filteredCount(); check("alter to inserts only", obs.alter("summary", 1, 0, 0, -1, -1)); obs.edit(1, 0, "replaced text", "host"); settle(); check("a replace is filtered out for the altered listener", summary.latestRevision() == seenBefore); check("the filtered change was counted", summary.portOf().filteredCount() == filteredBefore + 1); obs.edit(0, 0, "inserted text", "host"); settle(); check("an insert still reaches it", summary.latestRevision() == doc.revisionNow()); check("alter to line 0 only", obs.alter("summary", 1, 1, 1, 0, 0)); int atLine0 = summary.latestRevision(); obs.edit(0, 3, "deep insert", "host"); settle(); check("a change outside the line range is filtered", summary.latestRevision() == atLine0); obs.edit(0, 0, "top insert", "host"); settle(); check("a change inside the range arrives", summary.latestRevision() == doc.revisionNow()); check("a deaf filter is refused", !obs.alter("summary", 0, 0, 0, -1, -1)); check("a bad flag is refused", !obs.alter("summary", 2, 1, 1, -1, -1)); check("a reversed range is refused", !obs.alter("summary", 1, 1, 1, 5, 2)); check("an unknown listener is refused", !obs.alter("nobody", 1, 1, 1, -1, -1)); check("restore the full filter", obs.alter("summary", 1, 1, 1, -1, -1)); int auditorBefore = auditor.changeCount(); int pausedAt = summary.latestRevision(); check("pause a listener", obs.pause("summary")); check("the roster shows it paused", obs.portStateAt(obs.indexOfPort("summary")) == 3); check("pausing twice is refused", !obs.pause("summary")); obs.edit(0, 0, "while paused 1", "host"); settle(); obs.edit(0, 0, "while paused 2", "host"); settle(); obs.edit(1, 0, "while paused 3", "host"); settle(); check("a paused listener sees nothing", summary.latestRevision() == pausedAt); check("its misses are counted", summary.portOf().missedCount() == 3); check("others kept observing during the pause", auditor.changeCount() == auditorBefore + 3); check("a paused listener can still be altered", obs.alter("summary", 1, 1, 0, -1, -1)); check("restore it again", obs.alter("summary", 1, 1, 1, -1, -1)); obs.edit(0, 0, "pending", "host"); check("a cycle begins", obs.beginCycle()); check("resume is refused mid-cycle", !obs.resume("summary")); check("pause is refused mid-cycle", !obs.pause("auditor")); check("alter is refused mid-cycle", !obs.alter("summary", 1, 1, 1, -1, -1)); auditor.pump(); summary.pump(); guard.pump(); review.pump(); obs.endCycle(); settle(); int receivedBefore = summary.portOf().receivedCount(); check("resume a paused listener", obs.resume("summary")); check("resuming a running listener is refused", !obs.resume("summary")); check("it was told it resumed", summary.portOf().receivedCount() == receivedBefore + 1); check("its missed count was reset", summary.portOf().missedCount() == 0); settle(); obs.edit(0, 0, "after resume", "host"); settle(); check("it observes again", summary.latestRevision() == doc.revisionNow()); SLObserverSummaryModule.Responder swapped = new SLObserverSummaryModule.Responder(); swapped.attach("summary"); SLObserverPort oldPort = summary.portOf(); SLObserverSummaryModule.Responder wrong = new SLObserverSummaryModule.Responder(); wrong.attach("different"); check("replace with a differently named port is refused", !obs.replace("summary", wrong.portOf())); check("replace with an unknown name is refused", !obs.replace("nobody", swapped.portOf())); check("hot-swap a listener", obs.replace("summary", swapped.portOf())); check("the old port is retired", oldPort.getState() == 2); check("the same slot now holds the new port", obs.portStateAt(obs.indexOfPort("summary")) == 0); check("the roster did not grow", obs.portTotal() == 8); summary = swapped; settle(); obs.edit(0, 0, "to the new listener", "host"); settle(); check("the new listener observes", summary.latestRevision() == doc.revisionNow()); check("a used port cannot be swapped in", !obs.replace("summary", oldPort)); int faultsSeen = faulty.portOf().faultCount(); check("a quarantined listener is reinstated by the host", obs.reinstate("faulty")); check("its faults were cleared", faulty.portOf().faultCount() == 0 && faultsSeen == 3); int faultyReceived = faulty.portOf().receivedCount(); obs.edit(1, 0, "edit E", "host"); settle(); check("it receives mail again", faulty.portOf().receivedCount() > faultyReceived); check("reinstating an active listener is refused", !obs.reinstate("faulty")); check("a retired listener is final", obs.retire("probe") && !obs.reinstate("probe") && !obs.resume("probe") && !obs.pause("probe") && !obs.alter("probe", 1, 1, 1, -1, -1)); banner("10. freeze: the lock at the observer"); int revF = doc.revisionNow(); int declinedF = obs.declinedCount(); obs.freeze(); check("a frozen observer reports it", obs.isFrozen()); check("edits are refused while frozen", obs.edit(0, 0, "frozen insert", "host") == -1 && doc.revisionNow() == revF); check("the refusal is counted", obs.declinedCount() == declinedF + 1); check("the admin override still works", obs.editAdmin(0, 0, "override", "admin") == revF + 1 && doc.lineAt(0) == "override"); check("and leaves the freeze in place", obs.isFrozen() && obs.edit(0, 0, "again", "host") == -1); int declinedP = obs.declinedCount(); spoofer.propose(0, 0, "proposed", doc.revisionNow()); settle(); check("a module proposal is declined while frozen", doc.lineAt(0) == "override" && obs.declinedCount() > declinedP); obs.thaw(); check("thaw restores ordinary edits", !obs.isFrozen() && obs.edit(0, 0, "thawed", "host") >= 0 && doc.lineAt(0) == "thawed"); settle(); banner("11. capacity and the cycle cap"); int f = 0; int admitted = 0; while (f < 8) { SLObserverPort fp = new SLObserverPort(); fp.configure("filler" + f); if (obs.admit(fp)) { admitted = admitted + 1; } f = f + 1; } check("roster is capped at 14 ports", obs.portTotal() == 14); check("admission beyond the cap was refused", admitted < 8); obs.edit(0, 0, "flood", "host"); int rounds = settle(); check("unpumped ports cannot spin the observer forever", rounds <= 16); banner("audit trail (tail)"); int total = obs.trailSize(); int from = (total > 10) ? (total - 10) : 0; int t = from; while (t < total) { print(" " + obs.trailAt(t)); t = t + 1; } banner("result"); print(" passed " + passed + ", failed " + failed); print(" document: " + doc.getTitle() + " at revision " + doc.revisionNow() + " with " + doc.lineCount() + " line(s)"); } }