Name update

crates/ipxe-assets/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "pxeforge-ipxe-assets"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+description = "Bundled iPXE binaries and default chain scripts for PXEForge"
+
+[lints]
+workspace = true
+
+[dependencies]
+pxeforge-core.workspace = true
+rust-embed.workspace = true
+tracing.workspace = true
+thiserror.workspace = true

crates/ipxe-assets/src/lib.rs

@@ -0,0 +1,70 @@
+//! Bundled iPXE boot binaries and default chain script.
+//!
+//! At build time, we expect the iPXE binaries to live at `assets/ipxe/` at
+//! the workspace root. They are embedded into the PXEForge binary via
+//! `rust-embed` so the container image is self-contained. If a binary is
+//! missing, that architecture simply won't have PXE support — we log at
+//! startup and serve what we have.
+//!
+//! Filename convention (matches `ClientArch::ipxe_bootfile`):
+//!   - `undionly.kpxe`       — Legacy x86 BIOS
+//!   - `snponly-i386.efi`    — IA32 UEFI
+//!   - `snponly.efi`         — x86_64 UEFI
+//!   - `snponly-arm32.efi`   — ARM32 UEFI
+//!   - `snponly-arm64.efi`   — ARM64 UEFI
+//!   - `ipxe.efi` (fallback) — UEFI with bundled drivers, if snponly fails on a NIC
+//!   - `wimboot`             — Windows boot shim (fetched separately for WIM chains)
+#![forbid(unsafe_code)]
+
+use pxeforge_core::ClientArch;
+use rust_embed::Embed;
+
+#[derive(Embed)]
+#[folder = "../../assets/ipxe/"]
+#[include = "*.kpxe"]
+#[include = "*.efi"]
+#[include = "wimboot"]
+pub struct IpxeAssets;
+
+/// Return the embedded iPXE binary for `arch`, or `None` if we didn't bundle
+/// one for that architecture.
+#[must_use]
+pub fn bootfile_bytes(arch: ClientArch) -> Option<Vec<u8>> {
+    let name = arch.ipxe_bootfile()?;
+    IpxeAssets::get(name).map(|f| f.data.into_owned())
+}
+
+/// Return a named asset directly (e.g. `wimboot`, or a fallback `ipxe.efi`).
+#[must_use]
+pub fn asset_bytes(name: &str) -> Option<Vec<u8>> {
+    IpxeAssets::get(name).map(|f| f.data.into_owned())
+}
+
+/// Enumerate embedded asset filenames. Useful for startup logging so the
+/// operator can immediately tell which architectures will work.
+pub fn list_assets() -> Vec<String> {
+    IpxeAssets::iter().map(|c| c.into_owned()).collect()
+}
+
+/// Log at startup which iPXE binaries are present and which are missing.
+pub fn log_availability() {
+    let have: std::collections::HashSet<String> = list_assets().into_iter().collect();
+    let needed = [
+        (ClientArch::LegacyX86, "undionly.kpxe"),
+        (ClientArch::Ia32Uefi, "snponly-i386.efi"),
+        (ClientArch::X64Uefi, "snponly.efi"),
+        // ARM32 UEFI deferred — no upstream snponly binary published.
+        (ClientArch::Arm64Uefi, "snponly-arm64.efi"),
+    ];
+    for (arch, name) in needed {
+        if have.contains(name) {
+            tracing::info!(target: "pxeforge::ipxe", "bundled iPXE for {}: {}", arch.as_str(), name);
+        } else {
+            tracing::warn!(
+                target: "pxeforge::ipxe",
+                "MISSING iPXE binary for {}: {} — clients of this arch will not PXE boot",
+                arch.as_str(), name
+            );
+        }
+    }
+}