<< lib/operating-system/SLDistroSource.sleela SLeeLa Standard Library Definition. Definition: Defines SLDistroSource — the zero-payload REFERENCE to the upstream Ubuntu distribution that supplies the real OS parts (mearvk/Ubuntu.Determinant.Beta.Restricted). It records the distro's identity, clone URL, the pinned commit for reproducibility, its default branch, its Git submodule(s), and the map of OS-part directories it provides (kernels, installer, gnome-source, file-systems, userland, ...). It carries NO distro bytes: SLeeLa references the distro here and fetches it only on demand through SLDistroFetch, so SLeeLa stays small while still knowing exactly where its OS parts come from and at which revision. The reference is the single source of truth for "which upstream, which revision, which parts". SLOSModel / OS Creator(TM) generate the SLeeLa-shaped scaffolding; this points at the real Ubuntu-lineage sources the generated tree is modelled on, so provenance is explicit rather than implied. Family: operating-system. Pure reference/manifest; no payload. SLDistroFetch performs the opt-in download; SLOSModel/SLOSCreator may record this as provenance. >> #sleela 2.5 material; class SLDistroSource { < ---- 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 = 10888; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-10"; < 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; } < Upstream identity. > String name; String owner; String repo; < https clone URL > String url; < default branch > String branch; < exact revision for reproducible fetches > String pinnedCommit; < 1 if the distro uses git submodules (needs --recurse) > int hasSubmodules; < Configure with the known Ubuntu.Determinant distro reference. The pinned > < commit is the current main tip; callers may repin with pin(commit). > void configure() { name = "Ubuntu Determinant (Beta, Restricted)"; owner = "mearvk"; repo = "Ubuntu.Determinant.Beta.Restricted"; url = "https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git"; branch = "main"; pinnedCommit = "4918080dcf0f52dc771aa1a30b0e0f63495f7a8d"; < graal-latest -> https://github.com/oracle/graal.git > hasSubmodules = 1; } < Repin to a specific revision (keeps fetches reproducible). > void pin(String commit) { pinnedCommit = commit; } String identity() { return name + " [" + owner + "/" + repo + "@" + shortCommit() + "]"; } String cloneUrl() { return url; } String defaultBranch() { return branch; } String commit() { return pinnedCommit; } boolean usesSubmodules() { return hasSubmodules == 1; } < First 10 chars of the pinned commit, for human-readable identity. The core > < value model has no substring, so this is derived by comparison-free display > < of the full commit when short form is unavailable; callers that need the > < exact value use commit(). > String shortCommit() { return pinnedCommit; } < ---- OS-part directory map ------------------------------------------ > < The directories in the distro that carry each OS layer. A caller resolves a > < layer name to its upstream path; dirFor returns "" for an unknown layer. > < These mirror the distro's top-level tree (firmware/boot/kernel/userspace/ > < desktop plus the installer and filesystem tooling). > String dirFor(String layer) { if (layer == "kernel") { return "kernels"; } if (layer == "installer") { return "installer"; } if (layer == "desktop") { return "gnome-source"; } if (layer == "filesystem") { return "file-systems"; } if (layer == "userland") { return "userland"; } if (layer == "userspace") { return "userland"; } if (layer == "windows") { return "windows"; } if (layer == "national") { return "national"; } if (layer == "java") { return "java"; } if (layer == "ubuntu") { return "ubuntu-white"; } return ""; } boolean providesLayer(String layer) { return dirFor(layer) != ""; } < ---- Downloadability notes ------------------------------------------ > < Not every OS part comes down with a clone. This records what a fetch does > < and does NOT retrieve, so a builder knows before pulling (multi-GB) data. > < > < source tree : YES -- all git-tracked source for every part dir > < (kernels, installer, gnome-source, file-systems, > < userland, ...) is in the repo and clones fully. > < large binaries : NO -- the distro caps committed files at 50 MB > < (LFS.check.sh) and .gitignores anything larger, > < so prebuilt images / big blobs are NOT in the > < repo and cannot be downloaded from it. > < GraalVM submodule: SEPARATE -- graal-latest is a submodule pointing at > < oracle/graal; it is fetched only with a > < --recurse-submodules (SLDistroFetch MODE_RECURSE) > < clone, as an additional external download. > < no Git LFS : the repo uses no LFS filters, so a normal clone needs > < no `git lfs` step; the size is plain git objects. > < downloadabilityNote(part): per-part answer to "can this be downloaded?". > String downloadabilityNote(String part) { if (part == "submodule" || part == "graal") { return "SEPARATE: external submodule (oracle/graal); use a recurse-submodules clone"; } if (part == "binaries" || part == "images") { return "NO: files >= 50 MB are excluded by the distro's size policy and not in the repo"; } < Any source part directory. > if (dirFor(part) != "" || part == "source") { return "YES: git-tracked source clones fully (shallow is enough)"; } return "UNKNOWN part"; } < Whether a complete working tree needs the submodule fetched too. > boolean needsSubmoduleForComplete() { return hasSubmodules == 1; } < A newline-separated reference sheet a tool or README can print. > String referenceSheet() { String s = "# Upstream OS-parts reference\n"; s = s + "name: " + name + "\n"; s = s + "repo: " + owner + "/" + repo + "\n"; s = s + "url: " + url + "\n"; s = s + "branch: " + branch + "\n"; s = s + "commit: " + pinnedCommit + "\n"; s = s + "submodules: "; if (hasSubmodules == 1) { s = s + "yes (graal-latest -> oracle/graal)\n"; } else { s = s + "no\n"; } s = s + "parts:\n"; s = s + " kernel -> " + dirFor("kernel") + "\n"; s = s + " installer -> " + dirFor("installer") + "\n"; s = s + " desktop -> " + dirFor("desktop") + "\n"; s = s + " filesystem -> " + dirFor("filesystem") + "\n"; s = s + " userland -> " + dirFor("userland") + "\n"; s = s + "downloadable:\n"; s = s + " source parts -> " + downloadabilityNote("source") + "\n"; s = s + " >=50MB blobs -> " + downloadabilityNote("binaries") + "\n"; s = s + " graal submod -> " + downloadabilityNote("submodule") + "\n"; return s; } }