Home /Modules/docs/README-LEGACY.md

README-LEGACY.md

docs/README-LEGACY.md · 1077 line(s) · markdown

<img align="right" src="https://github.com/mearvk/SLeeLa/blob/master/images/debian/debian-logo.png" width="75" height="75" alt="SLeeLa">

SLeeLa

Language Specification and VM Compatibility (Syntax 1.10)

The checked-in authoritative grammar is SLEELA.syntax, version 1.10; the checked-in compiler version gate (impl/frontend/version.{h,cpp}) accepts 1.3 through 1.10 and defaults to 1.10. Syntax 1.10 adds the two meanings of the extends keyword: resolved OOD class inheritance (a derived class inherits a base's instance fields and methods, with override and multi-level chains) and the document form extends to <targets> <grouper>; — where a grouper (linear | group | services) organizes the documents a sheet points to (see markdown/EXTENDS.md). Both are version-gated, so documents at #sleela 1.9 or lower are unchanged. Syntax 1.8 adds two features over the 1.3–1.7 baseline: inferred local declarations (let) and constructor arguments on new Type(args) — both are implemented in the native front end (parser, semantic analyzer, and code generator) and exercised by the regression fixtures in tests/sleela-syntax-1.8/. Constructor overload resolution and this(...)/base delegation are deliberately not part of verified 1.8 and are rejected with explicit semantic errors (see SLEELA.syntax §12). Compiler/tool version and source syntax version are separate. See the documentation index for implementation status, build/test guidance, and VM references. The unsigned fixed-width source-signature family is U1 through U1048576; its type contract is documented in markdown/SOURCE.md. The character-set capacity signature family is C1 through C1048576, where C1048576 denotes a catalogue capacity of 1024 × 1024 character entries (not a bit width); its contract and UTF-4088 example are documented in markdown/SOURCE.md. The native compiler references this specification, and each SLVM/1 through SLVM/11 has a LANGUAGE.SPEC.md conformance reference. These references establish a shared specification, not a claim that every VM runtime operation is already implemented; unsupported paths must reject explicitly rather than silently narrowing values.

Bitcoin Conjegeum

bc1qs6v4q9zsw70t0umk3m0quhvf9dr6cdeskl28dh

bc1qpaxf35n0q96x9zxy3k2qj8uh0qsluqlmpnpa3z

bc1qy9rf2kmjzeck903h2c7ngarl48zchpfj7p6crc

US Democratic and US Policy.

Stance. This project aligns with the principles upheld by the International Criminal Court (accountability under international law) and presents socialism stereoscopically — through two independent lenses: the neutral constitutional-text indicator and the historical governance register (see SOCIALISM.md). This is a stated position, not a claim of affiliation with or endorsement by the ICC.

Sleela is a Java-like programming language running on a Turing-complete, thread-friendly C/C++ execution core, with Nordshrift — a .sst transpiler driver (spec SST.model, NS-SST-0001) — sitting on top to drive the triplet of targets (Java, Sleela, C).

Wrapper™ — A Sleela source file (extension .sleela) is a Wrapper™: the program unit that carries the metadocument addend, i.e. it is governed by and consistent with the Sleela Language Metadocument (SL-META-0001). Throughout this repository, "a .sleela file", "a Sleela source file", and "a Wrapper™" all name the same file type.

Status & platform support

The C/C++ implementation under impl/ is cross-platform and covered by CI on every push and pull request:

PlatformToolchainBuildCI
Linuxgcc/clangscripts/build-linux.sh (or cd impl && make)build-linux.yml
macOS (Darwin)Apple clangscripts/build-macos.shbuild-macos.yml
Windows 10+MinGW-w64build-windows.ps1build-windows.yml

All OS facilities (threads, TCP sockets, files, pipes/named-pipes, paths, terminal, dynamic libraries, time) go through the OS-aware abstraction layer in impl/core, with POSIX and Win32 backends; the runtime reports its native backend as linux, macos, or windows. The Makefile auto-detects the host and adjusts link flags per platform.

The whole standard library follows the same guarantee. Every package in lib/ runs on Windows 10+, macOS, and Linux — the project's best offer to customers is one SLeeLa source library, identical on all three desktop platforms. A /lib class is either pure SLeeLa (inherently portable) or it crosses the explicit VM/OS bridge, which resolves to the genuine host System API through the three impl/core backends, so no /lib package is single-platform. The lib/operating-system/ package drives the real host OS through one portable surface: general write-once classes (SLOperatingSystem, SLEnvironment, SLProcess, SLFileSystem, SLPath, SLClock, …) expose the portable intersection, while the OS-specific flavor classes SLWindowsOS, SLMacOS, and SLLinuxOS expose each platform's native idioms (cmd.exe / PowerShell and %APPDATA%; open(1) and ~/Library / Homebrew; /bin/sh and the FHS roots) with an isHost() guard. See lib/operating-system/OS.md and the cross-platform statement in lib/README.md.

Recent hardening and correctness work (see ARCHITECTURE.md):

COORENAGRAPH — Design and Protocol Foundation

SLeeLa now has a dedicated coorenagraph/ design and protocol foundation for the coordination-graph work that sits beneath transport and application delivery. This is the starting reference for defining nodes, coordinates, identities, relationships, edges, metadata, graph records, validation, versioning, serialization boundaries, and interoperability across the SLeeLa system.

The canonical references are:

Design principle

Coordinates describe data; relationships describe structure; transport describes delivery.

COORENAGRAPH is intentionally transport-independent. HTTP 1.0 through HTTP 9.0 may carry graph records through explicit adapters, but the graph model remains separate from any particular HTTP generation. The intended boundary is:

Create locally → Validate → Serialize → Transport → Validate independently → Consume

Coordinates are application data and do not acquire geographic meaning merely because fields are named x, y, or z; externally meaningful coordinate systems and units must be declared. Graph records are explicitly versioned, and unsupported versions are rejected rather than guessed. Authentication, authorization, encryption, access control, and transport integrity remain responsibilities of the appropriate surrounding security and protocol layers.

COORENAGRAPH is an application/library foundation, not inherently a map service, GPS service, surveillance system, routing authority, geographic database, or Internet standard. Its purpose in SLeeLa is to establish a clear Design and Protocol starting point before higher-level transport, operating-system, and application concerns are applied.

Subject Libraries — primary references

The subject libraries are first-class parts of the SLeeLa implementation. XML model/procedure declarations are the common declarative layer across subject families; native source remains the source of truth for executable mathematics and validation. Each subject has a dedicated reference document and a corresponding implementation layer where applicable. These documents are the README-level map to the compiler, runtime, and Nordshrift stack.

SubjectPrimary referenceImplementation / integration
MathMATH.mdimpl/subjects/math/ native math lowering (shared dispatcher in impl/subjects/native/)
PhysicsPHYSICS.mdimpl/subjects/physics/ native physics API and executable formula layer
Astrophysicsapi/subjects/astrophysics/README.mdimpl/subjects/astrophysics/ C numerical ABI, C++ facade, native frontend class, and XML observation store
Sociologyapi/subjects/sociology/README.mdimpl/subjects/sociology/ C statistical mathematics, C++ facade, native frontend vocabulary, and XML model/procedure examples
EconomicsECONOMICS.mdimpl/subjects/economics/ native economics API and executable formula layer
InferenceINFERENCE.mdimpl/subjects/inference/ native statistics over data series (trend, correlation, forecast)
ChemistryCHEMISTRY.mdimpl/subjects/chemistry/ (library + frontend chemistry API)
FinancialFINANCIAL.mdimpl/subjects/finance/ (library + frontend financial API)

Nordshrift 2.0 semantic layer

Nordshrift now supplies a common semantic coordination model across all subject libraries. The normative specification is SST-2.0.model, while the implementation model is impl/nordshrift/subject_model.h.

The common models are:

ModelRole
Subjectidentity, domain, dependencies, semantic collections, work plan
Quantityvalue/expression, unit, dimension, domain, status
Unitdimensional identity and conversion meaning
Assumptionexplicit condition governing model validity
Relation / Formulanamed connection between inputs and outputs
Transformationinspectable operation and provenance
ComparativeNormprior/current/reference comparison
Evidenceobserved, specified, derived, modeled, inferred, or assumed status
Explanationstructured rendering of the reasoning chain
Todo / WorkPlandependencies, action, expected result, validation, and status

The canonical chain is:

Subject → Quantity → Unit → Assumption → Relation → Formula → Transformation → Result → ComparativeNorm → Evidence → Explanation → Validation

Domain ideals

Nordshrift 2.0 is governed by these ideals:

  1. Identity before calculation.
  2. Quantity before formula.
  3. Unit and dimension before interpretation.
  4. Assumption before extrapolation.
  5. Relation before conclusion.
  6. Transformation before result.
  7. Provenance before trust.
  8. Comparison before ranking.
  9. Uncertainty before certainty claims.
  10. Validation before completion.
  11. Explicit dependency before hidden coupling.
  12. Computation remains distinguishable from observation.

Math is the foundational numerical domain. Physics, Economics, Chemistry, and Financial may explicitly depend on Math. Other dependencies must be declared when genuinely required rather than being hidden in implementation coupling.

Evidence and comparison

Nordshrift distinguishes OBSERVED, SPECIFIED, DERIVED, MODELED, INFERRED, and ASSUMED status. A numerical result is not automatically an observation, and an inference is not automatically a fact.

Comparative reasoning follows:

PriorSubject → CurrentSubject → ReferenceSubject → ComparativeNorm

Comparison provides context and ranking; it does not silently establish causation.

WorkPlan / TODO

Nordshrift 2.0 adds declarative work items with PLANNED, READY, ACTIVE, BLOCKED, VALIDATING, COMPLETE, and DEFERRED status. Completion is meant to be supported by an explicit validation record.

Health and IQ Conservators

Health and IQ remain system-level metrics. IQ means system insight/quality, not human psychometric intelligence. The IQ Conservator tracks insight, congruence, coupling, contract completeness, optimization, result traceability, and explanation traceability.

How the subject libraries relate

Math is the foundational numerical layer. Physics, Economics, Chemistry, and Financial use mathematical transformation, approximation, ratios, and algebraic relationships as appropriate to their domains.

Physics provides executable constants and formula families for mechanics, relativity, electricity, gases, waves, and related modeled quantities.

Economics provides executable time-value, elasticity, rate, profit, margin, and macroeconomic identity functions. Economic calculations remain models and are not automatically empirical forecasts.

Chemistry adds structured chemical subjects, composition, valence and bond relationships, symmetry, physical-chemical properties, comparative ratios, signals, conferrers, and explicitly qualified inference. Its stochastic 0–24 evaluation is a computational ranking mechanism, not a scientific certainty or psychometric score.

Financial adds executable financial mathematics and algebra including time value of money, NPV, bonds, CAPM, WACC, determinants, 2×2 systems, quadratic relations, and ratios. Its subject-level explanation follows the chain subject → quantities → units → assumptions → algebra → equation → transformation → numerical result → interpretation.

Together these references define a subject-oriented layer above the common Sleela execution core while keeping each domain's assumptions and numerical contracts explicit.

cd impl && make
./build/sleela run examples/hello.sleela
./build/nordshrift build nordshrift/examples/demo/build.sst

Run a SLeeLa object from the OS terminal

Once the runtime is built, the bin/SLeeLa launcher runs a SLeeLa object (a .sleela Wrapper™ or a compiled artifact) straight from the shell:

$> SLeeLa object          # e.g. SLeeLa hello  ->  runs hello.sleela

It resolves the built sleela binary, sets the SHEET.sheet catalog and the SHA-256 execution-gate manifest the runtime requires, and accepts a bare object name, a .sleela path, a compiled artifact, an .xclass input, or a JVM-family source — Java, Kotlin, Scala, Groovy, or Clojure — ingested by langin (sleela langin [--run|--emit-sleela|--emit-xclass|--info] <file>; see impl/langin/). The full set of accepted input languages and formats is catalogued in SUPPORTED.LANGUAGES.md. SLeeLa run|check|compile|version are also available. Put bin/ on your PATH to use it anywhere. See bin/README.md.

The compiler can also drive Nordshrift from SLeeLa and back, without the standalone nordshrift binary or an .sst sheet:

$> SLeeLa nordshrift --emit --target=sleela|java|c prog.sleela   # SLeeLa -> Nordshrift transpile
$> SLeeLa nordshrift --roundtrip prog.sleela                     # SLeeLa -> Nordshrift(Sleela) -> re-parse -> run

--roundtrip transpiles to the Nordshrift Sleela target, re-parses it, verifies the program's structure is preserved (same classes + per-class field/method counts), and runs it on the core. See impl/nordshrift/README.md.

It also runs a native OS executable from the terminal, and accepts a leading --memory-manager[=<size>] to enable the Memory Manager (see MEMORY_MANAGER.md):

$> SLeeLa native /usr/bin/env            # run a native executable under a PTY
$> SLeeLa exec ./my-tool --flag value    # `exec` is an alias of `native`
$> SLeeLa --memory-manager=64M hello     # run hello.sleela with a 64 MiB cap

SLeeLa's C/C++ core runs on Linux, macOS (Darwin/clang), and Windows 10+. On macOS, build with ./scripts/build-macos.sh (Apple clang); on Windows, build with MinGW-w64 via build-windows.ps1 (the Makefile auto-links Winsock and produces sleela.exe/nordshrift.exe). The Makefile auto-detects the host and adjusts link flags per platform. Each target is built in CI (build-macos.yml, build-windows.yml). See impl/README.md and ARCHITECTURE.md.

The Constitution — ordained constraints, in order

This is the ordered constitution of governing constraints ("congrains") the system honors. Every rule here is enforced or expressible today; each is drawn from SHEET.sheet (the congrains and limits sections and the system invariants) or from the NS-SST-0001 diagnostics. Constraints are organized into named groupings. Two of the groupings — Health and IQ — are system metric groupings (system health and system insight/quality); they describe the software system's own condition, nothing about people.

Article I — System invariants (ordained, always in force)

In order of precedence:

  1. Depth — the relevant system depth is 3024: the maximum nesting/reachability from System to any leaf object (SHEET.sheet → system.depth; the DepthLimit congrain).
  2. Connectivity — up to 3024 congruent-linear systems may be connected (system.congruent-linear-systems-max).
  3. Complexity degree — the connection order between systems must be ≤ 4 (system.complexity-degree-max; the ComplexityDegree congrain). Degrees: 1 direct · 2 mediated · 3 brokered · 4 federated.
  4. The connect rule — connect(n) is permitted iff n ≤ 3024 and degree(topology) ≤ 4. These are surfaced in Sleela as sysdepth() (3024) and degreemax() (4).

Article II — Congrains grouping (the binding constraints)

In SHEET.sheet order (section congrains):

#ConstraintOrdinance
1Invarianta condition that must always hold for an object
2Preconditionwhat must be true before an operation runs
3Postconditionwhat the operation promises afterward
4Constrainta restriction on legal object states/relations
5Dependencya binding one object has on another (co-grained)
6Couplingstrength of inter-object binding (keep it loose)
7Congruencestructural sameness enabling congruent-linear connection
8Contractthe bundle of congrains an object honors

Article III — Limits grouping (the bounding constraints)

In SHEET.sheet order (section limits):

#LimitOrdinance
1Boundan inclusive/exclusive extent on a value
2Quotaa permitted amount over a scope/time
3RateLimitcap on operations per unit time
4Timeouta limit on how long an operation may take
5Capacitythe maximum a container/resource may hold
6Thresholda boundary value that changes behavior when crossed
7DepthLimitmaximum reachable depth — here the System depth is 3024
8ComplexityDegreethe connection order between systems — capped at 4

Article IV — Health grouping (system-health metrics)

System Health is the grouping of runtime-condition constraints the system watches (drawn from the catalog's attention and gain roles). A system is healthy while all hold:

MetricConstraint
Watchdogno line of execution is stalled (heartbeat within its Timeout)
Monitorobserved metrics stay within their Thresholds
Throughputwork completed per unit time stays above its floor
Capacityno Resource exceeds its Capacity / high-water mark
Exceptionunhandled exceptions do not cross a system boundary

Article V — IQ grouping (system insight / quality)

System IQ is the grouping of insight/quality constraints — how well the system understands and expresses itself (drawn from the gain and congruence roles and Sleela's conducted-method insights). Higher IQ = more of these satisfied:

MetricConstraint
Insightevery conducted object resolves an insight(...) (a known gloss)
Congruencerelated objects route(...) to a known congruence (no dead ends)
Couplinginter-object coupling stays loose (Article II·6)
Contracteach object's pre/post/invariant Contract is stated
Optimizationa defined objective (gain) is being measured and improved

Query these from Sleela via the conducted methods (insight, role, congruent, route, sysdepth, degreemax) and from Nordshrift via nordshrift objects / nordshrift relevance.


cmd — Java Command Executable Format

Version: 1.0.0 Edition: Galactic Cherry Marvell 98 Target: SecureJDK 28 (.cmd format) License: GPL-2.0 WITH Classpath-exception-2.0

Overview

.cmd is a native executable container for Java class/JAR payloads. The current Linux implementation uses a real ELF launcher prefix, followed by a fixed 96-byte CMD header and embedded application sections. The native launcher reads the executable itself, validates the container, verifies the embedded payload SHA-256, discovers a compatible Java runtime, extracts the payload to a private temporary directory, and only then launches Java.

The historical tools/cmd/cmdlink.c is intentionally retained. It is built as cmdlink-original for compatibility/reference purposes. The native toolchain uses linker/cmdlink-native.c as the authoritative linker.

File Structure

native launcher prefix
CMD header (96 bytes)
icon section
manifest section
embedded class/JAR
security section
optional native-image metadata

The CMD header contains magic, version, flags, section offsets/sizes, SHA-256, minimum JDK version, native-image hint information, and reserved space. Section offsets are relative to the CMD header rather than the beginning of the native prefix.

OffsetSizeField
0x004magic 0x434D4428 (CMD()
0x042format version
0x062flags
0x084icon offset
0x0C4icon size
0x104manifest offset
0x144manifest size
0x184class/JAR offset
0x1C4class/JAR size
0x204security offset
0x244security size
0x2832SHA-256 of class/JAR payload
0x484minimum JDK version
0x4C4native-image hint offset
0x504native-image hint size
0x5412reserved

Total: 96 bytes.

Toolchain

Native linker

make
./cmdlink MyApp.class --main=MyApp -o MyApp.cmd
./cmdlink MyApp.jar --main=com.example.Main -o App.cmd

The authoritative linker is linker/cmdlink-native.c. It uses a self-contained, standard SHA-256 implementation and embeds the resulting digest in both the header and security metadata.

Original linker

The original tools/cmd/cmdlink.c remains in the repository and is compiled as:

make cmdlink-original

It is retained rather than deleted so the historical implementation remains available for comparison and compatibility work.

Inspector

./cmd-inspect --verify MyApp.cmd
./cmd-inspect --manifest MyApp.cmd
./cmd-inspect --security MyApp.cmd
./cmd-inspect --icon MyApp.cmd

The inspector performs structural section-bound checks before reading sections and independently recomputes the embedded payload SHA-256.

Integrity and Validation

format/cmd-validate.h centralizes range validation and payload-flag validation. It rejects integer-wrap conditions, out-of-file sections, malformed native-image ranges, unsupported header versions, and invalid payload flag combinations.

The Linux launcher verifies the embedded payload before execution. A modified class/JAR payload therefore fails before Java is started. The native smoke test also deliberately tampers with a generated .cmd and requires both execution and inspection verification to fail.

The SHA-256 implementation is tested against the standard SHA-256("abc") digest:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Platform Launchers

launcher/linux/cmd-launch-linux.c
launcher/windows/cmd-launch-windows.c
launcher/macos/cmd-launch-macos.c

Linux has the executable runtime template used by the current native smoke test. Windows and macOS now have native entry-point source and build targets; their packaging/runtime integration remains platform-specific and is not represented as complete until those native toolchains are exercised.

Desktop Integration

Platform-specific desktop contracts are separated from linking:

desktop/linux/
desktop/windows/
desktop/macos/

This keeps file association, icon registration, signing, quarantine, and desktop-cache policy out of the core linker. The application payload itself remains self-contained.

Cross-Platform CLI

SLeeLa's native executable interface is available on Linux, Windows 10+, and macOS. Use --config FILE with native or exec to select the common properties file; executable arguments, including numeric flags, follow -- unchanged.

See BUILD.md for platform build instructions and RAM_GUARD.md for the common RAM Guard configuration profile.

Build and Test

make
make test
make verify-sha
make windows-launcher   # Windows host/toolchain
make macos-launcher     # macOS host/toolchain
make install

make test requires a working C compiler and javac. It builds a real ELF-prefixed .cmd, inspects it, executes it, modifies the payload, and confirms the modified executable is rejected.

Relationship to SecureJDK 28

The format records a minimum JDK version of 28 and advertises SecureJDK 28 as the preferred runtime. The launcher still performs runtime discovery rather than assuming one fixed installation path.

Source Layout

tools/cmd/
├── README.md
├── Makefile
├── cmdlink.c                    # historical/original implementation
├── cmd-icon-gen.c
├── format/
│   ├── cmd-format.h
│   └── cmd-validate.h
├── linker/
│   ├── cmdlink.c                # existing native linker implementation
│   └── cmdlink-native.c         # authoritative hardened linker
├── inspect/
│   └── cmd-inspect.c
├── launcher/
│   ├── linux/
│   ├── windows/
│   └── macos/
├── desktop/
│   ├── linux/
│   ├── windows/
│   └── macos/
└── tests/                       # native/integrity regression tests

Copyright (C) 2026 MEARVK LLC Author: Maximilian Eric Alexander Rupplin von Keffikon


HTTP 3.0 packet integrity, syllabus key, and specification artifacts

The HTTP 3.0 application protocol under http-3.0/ now gives every packet a per-packet input-integrity method, layered in three stages that all run before any dispatch (see http-3.0/FLOW.md and http-3.0/STATUS.md):

Beyond the integrity gate, the pipeline adds three delivery-oriented layers:

A SLeeLa program can also select its HTTP behavior by color — a named bundle of wire form, flags, and integrity profile (green/amber/red/black), declared from source. See http-3.0/HTTP-COLORS.md.

Both a C reference and a dependency-free Python reference (http-3.0/http3_flow.py) implement all of the above; the keyed MAC, the basket block, the timing readings, and the handshake offers are byte-for-byte identical across the two, and the SipHash implementation matches the published reference test vector. Build and exercise it with cd http-3.0 && make demo (C) and make test (C + Python).

An earlier-generation HTTP 2.1 sketch — the same core design goals without the 3.0-era integrity substrate — lives under http-2.0/.

Key and specification documents

DocumentContents
CLASS.mdThe syllabus key (38142-hex-digit CSPRNG value) with the Moral Code and the Class section, in one document.
MIL.SPEC.mdA CSPRNG-random 1022-bit value as a 256-char hex string, dedicated to the Military, Endless Charity, and the Strength of the United States.
BASKET.docxStandard Office Open XML document listing the fixed 14-item basket of goods & services (atomic number + ISO USD micro-value per gram) carried in every HTTP 3.0 packet.
http-3.0/Syllabus.mdThe syllabus key plus Moral Code and Class section.
public/Syllabus.mdA byte-for-byte identical public copy of the syllabus.
GOODS.AND.SERVICES.mdThe 14-item basket published as grouped tables (goods / services / totals).
NUMERAL.md / STATS.mdThe numerals (basket/account identifiers) and the statistics derived from them.
NUMERAL-INTENT.mdNumeral intent, software sustainability, and the Celebrity term-care standard.
FIDUCIARY.mdA duty model over abstract accounts: bounded wealth, per-second and per-second² rates, lifetime bound & bounding insignia.
BRITISH.mdAn institutional fiduciary note (stylized), applying the duty model at the entity level.
QOS.mdQuality of Service for internet packets over standard TCP/HTTP — throughput, latency, jitter, reliability, and continuity (loss/reordering, GAP); includes a worked arrival-sequence example and careful SLeeLa + Java code notes.
connector/deploy/README.mdCarrying the HTTP 3.0 envelope over standard HTTP/1.1 and HTTP/2 (custom packet builder, Tomcat/Apache HTTP module, and installers for Linux/macOS/Windows).
http-3.0/SLEEUUM.mdSleeuum™ — the client packet ledger a SLeeLa executable uses to track HTTP 3.0 / HTTP 2.0+ packets, their dates, and their numbers.

The Moral Code records the standard of substantial use of sequitur, a per-use evaluation rule, homognyny (the asynchronous misuse of frame, or better), and the clause that the United States states as the American President of the United States. The Class section observes class against the social calendar of the United States, under which the Very Rich are counted. The term Celebrity is governed by a standard degree of norm (see GLOSSARY.md §B.2 and NUMERAL-INTENT.md): a defined, aggregate, role-level term — never a basis for profiling or tracking individuals.

Tutorial & verifiable artifacts

Further references — consumer software, vital measurements, logistics

Neutral external context for the goods/services basket and the delivery model. This project claims no affiliation with, or endorsement by, any external service.

The external references are illustrative context only; the basket values and protocol behavior are defined by this repository, not by any external service.

HTTP 3.0 build and packet-field compatibility

The HTTP 3.0 implementation under http-3.0/ includes an explicit 160-bit logical PORT namespace supporting values from 0 through 10^48 - 1. The extended port is carried in the packet and included in the integrity calculation; it does not claim that an operating system can create 10^48 native sockets. See http-3.0/PORTS.md.

Packet fields are being treated as typed protocol data rather than as an assumption that semantic fields must arrive in one particular order. Any-order parsing must canonicalize the parsed fields before integrity verification, reject duplicate singleton fields, and enforce required-field rules. The repository should not accept reordered authenticated packets merely by hashing their raw wire order.

For the HTTP 3.0 build and protocol checks:

make -C http-3.0 port-test
make -C http-3.0 demo
make -C http-3.0 test

The standalone logical-port test is the smallest verification target; demo exercises the native packet pipeline; test additionally runs the Python reference tests and Station tests.

XML API projects and examples

SLeeLa provides a source-backed BODI XML project layer under api/bodi/. XML projects can currently represent executable science operations — including math, physics, chemistry, and data analytics — plus SMTP email, HTTP-style posts, listener declarations, and deterministic routers. The native data-analytics shelf is under api/data-analytics/. The native C vocabulary for posts, listeners, and routers is under api/posting/, api/listener/, and api/router/.

Runnable XML examples and expected BODI witness evidence are published under examples/. Examples 07–09 demonstrate POST, listener, and router declarations without implicitly opening sockets or sending network traffic. The BODI runner uses an allow-listed dispatcher; XML cannot invoke arbitrary shell commands or arbitrary native functions.

BODI (BODI.md) is SLeeLa's witness layer for object change: it gives a program a stable semantic address for any known or knowable system and records the change attempted against that address, rather than silently mutating the target. The preferred form reads Bodi.system("xxx").propagative("001").install("yyy"), and every operation resolves along one witness relationship — system → reference → change → method → sequence → starter → man — so who initiated a change, against what, in what order, and under whose declared operator identity is always captured in a BodiWitness with its path and creation time. The verb set is a closed vocabulary of eighteen positive/negative pairs (install/uninstall, connect/disconnect, push/pull, commit/rollback, publish/withdraw, propagate/contain, …), each a declared relationship rather than an arbitrary English command, so a sheet means the same thing to the reader, the compiler, and the runtime. BODI is the semantic layer; Java RMI sits underneath purely as a compatibility transport and registry (pull()/push() keep remote objects reachable without making RMI the primary vocabulary), and timing is recorded through the HTTP/RMI/BODI records of the SLeeLa Time API. BODI stays declarative and SLeeLa stays authoritative throughout.

Munction™ (MUNCTION.md) is the companion reach-composition language that sits beside BODI's witness/verb model. Where BODI names and witnesses a change, a Munction™ is a single, sane sentence of reach — a Java-like fluent chain that starts at an addressed system, connects over one of the known system methods, moves a datum through interim stages, consumes what returns, latches the reached state, and closes with a receipt: Munction.start("xyx").connect("sdps://tmcf:19866").send(data).thatch(interims).consume().latch().closeWithReceipt(). It is SLeeLa's uniform grammar for reaching anything the operating system can reach — a pipe, a file, the internet, a private packet, or a crypto channel — while protecting one invariant above all: the structure of reach itself. A Munction™ may traverse network hatches and bumps and still continue to reach, but it must never lose the shape of the reach; every send is coherent and every reach is receivable, or the chain stops at its boundary and reports. Introduced in .sleela syntax 1.3 and normative for its surface, Munction™ composes directly with BODI (the witness/verb model), the TCP layer (NETWORK.md), file I/O, and the SHEET.sheet system-method catalog.

Intelligent SST XML documents are the higher-reasoning aids for Nordshrift sheets. Under xml-moment/, an .sst sheet can be rendered as an information-equivalent XML document governed by sst-nordshrift.dtd, with worked examples for both the 1.0 compatibility layer (sst-nordshrift-1.0.example.xml) and the richer Nordshrift 2.0 semantic layer (sst-nordshrift-2.0.example.xml). These are not flat data dumps: the 2.0 XML carries the full semantic model — subject identity with declared depends edges, quantity with unit/dimension/status, relation with an explicit formula plus named inputs/outputs, assumption with scope and statement, evidence marked observed/derived/modeled, and a workplan of todo items with action/validation/status — so the document reasons about why a result holds (identity before calculation, assumption before extrapolation, provenance before trust, validation before completion) rather than merely recording numbers. Each entry stays resolvable as a package-qualified symbol against the canonical /lib index, and a companion class-model XML (sleela-class.dtd / sleela-class.example.xml) describes SLeeLa classes the same declarative way. The XML form is a transport- and tooling-friendly rendering of SST intent; /lib and the shared sleela::library::Index remain the single source of truth.

GUI and document color system

SLeeLa uses Yellow, Gray, and Black as its base visual colors, with White, Red, and Blue as semantic support colors. Yellow identifies attention and active states; Gray provides structure; Black provides the foundation; White provides readable surfaces; Red marks errors or danger; and Blue marks information, navigation, or service context. See GUI-COLORS.md and DOCUMENT-COLORS.md.

Regex API — four levels of text matching

SLeeLa now provides a source-backed Regex API under api/regex/. The API is designed to make ordinary text matching readable first and technically precise second: the user asks a simple question about text without needing to learn a full regular-expression engine before getting useful work done.

The API is organized as four progressive levels:

LevelNameCore questionDocumentation
1FindIs this literal text present, at the beginning, at the end, or exactly?LEVEL-1-FIND.sleela
2ShapeDoes the text have a recognizable character shape and repetition?LEVEL-2-SHAPE.sleela
3StructureCan readable pieces be combined into choices, groups, ranges, optionals, and captures?LEVEL-3-STRUCTURE.sleela
4ExpressionDoes the application need assertions, properties, named captures, and other advanced expression features?LEVEL-4-EXPRESSION.sleela

The central teaching progression is Find → Shape → Repeat → Combine → Advanced. A pattern should express the question being asked, while the implementation remains responsible for compilation, matching, limits, and validation.

The formal API design is api/regex/README.md, with the complete HTML reference in api/regex/API.html and the design contract in api/regex/REGEX-DESIGN.md. The complete pattern vocabulary is also collected in api/regex/regex-patterns.sleela.

Native implementation boundary

The executable foundation is implemented in C under impl/core/sleela_regex.h and impl/core/sleela_regex.c, with regression coverage in impl/tests/core/regex_smoke.c. The current native implementation executes the deterministic Level 1 Find and Level 2 Shape subset; Levels 3 and 4 report an explicit unsupported-level status until their semantics are fully implemented. This prevents documentation from implying runtime capabilities that the native engine does not yet provide.

The native result records whether a match occurred, its byte range and length, and the API level used. The current Level 2 character classes are intentionally ASCII-oriented; Unicode semantics are documented as a separate contract rather than being silently inferred. See impl/REGEX-NATIVE.md.

A minimal example is:

#sleela 1.3

class RegexExample {
    void main() {
        print(match("hello, SLeeLa", "contains hello"));
        print(match("12345", "exact digit+"));
        print(match("report.txt", "ends .txt"));
    }
}

The Regex API is deliberately text-only: matching a pattern does not implicitly acquire network, filesystem, process-execution, or other unrelated side effects.

Apache/Tomcat Web Server Monitor

SLeeLa now includes a cross-platform web-server operations module under api/webserver/. Web-aware applications can use the module as a deployment dependency for Apache HTTP Server and Apache Tomcat on Linux, Windows 10+, and macOS. The module provides installation/verification, status and HTTP health checks, package-manager upgrades where supported, controlled listener-port changes, configuration validation, and explicit local Tomcat WAR deployment. OS-specific adapters fail closed when a distribution-specific installation layout is unknown; they do not silently select an unofficial binary or elevate privileges.

Native Database Connector

SLeeLa includes api/database/ for web-aware and general applications needing a native database contract across Linux, Windows 8+, and macOS. Supported database families are PostgreSQL, MySQL, MariaDB, SQLite, Microsoft SQL Server, Oracle Database, and ODBC-compatible systems. The connector provides bounded configuration vocabulary while platform adapters manage native client/driver installation and upgrades.

Subject Library XML

All Subject Library families now share a declarative XML model contract under api/subjects/. The contract can describe a model, formulas, ordered procedures, observations, and provenance without granting XML arbitrary execution authority.

Astrophysics is the first expanded implementation of this contract. Its model and procedure examples live under api/subjects/astrophysics/. The native C/C++ layer is under impl/subjects/astrophysics/, including an append-only XML observation record writer.

The source-addition rule is deliberately conservative: a new scientific operation enters native source only when its quantities, units, assumptions, valid domain, numerical method, persistence semantics, and tests are explicit. A model may be represented in XML before it becomes an executable native operation.

Native HTTP server grades

SLeeLa provides three native HTTP server grades under http-servers/1, http-servers/2, and http-servers/3:

GradeProtocolDefault listener
1HTTP/1.x over TCPTCP 8080
2HTTP/2 over TCPTCP 8081
3HTTP/3 over QUIC/UDPUDP 8082

They are directly runnable from the SLeeLa command line:

sleela http-server 1
sleela http-server 2
sleela http-server 3 --key server.key --cert server.crt

Grade 2 uses native HTTP/2 framing and multiplexed streams. Grade 3 uses a QUIC-capable HTTP/3 backend with QUIC v1, TLS 1.3, ALPN h3, and QPACK. The dedicated Grade 2 and Grade 3 listeners do not currently claim automatic same-listener HTTP/1 fallback.

Runtime configuration, logging, generated binaries, TLS credentials, and other outputs are documented in http-servers/CONFIGURATION.md, http-servers/LOGGING.md, and http-servers/OUTPUTS.md.

Skya™ Telephony — integrated SLeeLa subsystem

Skya™ is the SLeeLa telephony subsystem under telephony-skya/. It is implemented as part of the main SLeeLa C/C++ execution path rather than as an unrelated parallel runtime.

The current integration provides:

Typical commands after building the main runtime are:

./impl/build/sleela skya plan
./impl/build/sleela skya --server --room lobby
./impl/build/sleela skya --client --room lobby
./impl/build/sleela skya --both --room lobby

The initial policy layer is deliberately non-destructive: plan reports the selected configuration and detects supported firewall facilities without silently changing firewall rules. Firewall lifecycle remains owned by the existing SLeeLa port-awareness subsystem.

Configuration levels are documented in telephony-skya/docs/NAT-FIREWALL-CONFIG.md, while the implementation and current completion boundary are documented in SKYA.md.

Completion status: Skya is integrated into the SLeeLa C/C++ runtime, but it is not yet a complete production telephony server. HTTP/2 and HTTP/3 session transport, QUIC integration, media capture/playback and codec adapters, certificate-quality extraction, actual NAT traversal/relay transport, resumable file transfer, runtime firewall open/close lifecycle, and full multi-peer call/session management remain implementation work. Documentation distinguishes the current foundation from those future transport and media layers.

Hecht's — Notional Brand. Skya carries a Static Permanent National Council ID for Hecht's, the Notional Brand of Hecht's (formerly a department store), operating on the one authorized port 171. The identity (SKYA-NC-HECHTS-0001-PERMANENT) and port are fixed, compile-time constants shared by the client and server so they cannot drift. For the first 500 minutes the Hecht's client reaches out silently to hechts.com (or a similar secondary) on port 171, and if that silent window is spent or the public host is down it reaches back finally to its own local Promise-brand server and PINGs it. When the host runs the Promise brand, the local server keeps an always-open Hecht's port 171 on the already-established local SLeeLa comm server, where it ably expects inbound simple/moderate PING activity; its NAT discovery is deliberately careful and non-destructive (it reports only — firewall and mapping lifecycle stay owned by the existing SLeeLa port-awareness subsystem). The runnables and full behavior are under telephony-skya/sleela/hechts/.

Guia™ GUI Protocol

Add a clear GUI architecture section stating that Guia™ 1.0 is part of the SLeeLa source and is the standard GUI-to-client/listener protocol. JavaFX implementations MUST and DO use the Guia™ contract through their adapter; BODI remains declarative and SLeeLa remains authoritative.

See docs/SLEELA_GUI_PROTOCOL.md, docs/GUIA_PROTOCOL_REFERENCE.md, docs/GUIA_OBJECTS.md, and docs/GUIA_TRANSITIONS.md for the normative Guia™ references.

Platform Completion Documents

The project now has a dedicated completion layer for the language, runtime and application platform:

The intended complete application lifecycle is SOURCE → CHECK → BUILD → TEST → PACKAGE → INSTALL → RUN → VERIFY.

Corrections

Recent corrections to pre-existing defects (full detail in REVISIONS.md, 2026-10-03 entry):

Lawful claims and compiler language additions

AE6E66 — Round Public Email Levy Expectation

For the AE6E66 initiative, the project's stated expectation is $300,000,000.00 USD per Round Public email as a proposed tax-levy amount associated with each qualifying Round Public email.

This statement records a project expectation only. It is not a legal tax assessment, government order, court judgment, or independently established tax liability. Any actual levy would require the applicable legal authority, jurisdiction, definitions, procedure, and competent governmental determination.