slbuild.c
build/native-builder/slbuild.c · 493 line(s) · c
/* ==========================================================================
* slbuild — SLeeLa OS-specific native builder/installer.
* Max Rupplin · MEARVK LLC · 2026
*
* WHAT IT IS
* A single native binary, compiled per-OS by build/native-builder/
* make-slbuild.sh, that orchestrates the SLeeLa main-package build and
* installation with the calm, beautiful presentation of the shell
* clean-install. It is the compiled front door to the same real process:
* 1) build the integrity-gated core products (sleela, sleelvac, nordshrift)
* 2) stage the main package (standard library minus the excluded trees)
* 3) install user-local (or to --prefix), link the binaries
* 4) print a formal "Record of Build" attestation
*
* WHY A BINARY
* The build/install logic lives in a real, OS-aware executable so it can be
* shipped and run directly on each platform, rather than requiring a shell
* script interpreter. It detects the host OS at runtime (operating-system/
* identity model) and adapts paths and the build command accordingly.
*
* USAGE
* slbuild [--prefix DIR] [--plain] [--no-color] [--build-only] [--dry-run]
* [--repo DIR] [-h|--help]
*
* --prefix DIR install root (default: $HOME/.local/sleela)
* --build-only build the core products, do not stage/install
* --dry-run print what would happen; do not build or install
* --plain ASCII only, no color (also honors NO_COLOR / non-TTY)
* --repo DIR repository root (default: auto-detected from argv[0])
*
* The EXACT, verbatim compiler/linker output is captured to a timestamped
* log; the screen shows a calm, summarized progress report.
* ========================================================================== */
/* Enable POSIX/GNU library surface (realpath, setenv, popen, fileno,
* localtime_r, PATH_MAX) under -std=c11, which otherwise hides them. */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#endif
#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <libgen.h>
/* Some platforms do not expose PATH_MAX in <limits.h>; provide a safe default. */
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
#define SL_PRODUCT "SLeeLa"
#define SL_RELEASE "1.3.2-pro"
#define SL_SYNTAX "1.0 - 3.0"
#define SL_TAGLINE "THE NOW. THE INGREDIENT."
/* ---- host OS identity (operating-system/ model: National -> ... ) -------- */
static const char *host_os(void) {
#if defined(_WIN32) || defined(_WIN64)
return "Windows";
#elif defined(__APPLE__)
return "macOS";
#elif defined(__linux__)
return "Linux";
#elif defined(__FreeBSD__)
return "FreeBSD";
#else
return "POSIX";
#endif
}
/* ---- presentation layer: color, glyphs, rules, boxes --------------------- */
static int USE_STYLE = 1;
static const char *RESET="", *BOLD="", *DIM="", *ITAL="",
*GREEN="", *GREENB="", *WHITE="", *GREY="", *RED="", *AMBER="";
static const char *G_OK="[ok]", *G_RUN="[..]", *G_WARN="[!]", *G_ERR="[x]", *G_DOT="-";
static void style_init(void) {
if (getenv("NO_COLOR") != NULL) USE_STYLE = 0;
if (!isatty(fileno(stdout))) USE_STYLE = 0;
if (USE_STYLE) {
RESET="\033[0m"; BOLD="\033[1m"; DIM="\033[2m"; ITAL="\033[3m";
GREEN="\033[38;5;43m"; GREENB="\033[1;38;5;43m"; WHITE="\033[38;5;231m";
GREY="\033[38;5;245m"; RED="\033[38;5;203m"; AMBER="\033[38;5;215m";
G_OK="[\u2713]"; G_RUN="[\u00bb]"; G_WARN="[!]"; G_ERR="[x]"; G_DOT="\u00b7";
} else {
RESET=""; BOLD=""; DIM=""; ITAL=""; GREEN=""; GREENB=""; WHITE="";
GREY=""; RED=""; AMBER="";
G_OK="[ok]"; G_RUN="[..]"; G_WARN="[!]"; G_ERR="[x]"; G_DOT="-";
}
}
static void rule(void) {
int w = 72, i; const char *ch = USE_STYLE ? "\u2500" : "-";
printf("%s", GREY);
for (i = 0; i < w; i++) printf("%s", ch);
printf("%s\n", RESET);
}
static void heading(const char *s) { printf("\n%s\u2590 %s%s\n", GREENB, s, RESET); rule(); }
static void step(const char *s) { printf(" %s%s%s %s\n", GREEN, G_RUN, RESET, s); }
static void okln(const char *s) { printf(" %s%s%s %s\n", GREEN, G_OK, RESET, s); }
static void warnln(const char *s){ printf(" %s%s%s %s\n", AMBER, G_WARN, RESET, s); }
static void item(const char *s) { printf(" %s%s%s %s\n", GREEN, G_DOT, RESET, s); }
static void dieln(const char *s) { fprintf(stderr, " %s%s %s%s\n", RED, G_ERR, s, RESET); exit(1); }
static void bline(const char *vis, const char *col) {
int IW = 55, pad; const char *v = USE_STYLE ? "\u2502" : "|";
pad = IW - (int)strlen(vis); if (pad < 0) pad = 0;
printf(" %s%s%s %s%*s %s%s%s\n", GREEN, v, RESET, col, pad, "", GREEN, v, RESET);
}
static void banner(void) {
int IW = 55, i;
const char *tl = USE_STYLE?"\u256d":"+", *tr = USE_STYLE?"\u256e":"+";
const char *bl = USE_STYLE?"\u2570":"+", *br = USE_STYLE?"\u256f":"+";
const char *h = USE_STYLE?"\u2500":"-";
printf("\n %s%s", GREEN, tl);
for (i = 0; i < IW + 2; i++) printf("%s", h);
printf("%s%s\n", tr, RESET);
bline("", "");
{
char col[256];
snprintf(col, sizeof col, " %s%sS L e e L a%s %sBuilder / Installer%s",
BOLD, WHITE, RESET, GREEN, RESET);
bline(" S L e e L a Builder / Installer", col);
snprintf(col, sizeof col, " %s%s%s%s", DIM, ITAL, SL_TAGLINE, RESET);
bline(" " SL_TAGLINE, col);
}
bline("", "");
{
char vis[128], col[256];
snprintf(vis, sizeof vis, " release %s syntax %s os %s",
SL_RELEASE, SL_SYNTAX, host_os());
snprintf(col, sizeof col,
" %srelease%s %s%s%s %ssyntax%s %s%s%s %sos%s %s%s%s",
GREY, RESET, WHITE, SL_RELEASE, RESET,
GREY, RESET, WHITE, SL_SYNTAX, RESET,
GREY, RESET, WHITE, host_os(), RESET);
bline(vis, col);
}
bline("", "");
printf(" %s%s", GREEN, bl);
for (i = 0; i < IW + 2; i++) printf("%s", h);
printf("%s%s\n\n", br, RESET);
}
/* ---- library exclusions (identical policy to the shell clean-install) ---- */
static const char *EXCLUDE_LIB[] = {
"http","http-1.0","http-2.0","http-3.0","http-4.0","http-5.0","http-6.0",
"http-7.0","http-8.0","http-9.0","http-servers","server-edition",
"web-server-technology","ide","ide-workbench","linux-editors","wifi",
"moral-capacitor","philosophers","manifesto","politico",
"international-criminal-court","psychiatry","citizen", NULL
};
static int is_excluded(const char *name) {
for (int i = 0; EXCLUDE_LIB[i]; i++)
if (strcmp(EXCLUDE_LIB[i], name) == 0) return 1;
return 0;
}
/* ---- small helpers ------------------------------------------------------- */
static char REPO[PATH_MAX];
static char BUILD_LOG[PATH_MAX];
static char BUILD_STARTED[64], BUILD_ENDED[64];
static int LIB_KEPT = 0, LIB_DROPPED = 0;
static void now_str(char *out, size_t n) {
time_t t = time(NULL); struct tm tmv; localtime_r(&t, &tmv);
strftime(out, n, "%Y-%m-%d %H:%M:%S", &tmv);
}
/* run a shell command line, appending stdout+stderr to BUILD_LOG. */
static int run_logged(const char *cmd) {
char full[PATH_MAX * 2];
snprintf(full, sizeof full, "%s >> '%s' 2>&1", cmd, BUILD_LOG);
int rc = system(full);
return (rc == -1) ? -1 : WEXITSTATUS(rc);
}
static int run_quiet(const char *cmd) {
char full[PATH_MAX];
snprintf(full, sizeof full, "%s >/dev/null 2>&1", cmd);
int rc = system(full);
return (rc == -1) ? -1 : WEXITSTATUS(rc);
}
/* count lines in a file (for the build summary). */
static long count_lines(const char *path) {
FILE *f = fopen(path, "r"); if (!f) return 0;
long n = 0; int c, prev = '\n';
while ((c = fgetc(f)) != EOF) { if (c == '\n') n++; prev = c; }
if (prev != '\n') n++;
fclose(f); return n;
}
static void usage(const char *argv0) {
printf("usage: %s [--prefix DIR] [--plain] [--no-color] [--build-only]\n"
" [--dry-run] [--repo DIR] [-h|--help]\n", argv0);
}
int main(int argc, char **argv) {
const char *prefix = NULL, *repo_arg = NULL;
int build_only = 0, dry_run = 0;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--plain") || !strcmp(argv[i], "--no-color")) { setenv("NO_COLOR","1",1); }
else if (!strcmp(argv[i], "--build-only")) build_only = 1;
else if (!strcmp(argv[i], "--dry-run")) dry_run = 1;
else if (!strcmp(argv[i], "--prefix") && i+1 < argc) prefix = argv[++i];
else if (!strcmp(argv[i], "--repo") && i+1 < argc) repo_arg = argv[++i];
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { usage(argv[0]); return 0; }
else { fprintf(stderr, "unknown option: %s\n", argv[i]); usage(argv[0]); return 2; }
}
style_init();
/* Resolve the repository root: --repo, else SLEELA_REPO, else derive from
* argv[0] (build/native-builder/slbuild -> two levels up). */
if (repo_arg) {
realpath(repo_arg, REPO);
} else if (getenv("SLEELA_REPO")) {
realpath(getenv("SLEELA_REPO"), REPO);
} else {
/* Resolve the real path of this executable, then walk up parent
* directories until one contains impl/Makefile. This is robust to the
* binary's depth (bin/<os>/slbuild) and to being run from anywhere. */
char here[PATH_MAX];
if (realpath(argv[0], here) == NULL) {
/* argv[0] may be a bare name found via PATH; fall back to CWD. */
if (getcwd(here, sizeof here) == NULL) here[0] = 0;
}
/* start from the directory containing the executable */
char dirbuf[PATH_MAX]; strncpy(dirbuf, here, sizeof dirbuf - 1); dirbuf[sizeof dirbuf - 1] = 0;
char *d = dirname(dirbuf);
REPO[0] = 0;
for (int up = 0; up < 12 && d && d[0]; up++) {
char chk[PATH_MAX];
snprintf(chk, sizeof chk, "%s/impl/Makefile", d);
if (access(chk, F_OK) == 0) { strncpy(REPO, d, sizeof REPO - 1); REPO[sizeof REPO - 1] = 0; break; }
if (strcmp(d, "/") == 0) break;
char parent[PATH_MAX]; snprintf(parent, sizeof parent, "%s/..", d);
static char resolved[PATH_MAX];
if (realpath(parent, resolved) == NULL) break;
d = resolved;
}
}
/* sanity: repo must contain impl/Makefile */
{
char chk[PATH_MAX]; snprintf(chk, sizeof chk, "%s/impl/Makefile", REPO);
if (access(chk, F_OK) != 0)
dieln("could not locate the SLeeLa repository (impl/Makefile not found); pass --repo DIR");
}
/* default prefix */
char prefbuf[PATH_MAX];
if (!prefix) {
const char *home = getenv("HOME");
snprintf(prefbuf, sizeof prefbuf, "%s/.local/sleela", home ? home : "/tmp");
prefix = prefbuf;
}
banner();
printf(" %sBuilds the SLeeLa core products and installs the main package,%s\n", GREY, RESET);
printf(" %susing this host's native toolchain (%s).%s\n", GREY, host_os(), RESET);
heading("Plan");
{ char b[PATH_MAX]; snprintf(b,sizeof b,"repository %s", REPO); item(b);
snprintf(b,sizeof b,"host OS %s", host_os()); item(b);
snprintf(b,sizeof b,"products sleela, sleelvac, nordshrift"); item(b);
snprintf(b,sizeof b,"install to %s", build_only ? "(build only)" : prefix); item(b);
}
if (dry_run) {
heading("Dry run");
okln("no build or install performed (--dry-run).");
printf(" %s%s%s\n\n", DIM, SL_TAGLINE, RESET);
return 0;
}
/* -------- build the core products (integrity-gated impl build) -------- */
heading("Building SLeeLa");
{
char logdir[PATH_MAX]; snprintf(logdir, sizeof logdir, "%s/build/native-builder/logs", REPO);
char mk[PATH_MAX]; snprintf(mk, sizeof mk, "mkdir -p '%s'", logdir);
run_quiet(mk);
char stamp[32]; time_t t = time(NULL); struct tm tmv; localtime_r(&t,&tmv);
strftime(stamp, sizeof stamp, "%Y%m%d-%H%M%S", &tmv);
snprintf(BUILD_LOG, sizeof BUILD_LOG, "%s/build-%s.log", logdir, stamp);
}
now_str(BUILD_STARTED, sizeof BUILD_STARTED);
char manifest[PATH_MAX];
if (getenv("SLEELA_SHA256_MANIFEST"))
strncpy(manifest, getenv("SLEELA_SHA256_MANIFEST"), sizeof manifest - 1);
else
snprintf(manifest, sizeof manifest, "%s/security/sha256-manifest.json", REPO);
{ FILE *f = fopen(BUILD_LOG, "w");
if (f) {
fprintf(f, "SLeeLa slbuild — verbatim build log\n");
fprintf(f, "host OS: %s\n", host_os());
fprintf(f, "started: %s\n", BUILD_STARTED);
fprintf(f, "command: make -C %s/impl build/sleela build/sleelvac build/nordshrift\n", REPO);
fprintf(f, "manifest: %s\n", manifest);
fprintf(f, "----------------------------------------------------------------------\n");
fclose(f);
} }
printf(" %sbuilding the core products; verbatim output captured to the build log%s\n", GREY, RESET);
const char *products[] = { "sleela", "sleelvac", "nordshrift", NULL };
int built_ok = 1;
for (int i = 0; products[i]; i++) {
char msg[128]; snprintf(msg, sizeof msg, "build %s%s%s", WHITE, products[i], RESET); step(msg);
char hdr[PATH_MAX]; snprintf(hdr, sizeof hdr, "printf '\\n===== make build/%s =====\\n'", products[i]);
run_logged(hdr);
char cmd[PATH_MAX * 2];
snprintf(cmd, sizeof cmd,
"env SLEELA_SHA256_MANIFEST='%s' make -C '%s/impl' build/%s",
manifest, REPO, products[i]);
if (run_logged(cmd) == 0) {
char o[128]; snprintf(o, sizeof o, "%s built", products[i]); okln(o);
} else {
built_ok = 0;
char w[160]; snprintf(w, sizeof w, "build of %s%s%s failed — see the log tail below:", WHITE, products[i], RESET);
warnln(w);
char tail[PATH_MAX]; snprintf(tail, sizeof tail, "tail -n 14 '%s' | sed 's/^/ /'", BUILD_LOG);
system(tail);
break;
}
}
now_str(BUILD_ENDED, sizeof BUILD_ENDED);
{ FILE *f = fopen(BUILD_LOG, "a");
if (f) { fprintf(f, "\n----------------------------------------------------------------------\nended: %s\n", BUILD_ENDED); fclose(f); } }
if (!built_ok) {
char m[PATH_MAX]; snprintf(m, sizeof m, "full verbatim build log: %s", BUILD_LOG);
printf(" %s%s%s\n", GREY, m, RESET);
dieln("build failed — the exact messages above and the full log are retained.");
}
okln("build complete");
{ long total = count_lines(BUILD_LOG);
char s[128]; snprintf(s, sizeof s, "%ssummary%s log lines %ld", GREY, RESET, total);
printf(" %s\n", s);
char l[PATH_MAX]; snprintf(l, sizeof l, "%sverbatim log:%s %s%s%s", GREY, RESET, WHITE, BUILD_LOG, RESET);
printf(" %s\n", l);
}
/* verify the products exist and run */
for (int i = 0; products[i]; i++) {
char bin[PATH_MAX]; snprintf(bin, sizeof bin, "%s/impl/build/%s", REPO, products[i]);
if (access(bin, X_OK) != 0) { char e[PATH_MAX]; snprintf(e,sizeof e,"required product missing: %s", bin); dieln(e); }
}
if (build_only) {
heading("Record of Build");
printf(" %sCore products built (build-only); no install performed.%s\n", GREY, RESET);
printf(" %s%-14s%s %s %s(syntax %s)\n", GREY, "Product", RESET, SL_PRODUCT " " SL_RELEASE, GREY, SL_SYNTAX);
printf(" %s%-14s%s %s\n", GREY, "Host OS", RESET, host_os());
printf(" %s%-14s%s sleela, sleelvac, nordshrift\n", GREY, "Binaries", RESET);
printf(" %s%-14s%s %s -> %s\n", GREY, "Build window", RESET, BUILD_STARTED, BUILD_ENDED);
printf(" %s%-14s%s %s%s%s\n", GREY, "Verbatim log", RESET, WHITE, BUILD_LOG, RESET);
printf("\n %s%sSo attested, this build complete and in order.%s\n\n", GREEN, ITAL, RESET);
return 0;
}
/* -------- stage + install the main package ---------------------------- */
heading("Staging the main package");
char stage[PATH_MAX];
snprintf(stage, sizeof stage, "%s/build/native-builder/.stage", REPO);
{ char rm[PATH_MAX]; snprintf(rm, sizeof rm, "rm -rf '%s'", stage); run_quiet(rm); }
{ char mk[PATH_MAX]; snprintf(mk, sizeof mk,
"mkdir -p '%s/bin' '%s/lib' '%s/config' '%s/tools' '%s/security'",
stage, stage, stage, stage, stage); run_quiet(mk); }
step("copying binaries");
for (int i = 0; products[i]; i++) {
char cp[PATH_MAX * 2];
snprintf(cp, sizeof cp, "install -m 755 '%s/impl/build/%s' '%s/bin/%s'",
REPO, products[i], stage, products[i]);
if (run_quiet(cp) != 0) dieln("failed to stage a binary");
item(products[i]);
}
step("staging the standard library (excluding servers, IDEs, Wi-Fi, religious/moral)");
{
char libdir[PATH_MAX]; snprintf(libdir, sizeof libdir, "%s/lib", REPO);
/* enumerate top-level lib/ packages */
char listcmd[PATH_MAX]; snprintf(listcmd, sizeof listcmd,
"find '%s' -mindepth 1 -maxdepth 1 -type d -printf '%%f\\n' | sort", libdir);
FILE *p = popen(listcmd, "r");
if (!p) dieln("could not enumerate the standard library");
char name[256];
while (fgets(name, sizeof name, p)) {
name[strcspn(name, "\n")] = 0;
if (name[0] == 0) continue;
if (is_excluded(name)) { LIB_DROPPED++; continue; }
char cp[PATH_MAX * 2];
snprintf(cp, sizeof cp, "cp -a '%s/%s' '%s/lib/'", libdir, name, stage);
if (run_quiet(cp) == 0) LIB_KEPT++;
}
pclose(p);
/* inventory markdown travels with the library */
char cpmd[PATH_MAX * 2];
snprintf(cpmd, sizeof cpmd, "cp -a '%s'/lib/*.md '%s/lib/' 2>/dev/null || true", REPO, stage);
run_quiet(cpmd);
}
{ char m[128]; snprintf(m, sizeof m, "library staged: %d packages kept, %d excluded", LIB_KEPT, LIB_DROPPED); okln(m); }
step("staging the integrity manifest and verifier");
{
char c[PATH_MAX * 2];
snprintf(c, sizeof c, "cp -a '%s/tools/verify-before-execution.py' '%s/tools/' 2>/dev/null || true", REPO, stage); run_quiet(c);
snprintf(c, sizeof c, "cp -a '%s/security/sha256-manifest.json' '%s/security/'", REPO, stage); run_quiet(c);
snprintf(c, sizeof c, "cp -a '%s/SHEET.sheet' '%s/' 2>/dev/null || true", REPO, stage); run_quiet(c);
}
okln("manifest + verifier staged");
/* startup.conf */
{
char conf[PATH_MAX]; snprintf(conf, sizeof conf, "%s/config/startup.conf", stage);
FILE *f = fopen(conf, "w");
if (f) {
fprintf(f, "# Generated by slbuild (%s native builder/installer)\n", host_os());
fprintf(f, "install.mode=user\ninstall.root=%s\npackage=main\n", prefix);
fprintf(f, "servers=excluded\nides=excluded\nwifi=excluded\nhost.os=%s\n", host_os());
fclose(f);
}
}
heading("Installing");
{ char mk[PATH_MAX]; snprintf(mk, sizeof mk, "mkdir -p '%s'", prefix); run_quiet(mk); }
{ char cp[PATH_MAX * 2]; snprintf(cp, sizeof cp, "cp -a '%s/.' '%s/'", stage, prefix);
if (run_quiet(cp) != 0) dieln("failed to copy the staged package into the install root"); }
/* Verify the install actually materialized — do not trust the copy's exit
* code alone (a sandboxed/overlay filesystem can report success yet not
* persist). The installed sleela binary must exist and be executable. */
{ char chk[PATH_MAX]; snprintf(chk, sizeof chk, "%s/bin/sleela", prefix);
if (access(chk, X_OK) != 0) {
char e[PATH_MAX]; snprintf(e, sizeof e,
"install did not materialize at %s (bin/sleela missing); choose a writable --prefix", prefix);
dieln(e);
} }
{ char m[PATH_MAX]; snprintf(m, sizeof m, "installed to %s%s%s", WHITE, prefix, RESET); okln(m); }
/* preserve the verbatim build log alongside the install */
char installed_log[PATH_MAX] = {0};
{
char mk[PATH_MAX]; snprintf(mk, sizeof mk, "mkdir -p '%s/logs'", prefix); run_quiet(mk);
char cp[PATH_MAX * 2]; snprintf(cp, sizeof cp, "cp -a '%s' '%s/logs/'", BUILD_LOG, prefix);
if (run_quiet(cp) == 0) {
const char *base = strrchr(BUILD_LOG, '/'); base = base ? base + 1 : BUILD_LOG;
snprintf(installed_log, sizeof installed_log, "%s/logs/%s", prefix, base);
}
}
/* clean the stage */
{ char rm[PATH_MAX]; snprintf(rm, sizeof rm, "rm -rf '%s'", stage); run_quiet(rm); }
heading("Installed");
{ char m[160]; snprintf(m, sizeof m, "%s %s main package is installed.", SL_PRODUCT, SL_RELEASE); okln(m); }
printf(" %sBinaries:%s %s%s/bin%s %s(sleela · sleelvac · nordshrift)%s\n",
GREY, RESET, WHITE, prefix, RESET, GREY, RESET);
printf(" %sTry:%s %s%s/bin/sleela version%s\n", GREY, RESET, WHITE, prefix, RESET);
/* -------- Record of Build -------------------------------------------- */
heading("Record of Build");
printf(" %sBe it recorded that the SLeeLa main package was built and installed%s\n", GREY, RESET);
printf(" %sin good order on this %s host, as attested below.%s\n\n", GREY, host_os(), RESET);
printf(" %s%-16s%s %s %s(syntax %s)%s\n", GREY, "Product", RESET, SL_PRODUCT " " SL_RELEASE, GREY, SL_SYNTAX, RESET);
printf(" %s%-16s%s %s\n", GREY, "Host OS", RESET, host_os());
printf(" %s%-16s%s sleela, sleelvac, nordshrift\n", GREY, "Binaries", RESET);
{ char m[96]; snprintf(m, sizeof m, "%d packages included \u00b7 %d excluded", LIB_KEPT, LIB_DROPPED);
printf(" %s%-16s%s %s\n", GREY, "Library", RESET, m); }
printf(" %s%-16s%s servers \u00b7 IDEs/editors \u00b7 Wi-Fi \u00b7 religious/moral/political\n", GREY, "Excluded", RESET);
printf(" %s%-16s%s %s\n", GREY, "Destination", RESET, prefix);
printf(" %s%-16s%s %s -> %s\n", GREY, "Build window", RESET, BUILD_STARTED, BUILD_ENDED);
printf(" %s%-16s%s SHA-256 manifest honored (fail-closed)\n", GREY, "Integrity", RESET);
printf(" %s%-16s%s %s%s%s\n", GREY, "Verbatim log", RESET, WHITE,
installed_log[0] ? installed_log : BUILD_LOG, RESET);
printf("\n %s%sSo attested, this build complete and in order.%s\n", GREEN, ITAL, RESET);
printf(" %s%s%s\n\n", DIM, SL_TAGLINE, RESET);
return 0;
}