buninu-linux 0.9.56 → 0.11.56

package/initramfs/usr/lib/bootstrap/3.gen-musl-dev.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+import { cc } from "bun:ffi";
+import {
+  mkdtempSync, readFileSync, renameSync,
+  rmSync, writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  assertAbsent, bootstrap, cli,
+  requireRootfs, validateElf,
+} from "./lib/common.js";
+import {
+  generateHeaders,
+} from "./lib/musl-headers.js";
+
+async function main(args) {
+  // Run inside the prepared rootfs.
+  // This generates public headers
+  // and ordinary dynamic-link CRT.
+  // It does not build libc or rcrt1.
+  if (args.length) throw new Error(
+    "Usage: bun 3.gen-musl-dev.js"
+  );
+  const { arch } = requireRootfs();
+  const names = [
+    "crt1.o", "crti.o", "crtn.o",
+  ];
+  assertAbsent("/usr/include");
+  for (const name of names) {
+    assertAbsent(`/usr/lib/${name}`);
+  }
+
+  // Follow musl's Makefile rules in
+  // JS: public headers, arch bits,
+  // alltypes.h and syscall.h.
+  console.log(
+    "① Generating musl headers"
+  );
+  generateHeaders(
+    arch,
+    "/bootstrap/src/musl",
+    "/usr/include"
+  );
+  // chroot mounts /tmp separately;
+  // stage objects on the same FS as
+  // /usr/lib for the final rename.
+  const work = mkdtempSync(
+    "/usr/lib/.musl-crt-"
+  );
+  let compiler;
+  try {
+    // ARM64 TCC does not handle adrp.
+    // Ordinary crt1's _start_c uses
+    // x0, not x1 (_DYNAMIC). Omit just
+    // that unused argument in a
+    // temporary header override.
+    // Keep musl sources untouched.
+    if (arch === "aarch64") {
+      prepareArm64Startup(work);
+    }
+
+    // Bun.cc builds libtcc.c in memory
+    // without standalone cc or CRT.
+    // TCC_OUTPUT_OBJ emits the three
+    // relocatable startup objects.
+    console.log(
+      "② Building CRT with Bun.cc"
+    );
+    compiler = cc({
+      source: join(
+        bootstrap,
+        "lib/compile-object.c"
+      ),
+      library: ["gcc_s"],
+      flags: ["-L/usr/lib", "-L/lib"],
+      include: [
+        "/bootstrap/src/tinycc",
+        "/bootstrap/src/tinycc/include",
+        "/usr/include",
+      ],
+      symbols: {
+        compile_object: {
+          args: [
+            "cstring", "cstring",
+            "cstring",
+          ],
+          returns: "int",
+        },
+      },
+    });
+    compileCrt(
+      compiler, arch, work, names
+    );
+    for (const name of names) {
+      renameSync(
+        join(work, name),
+        `/usr/lib/${name}`
+      );
+    }
+    console.log(
+      "Ready: musl headers and CRT."
+    );
+    console.log(
+      "Next: bun " +
+      "/bootstrap/" +
+      "4.build-tcc.js"
+    );
+  } finally {
+    compiler?.close();
+    rmSync(work, {
+      recursive: true, force: true,
+    });
+  }
+}
+
+function prepareArm64Startup(work) {
+  const original = readFileSync("/bootstrap/src/musl/arch/aarch64/crt_arch.h", "utf8");
+  const lines = original.split("\n");
+  const removed = lines.filter(line => line.includes("_DYNAMIC"));
+  if (removed.length !== 4 || !removed.some(line => line.includes("adrp x1"))) {
+    throw new Error("Unexpected musl ARM64 startup code; refusing compatibility edit");
+  }
+  writeFileSync(join(work, "crt_arch.h"), lines.filter(line => !line.includes("_DYNAMIC")).join("\n"));
+}
+
+function compileCrt(compiler, arch, work, names) {
+  const z = text => Buffer.from(text + "\0");
+  const flags = `-nostdinc -DCRT -D_XOPEN_SOURCE=700 -I${work} -I/bootstrap/src/musl/arch/${arch} -I/bootstrap/src/musl/arch/generic -I/bootstrap/src/musl/src/include -I/bootstrap/src/musl/src/internal -I/usr/include -I/bootstrap/src/tinycc/include`;
+  for (const name of names) {
+    const source = name === "crt1.o" ? "/bootstrap/src/musl/crt/crt1.c" : `/bootstrap/src/musl/crt/${arch}/${name.slice(0, -2)}.s`;
+    const output = join(work, name);
+    console.log(`${source} -> /usr/lib/${name}`);
+    const result = compiler.symbols.compile_object(z(source), z(output), z(flags));
+    if (result) throw new Error(`${name}: TinyCC returned ${result}`);
+    const bytes = readFileSync(output);
+    validateElf(name, bytes, arch);
+    if (bytes.readUInt16LE(16) !== 1) throw new Error(`${name} is not a relocatable ELF object`);
+  }
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/4.build-tcc.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  bootstrap, cli, requireRootfs, run,
+  validateElf,
+} from "./lib/common.js";
+import {
+  buildTcc,
+} from "./lib/tcc-build.js";
+
+async function main(args) {
+  // Stage 3 must have generated
+  // headers and the three CRT files.
+  if (args.length) throw new Error(
+    "Usage: bun 4.build-tcc.js"
+  );
+  const { arch } = requireRootfs();
+  for (const name of [
+    "crt1.o", "crti.o", "crtn.o",
+  ]) {
+    validateElf(
+      name,
+      readFileSync(`/usr/lib/${name}`),
+      arch
+    );
+  }
+
+  // Bun.cc -> standalone stage1 ->
+  // stage2, then compare bytes.
+  // Build x64 runtime helpers when
+  // needed and test /bin/cc.
+  await buildTcc();
+
+  // Exercise the generated CRT:
+  // argv, env, constructors,
+  // destructors and exit status.
+  await verifyStartup();
+  console.log(
+    "Ready: cc source.c -o program"
+  );
+  console.log(
+    "Next: bun /bootstrap/" +
+    "5.build-make.js"
+  );
+}
+
+async function verifyStartup() {
+  const output = "/bootstrap/build/tinycc/startup-check";
+  await run(["/bin/cc", join(bootstrap, "lib/startup-check.c"), "-o", output]);
+  const child = Bun.spawn([output, "hello", "two words"], {
+    env: { PATH: "/bin:/usr/bin", CRT_TEST: "seed-free" }, stdout: "pipe", stderr: "inherit",
+  });
+  const stdout = await new Response(child.stdout).text();
+  if (await child.exited !== 42 || stdout !== "argc/argv, environment, constructor OK\ndestructor OK\n") {
+    throw new Error(`CRT startup check failed: ${stdout}`);
+  }
+  console.log(stdout + "exit status 42: OK");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/5.build-make.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+import {
+  chmodSync, copyFileSync,
+} from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  installAdapters, makeIn, patch,
+  ready, shell, source, stage, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    5, "make", args
+  );
+  installAdapters();
+  const src = await source(
+    "make@4.4.1", "make-4.4.1"
+  );
+  const build = buildRoot + "/make";
+  prepareMake(src);
+  await configure(src, build, [
+    "--build=" + triple,
+    "--prefix=/bootstrap/toolchain",
+    "--disable-dependency-tracking",
+    "--without-guile", "--disable-nls",
+  ]);
+
+  // GNU Make provides its own
+  // no-make shell bootstrap builder.
+  await command(
+    [shell, src + "/build.sh"],
+    build
+  );
+  copyFileSync(
+    build + "/make", tools + "/make"
+  );
+  chmodSync(tools + "/make", 0o755);
+  await makeIn(build, ["clean"]);
+  await makeIn(build);
+  copyFileSync(
+    build + "/make", tools + "/make"
+  );
+  await command(
+    [tools + "/make", "--version"]
+  );
+  ready(5, "GNU Make self-rebuild");
+}
+
+function prepareMake(src) {
+  patch(src + "/build.sh", '  LIBOBJS="${LIBOBJS:+$LIBOBJS }lib/$lo"',
+    '  lo=${lo#\'${LIBOBJDIR}\'}\n  LIBOBJS="${LIBOBJS:+$LIBOBJS }lib/$lo"');
+  patch(src + "/src/mkcustom.h", "char *alloca ();", "void *alloca ();");
+  patch(src + "/lib/glob.c", "extern char *alloca ();", "extern void *alloca ();");
+  patch(src + "/lib/alloca.c", "memory_full ();", "abort ();");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/6.build-binutils.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import {
+  existsSync, readdirSync,
+  readFileSync, statSync,
+  copyFileSync, writeFileSync,
+} from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  makeIn, ready, source, stage,
+  toolchain, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { arch, triple } = stage(
+    6, "binutils", args
+  );
+  const src = await source(
+    "binutils@2.39", "binutils-2.39"
+  );
+  const build = buildRoot + "/binutils";
+  const env = {
+    CFLAGS: "-O2 -D__LITTLE_ENDIAN__=1",
+  };
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--target=" + triple,
+    "--prefix=" + toolchain,
+    "--disable-nls", "--disable-werror",
+    "--disable-gprofng",
+    "--disable-gold", "--disable-gdb",
+    "--disable-sim", "--disable-libctf",
+    "--disable-shared",
+    "--disable-multilib",
+    "--disable-dependency-tracking",
+    "--without-debuginfod",
+    "--without-zstd",
+  ], env);
+  await makeIn(build, ["all"], env);
+  restoreManpages(src, build);
+  await makeIn(build, ["install"], env);
+  await runtime(arch);
+  await command([
+    toolchain + "/bin/as", "--version",
+  ]);
+  await command([
+    toolchain + "/bin/ld", "--version",
+  ]);
+  ready(6, "Binutils and TCC runtime");
+}
+
+function restoreManpages(src, build) {
+  for (const dir of ["gas/doc", "binutils/doc", "ld", "gprof"]) {
+    for (const name of readdirSync(src + "/" + dir).filter(n => n.endsWith(".1"))) {
+      const target = `${build}/${dir}/${name}`;
+      if (existsSync(target) && statSync(target).size === 0) copyFileSync(`${src}/${dir}/${name}`, target);
+    }
+  }
+}
+
+async function runtime(arch) {
+  const cwd = buildRoot + "/tcc-runtime";
+  if (arch === "aarch64") {
+    await command([tools + "/cc", "-c", "/bootstrap/src/tinycc/lib/lib-arm64.c", "-o", "lib-arm64.o"], cwd);
+    await command([toolchain + "/bin/ar", "rcs", toolchain + "/lib/tcc/libbootstrap-tcc-arm64.a", "lib-arm64.o"], cwd);
+  }
+  const code = `static volatile long double a=1.5L,b=2.0L;
+int main(void){long double x=a,y=b;return x*y!=3.0L||x/y!=0.75L||x+y!=3.5L||x-y!=-0.5L||!(x<y)||(double)(x*y)!=3.0;}`;
+  // command() creates the working directory before compilation.
+  await command([toolchain + "/bin/ar", "--version"], cwd);
+  writeFileSync(cwd + "/quad.c", code);
+  await command([tools + "/cc", "quad.c", "-o", "quad"], cwd);
+  await command([cwd + "/quad"], cwd);
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/7.build-gmp.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, canonicalizers, configure,
+  makeIn, patch, deps, ready,
+  source, stage,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { arch, triple } = stage(
+    7, "gmp", args
+  );
+  const src = await source(
+    "gmp@4.3.2", "gmp-4.3.2"
+  );
+  const build = buildRoot + "/gmp";
+  canonicalizers(src);
+  patch(
+    src + "/gmp-impl.h",
+    "char *alloca ();",
+    "void *alloca ();"
+  );
+  // GMP 4.3 uses CPU "none" for C;
+  // --disable-assembly is ignored.
+  // Keep build/host equal: native,
+  // with 64-bit unsigned-long limbs.
+  const generic = arch === "x86_64";
+  const host = generic
+    ? "none-unknown-linux-musl"
+    : triple;
+  const env = {
+    ABI: generic ? "long" : "standard",
+    CPPFLAGS: "-DNO_ASM",
+  };
+  await configure(src, build, [
+    "--build=" + host,
+    "--host=" + host,
+    "--prefix=" + deps,
+    "--disable-shared",
+    "--enable-static",
+    "--disable-dependency-tracking",
+    "--disable-cxx",
+    "--enable-alloca=malloc-reentrant",
+  ], env);
+  checkConfiguration(src, build);
+  await makeIn(build, ["all"], env);
+  await makeIn(build, ["install"], env);
+  ready(7, "GMP static library");
+}
+
+function checkConfiguration(src, build) {
+  const log = readFileSync(build + "/config.log", "utf8");
+  const recorded = log.slice(log.lastIndexOf("## confdefs.h. ##"));
+  const template = readFileSync(src + "/config.in", "utf8");
+  const config = readFileSync(build + "/config.h", "utf8");
+  const names = new Set([...template.matchAll(/^#undef (\w+)/gm)].map(m => m[1]));
+  const actual = new Map([...config.matchAll(/^#define (\w+)[ \t]+(.*)$/gm)].map(m => [m[1], m[2].trim()]));
+  let checked = 0;
+  for (const m of recorded.matchAll(/^#define (\w+)[ \t]+(.*)$/gm)) {
+    if (!names.has(m[1])) continue;
+    if (actual.get(m[1]) !== m[2].trim()) throw new Error(`GMP config.h mismatch: ${m[1]}`);
+    checked++;
+  }
+  if (checked < 20) throw new Error("Insufficient GMP configure definitions");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/8.build-mpfr.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+import {
+  readFileSync, writeFileSync,
+} from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, canonicalizers, command,
+  configure, makeIn, patch, deps,
+  ready, source, stage,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    8, "mpfr", args
+  );
+  const src = await source(
+    "mpfr@2.4.2", "mpfr-2.4.2"
+  );
+  const build = buildRoot + "/mpfr";
+  canonicalizers(src);
+  prepareAllocation(src);
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--prefix=" + deps,
+    "--disable-shared",
+    "--enable-static",
+    "--disable-dependency-tracking",
+    "--with-gmp=" + deps,
+  ]);
+  await makeIn(build);
+  await makeIn(build, [
+    "-C", "tests",
+    "tadd", "tdiv", "tsqrt",
+  ]);
+  for (const name of [
+    "tadd", "tdiv", "tsqrt",
+  ]) {
+    await command(
+      [build + "/tests/" + name],
+      build + "/tests",
+      { srcdir: src + "/tests" }
+    );
+  }
+  await makeIn(build, ["install"]);
+  ready(8, "MPFR upstream tests");
+}
+
+function prepareAllocation(src) {
+  const path = src + "/mpfr-gmp.h";
+  patch(path, "char *alloca ();", "void *alloca ();");
+  const text = readFileSync(path, "utf8");
+  if (text.includes("/* Bootstrap: no working alloca. */")) return;
+  const start = text.indexOf("#define TMP_ALLOC(n)"), end = text.indexOf("#define TMP_DECL(m)", start);
+  if (start < 0 || end < 0) throw new Error("Unexpected MPFR allocation macros");
+  writeFileSync(path, text.slice(0, start) + "/* Bootstrap: no working alloca. */\n#ifdef C_ALLOCA\n#define TMP_ALLOC(n) mpfr_tmp_allocate (&tmp_marker, (n))\n#else\n" + text.slice(start, end) + "#endif\n" + text.slice(end));
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/9.build-mpc.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env bun
+import { writeFileSync } from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, canonicalizers, command,
+  configure, makeIn, deps, ready,
+  source, stage, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    9, "mpc", args
+  );
+  const src = await source(
+    "mpc@0.8.1", "mpc-0.8.1"
+  );
+  const build = buildRoot + "/mpc";
+  canonicalizers(src);
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--prefix=" + deps,
+    "--disable-shared",
+    "--enable-static",
+    "--disable-dependency-tracking",
+    "--with-gmp=" + deps,
+    "--with-mpfr=" + deps,
+  ]);
+  await makeIn(build);
+  await makeIn(build, ["install"]);
+  await verifyMath(build);
+  ready(9, "GMP, MPFR and MPC math");
+}
+
+async function verifyMath(build) {
+  writeFileSync(build + "/verify-math.c", `#include <gmp.h>
+#include <mpfr.h>
+#include <mpc.h>
+int main(void){
+mpz_t z;mpfr_t f;mpc_t c;
+mpz_init(z);mpz_ui_pow_ui(z,2,100);
+if(mpz_sizeinbase(z,2)!=101)return 1;
+mpz_sub_ui(z,z,1);if(mpz_popcount(z)!=100)return 2;
+mpfr_init2(f,128);mpfr_set_ui(f,144,GMP_RNDN);mpfr_sqrt(f,f,GMP_RNDN);
+if(mpfr_cmp_ui(f,12))return 3;
+mpc_init2(c,128);mpc_set_ui_ui(c,3,4,MPC_RNDNN);mpc_mul(c,c,c,MPC_RNDNN);
+if(mpfr_cmp_si(mpc_realref(c),-7)||mpfr_cmp_ui(mpc_imagref(c),24))return 4;
+mpc_clear(c);mpfr_clear(f);mpz_clear(z);return 0;}
+`);
+  await command([tools + "/cc", "-I" + deps + "/include", "verify-math.c",
+    deps + "/lib/libmpc.a", deps + "/lib/libmpfr.a", deps + "/lib/libgmp.a", "-o", "verify-math"], build);
+  await command([build + "/verify-math"], build);
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dr. John (醫者小智)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/initramfs/usr/lib/bootstrap/LICENSES/MIT-ZilchOS-bootstrap-from-tcc.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Alexander Sosedkin.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/initramfs/usr/lib/bootstrap/NOTICE.md

@@ -0,0 +1,65 @@
+# Bootstrap credits and third-party notices
+
+Original Buninu bootstrap work uses the MIT license in `LICENSE`.
+Third-party components retain the terms below.
+
+## ZilchOS bootstrap-from-tcc
+
+- Credit: [ZilchOS/bootstrap-from-tcc](https://github.com/ZilchOS/bootstrap-from-tcc).
+- Author/copyright: Copyright (c) 2021 Alexander Sosedkin.
+- License: MIT; the complete, unmodified notice is in
+  [LICENSES/MIT-ZilchOS-bootstrap-from-tcc.txt](LICENSES/MIT-ZilchOS-bootstrap-from-tcc.txt).
+- Reference checkout: `d2f9454b34fef570cfb32cf5b17d85a90dba81bf`.
+- Buninu's TinyCC-to-GCC bootstrap route was developed with this project's
+  route and recipes as references, particularly GNU Make's no-make bootstrap
+  and self-rebuild, Binutils configuration, and the transition to GCC 4.
+- Buninu adapts that approach to Bun.cc, bunmsh, musl and native ARM64/x64;
+  its JavaScript stages, layout and local compatibility edits differ from the
+  original recipes. This credit does not imply upstream verification or endorsement.
+- ZilchOS's MIT license covers its own work, not the independent packages
+  downloaded or compiled by either project's recipes.
+
+## Sources bundled with Buninu Linux
+
+| Material | License/provenance |
+| --- | --- |
+| musl 1.2.6 | MIT; original `COPYRIGHT` remains in the source archive and `/bootstrap/src/musl/COPYRIGHT` |
+| TinyCC `05f0faf` | Compiler principally LGPL-2.1-or-later; original `COPYING` and individual source notices remain in `/bootstrap/src/tinycc` |
+| TinyCC runtime helpers | Per-file terms apply; for example `lib/libtcc1.c` carries GPL-2.0-or-later with an additional linking permission, retained verbatim in the upstream archive |
+| Local bootstrap overlay and JS scripts | Buninu Linux's MIT terms for original local work; third-party material keeps its own terms and notices |
+
+- Archives are under `sources/` in the outer package; SHA-256 pins are in
+  `lib/seed.js`. Stage 1 extracts them without stripping copyright notices.
+- The overlay supplies local configuration, build entry points and smoke tests.
+  Compiling or including upstream TinyCC source does not relicense that source.
+- The musl ARM64 startup adjustment is a temporary local header override;
+  the original musl source and copyright notice are retained.
+
+## Sources fetched by stages 5–12
+
+These archives and their resulting binaries are not prebundled in the npm
+package. Fixed URLs and SHA-256 pins are in `downloads.md`. Downloads preserve
+upstream license texts and individual file notices in `/bootstrap/src`.
+
+| Stage | Package | Principal code license / upstream notice |
+| --- | --- | --- |
+| 5 | GNU Make 4.4.1 | GPL-3.0-or-later; `COPYING` |
+| 6 | GNU Binutils 2.39 | GPL-3.0-or-later for the main tools; component-specific terms also apply; `COPYING*` and source headers |
+| 7 | GMP 4.3.2 | LGPL-3.0-or-later for the library; `COPYING.LIB`, with GPL text in `COPYING` |
+| 8 | MPFR 2.4.2 | LGPL-2.1-or-later for the library; `COPYING.LIB` |
+| 9 | MPC 0.8.1 | LGPL-2.1-or-later for the library; `COPYING.LIB` |
+| 10 | GNU m4 1.4.18 | GPL-3.0-or-later; `COPYING` |
+| 11 | Flex 2.6.4 | Upstream BSD-style license; preserve its exact `COPYING` text |
+| 12 | GCC 4.7 vendor commit `9d2b63d100ae7c99ee8b128fb41086fd85c8f57d` | Compiler GPL-3.0-or-later; libgcc files carry their own notices and GCC Runtime Library Exception 3.1 where stated; `COPYING3`, `COPYING.RUNTIME`, other `COPYING*` and source headers |
+
+- This table summarizes the principal code licenses; manuals, bundled support
+  code and individual files may carry other terms. Their original notices govern.
+- Stage 12 preserves the top-level license texts for GCC, Binutils and linked
+  numerical libraries under `/bootstrap/result/share/licenses/`, together with
+  this bootstrap credit and the ZilchOS MIT license.
+- License texts alone are not Corresponding Source. A distributor of compiled
+  results must also retain/provide the applicable source and local changes as
+  required by the relevant licenses; the pinned downloads and shipped recipes
+  document the inputs and modifications.
+- Prebuilt Bun, musl, libgcc, libstdc++ and bunmsh remain separately licensed
+  seed components; see the outer package's `NOTICE.md` and application notices.