<< lib/vm/vmsharp/VMSharpUsbMedia.sleela SLeeLa Standard Library Definition. Definition: VMSharp(TM) USB boot-media MODEL. It describes initializing VMSharp from a USB device: the developer runs `make` to stage the VMSharp files (and `make install` to write them to a USB the user explicitly designates), the computer's firmware (BIOS/MBR or UEFI) then loads those files from the USB, and VMSharp starts in either of its configured options (limited Desktop, or install an OS from OS.Sensitivity.III). It also carries the engineering-preference knob the brief named -- a labelled build profile selectable as "sequitur", "iq", or "havingness" -- so a team's engineering preference is recorded on the media build. The preference is a descriptive label on the staged media; it does not change the honesty boundary or the fail-closed gates. Honesty boundary: this is a declarative model and the staging plan. It writes nothing to any USB, invokes no firmware, and boots nothing; the real staging and the explicit, user-confirmed USB write are performed by the per-OS Makefiles under usb/ (make / make install) which refuse to run without an explicitly designated device. A real bootable VMSharp image is produced only by the pinned OS Creator toolchain. Authored for the User MEARVK LLC, respectful of United States law and of the persons and groupings of peoples it concerns. Family: vm. >> #sleela 3.0 material; class VMSharpUsbMedia { < ---- 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 = 38014; String metaAuthor = "Max Rupplin 2026; George Soros a Kindness 2507+"; String metaDate = "2026-11-05"; String metaCopyright = "MEARVK LLC"; String metaTrademark = "VMSharp"; String metaCorporation = "MEARVK LLC"; < metaOrigin: National | | International | Galactic > String metaOrigin = "United States"; String metaBirthDate = "2026-11-05"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 7; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "UEFI Specification; USB Mass Storage Class"; 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; } < ---- the three OS brands whose Makefiles stage/install the media ---- > int BRAND_LINUX = 1; int BRAND_WINDOWS = 2; int BRAND_MACOS = 3; < ---- the engineering-preference profiles ---- > String PREF_SEQUITUR = "sequitur"; String PREF_IQ = "iq"; String PREF_HAVINGNESS = "havingness"; String engineeringPreference = "sequitur"; String usbDevice = ""; boolean deviceDesignated = false; boolean staged = false; boolean written = false; void configure() { engineeringPreference = "sequitur"; usbDevice = ""; deviceDesignated = false; staged = false; written = false; } < Set the engineering preference; unknown values fall back to sequitur. > void setEngineeringPreference(String pref) { if (pref == PREF_SEQUITUR || pref == PREF_IQ || pref == PREF_HAVINGNESS) { engineeringPreference = pref; } else { engineeringPreference = PREF_SEQUITUR; } } String getEngineeringPreference() { return engineeringPreference; } < The per-brand Makefile that stages and installs the media. > String makefileForBrand(int brand) { if (brand == BRAND_LINUX) { return "usb/Makefile.linux"; } if (brand == BRAND_WINDOWS) { return "usb/Makefile.windows"; } if (brand == BRAND_MACOS) { return "usb/Makefile.macos"; } return "usb/Makefile"; } < `make` stages the VMSharp files into a staging dir (no device needed). > void stage() { staged = true; } boolean isStaged() { return staged; } << Designate the USB device to install onto. Recording a designation does NOT write it; the actual write is the guarded `make install` step. >> void designateDevice(String device) { usbDevice = device; deviceDesignated = device != ""; } String getUsbDevice() { return usbDevice; } boolean isDeviceDesignated() { return deviceDesignated; } << Mark the media written (the per-OS `make install` reports success). This is fail-closed: it requires the files staged AND a device explicitly designated; writing never proceeds on assumption. >> boolean markWritten() { if (!staged) { return false; } if (!deviceDesignated) { return false; } written = true; return true; } boolean isWritten() { return written; } < The media is bootable-ready only after it is staged AND written. > boolean isBootReady() { return staged && written; } << The ordered media-to-boot procedural: stage with make, install to the designated USB with make install, let firmware load it, and start VMSharp in the chosen option. A boot/install screen walks these; this model lists and gates them. >> SLList bootMediaPlan() { SLList out = new SLList(); out.add("make-stage-vmsharp-files"); out.add("designate-usb-device"); out.add("make-install-to-usb"); out.add("set-firmware-boot-order-usb-first"); out.add("firmware-loads-vmsharp-from-usb"); out.add("vmsharp-desktop-up"); out.add("choose-option-desktop-or-os-sensitivity"); return out; } int bootMediaSteps() { SLList p = bootMediaPlan(); return p.length(); } << The firmware interface that loads from USB for an architecture, mirroring the bootloader model: x64 -> UEFI, x86 -> BIOS/MBR. >> String firmwareFor(String arch) { if (arch == "x64") { return "UEFI (USB, removable media path)"; } if (arch == "x86") { return "BIOS/MBR (USB legacy boot)"; } return "unsupported"; } < A one-line media summary. > String summary() { return "VMSharp USB media: pref=" + engineeringPreference + " device=" + usbDevice + " staged=" + staged + " written=" + written; } }