buninu-linux 0.13.56 → 0.15.58

package/initramfs/lib/bunterm/vt-menu.js

@@ -0,0 +1,181 @@
+// Local overlay; none of its input is sent to the PTY.
+import { StringDecoder } from "node:string_decoder";
+
+export function createVtMenu({ list, select, create = null, changed, width, height, rowHeight, controls = null }) {
+  let row = Math.max(24, Math.ceil(rowHeight + 8));
+  let capacity = Math.max(1, Math.floor(height / row) - 2);
+  const panelWidth = Math.min(width, 420);
+  let entries = null, selected = 0, offset = 0, swallow = false;
+  let command = [], caret = 0, editing = false, status = "", escape = "";
+  let decoder = new StringDecoder("utf8");
+  let creating = false;
+  const layout = () => {
+    row = Math.max(24, Math.ceil((controls?.cellHeight?.() ?? rowHeight) + 8));
+    capacity = Math.max(1, Math.floor(height / row) - 2);
+    if (selected >= offset + capacity) offset = selected - capacity + 1;
+  };
+  const close = () => { entries = null; editing = false; changed(); };
+  const move = delta => {
+    selected = Math.max(0, Math.min(entries.length - 1, selected + delta));
+    offset = Math.max(0, Math.min(offset, selected));
+    if (selected >= offset + capacity) offset = selected - capacity + 1;
+    changed();
+  };
+  const run = (line) => {
+    // Promise.resolve().then also catches synchronous callbacks.
+    Promise.resolve().then(() => controls.execute(line)).then(message => {
+      status = message || ""; changed();
+    }).catch(error => { status = error.message; changed(); });
+  };
+  const choose = (right = false) => {
+    const target = entries[selected];
+    if (target?.kind === "create") {
+      if (creating) return;
+      creating = true;
+      status = "啟動中 / Starting…"; changed();
+      Promise.resolve().then(() => create(controls.fontSize())).then(() => close())
+        .catch(error => { status = error.message; changed(); })
+        .finally(() => { creating = false; });
+      return;
+    }
+    if (target?.kind === "font") { run(`font ${right ? "+" : "-"}`); return; }
+    if (target?.kind === "clipboard") {
+      run(right ? "paste" : "copy");
+      return;
+    }
+    if (target?.kind === "command") { editing = true; changed(); return; }
+    close(); if (target) select(target.number);
+  };
+  return {
+    get visible() { return entries !== null; },
+    close,
+    pointer(report) {
+      layout();
+      if (swallow && !entries) {
+        if (!Object.values(report.buttons).some(Boolean)) swallow = false;
+        return true;
+      }
+      if (!entries) {
+        if (report.x < 0 || report.y < 0 || report.x >= 2 || report.y >= 2 || !report.pressed.includes("left")) return false;
+        entries = [...(controls ? [{kind:"font"}, {kind:"clipboard"}, {kind:"command"}] : []), ...list(),
+          ...(create && controls ? [{kind:"create",label:"+ 新增 bunterm / New bunterm"}] : [])];
+        selected = 0; offset = 0; swallow = true; status = ""; escape = "";
+        decoder = new StringDecoder("utf8"); changed(); return true;
+      }
+      swallow = Object.values(report.buttons).some(Boolean);
+      if (report.wheel) move(-Math.sign(report.wheel));
+      const index = Math.floor(report.y / row) - 1 + offset;
+      const inside = report.x >= 0 && report.x < panelWidth && report.y >= row && index >= offset && index < Math.min(entries.length, offset + capacity);
+      if (inside && report.moved && !editing) { selected = index; changed(); }
+      if (report.pressed.includes("left")) {
+        swallow = true;
+        if (controls?.toggleFps && report.y >= 0 && report.y < row &&
+            report.x >= Math.max(0,panelWidth-112) && report.x < panelWidth) {
+          controls.toggleFps(); changed(); return true;
+        }
+        if (inside) {
+          selected = index; editing = false;
+          if (entries[index].kind !== "font" || report.x < 64 || report.x >= panelWidth-64)
+            choose(report.x >= panelWidth/2);
+          else changed();
+        } else close();
+      } else if (report.pressed.includes("right")) { swallow = true; close(); }
+      return true;
+    },
+    input(bytes) {
+      if (!entries) return false;
+      layout();
+      const text = decoder.write(bytes);
+      if (text === "\x1b" && !escape || text === "\x03") { close(); return true; }
+      // Parse multiple keys in one console read, retaining incomplete CSI/SS3.
+      const input = escape + text; escape = "";
+      for (let i = 0; i < input.length;) {
+        let key = String.fromCodePoint(input.codePointAt(i));
+        if (key === "\x1b") {
+          const rest = input.slice(i);
+          const match = /^\x1b(?:\[[0-9;]*[A-Za-z~]|O[A-Za-z])/.exec(rest);
+          if (!match) { if (/^\x1b(?:\[[0-9;]*|O)?$/.test(rest)) escape = rest; break; }
+          key = match[0];
+        }
+        i += key.length;
+        if (key === "\x03") { close(); break; }
+        if (key === "\t" && controls) {
+          editing = !editing;
+          if (editing && controls) { selected = 2; move(0); }
+        } else if (editing) {
+          if (key === "\r" || key === "\n") { run(command.join("")); command = []; caret = 0; }
+          else if (key === "\x7f" || key === "\b") { if (caret) command.splice(--caret,1); }
+          else if (key === "\x1b[3~") command.splice(caret,1);
+          else if (["\x1b[D","\x1bOD"].includes(key)) caret = Math.max(0,caret-1);
+          else if (["\x1b[C","\x1bOC"].includes(key)) caret = Math.min(command.length,caret+1);
+          else if (["\x01","\x1b[H","\x1bOH"].includes(key)) caret = 0;
+          else if (["\x05","\x1b[F","\x1bOF"].includes(key)) caret = command.length;
+          else if (key === "\x15") { command = []; caret = 0; }
+          else if (key.codePointAt(0) >= 32 && !key.startsWith("\x1b") && command.length < 1024) command.splice(caret++,0,key);
+        } else if (["\x1b[A", "\x1bOA", "k"].includes(key)) move(-1);
+        else if (["\x1b[B", "\x1bOB", "j"].includes(key)) move(1);
+        else if (key === "\r" || key === "\n") { choose(); if (!entries) break; }
+        else if (controls && ["+","-","\x1b[C","\x1b[D"].includes(key) && entries[selected]?.kind === "font")
+          choose(key === "+" || key === "\x1b[C");
+        else if (controls && entries[selected]?.kind === "clipboard" && ["c","p","\x1b[C","\x1b[D"].includes(key))
+          choose(key === "p" || key === "\x1b[C");
+      }
+      changed();
+      return true;
+    },
+    draw(renderer) {
+      if (!entries) return;
+      layout();
+      const { canvas, CanvasKit } = renderer;
+      const visible = entries.slice(offset, offset + capacity);
+      const rect = (y, color) => canvas.drawRect(CanvasKit.XYWHRect(0, y, panelWidth, row), renderer.paintFor(color));
+      const text = (value, y, x = 8, span = panelWidth - 16, align = "left") => renderer.drawText(value, x, y + (row - renderer.cellHeight) / 2,
+        Math.max(1, Math.floor(span / renderer.cellWidth)), [240, 240, 240], {align});
+      canvas.save();
+      canvas.clipRect(CanvasKit.XYWHRect(0, 0, panelWidth, Math.min(height, (visible.length + 2) * row)), CanvasKit.ClipOp.Intersect, false);
+      rect(0, [35, 40, 48]);
+      const fpsWidth = controls?.toggleFps ? Math.min(panelWidth,112) : 0;
+      text(controls ? "bunterm" : "Switch terminal",0,8,Math.max(1,panelWidth-fpsWidth-16));
+      if (fpsWidth) {
+        canvas.drawRect(CanvasKit.XYWHRect(panelWidth-fpsWidth,2,fpsWidth-2,row-4),
+          renderer.paintFor(controls.fpsEnabled()?[35,100,110]:[55,65,75]));
+        text(controls.fpsEnabled() ? "[FPS ✓]" : "[FPS]",0,panelWidth-fpsWidth+4,fpsWidth-10,"center");
+      }
+      visible.forEach((entry, i) => {
+        const y = (i + 1) * row;
+        rect(y, i + offset === selected ? [45, 80, 125] : [25, 29, 35]);
+        if (entry.kind === "font") {
+          // Use equal, cell-aligned button widths. Centered text scales to
+          // fit at large font sizes instead of clipping the closing bracket.
+          const buttonWidth = Math.max(1,Math.floor(48/renderer.cellWidth))*renderer.cellWidth;
+          const labelStart = buttonWidth+16;
+          text("[-]",y,8,buttonWidth,"center");
+          text(`🔤 字體 Font ${controls.fontSize()}`,y,labelStart,Math.max(1,panelWidth-labelStart*2),"center");
+          text("[+]",y,Math.max(8,panelWidth-8-buttonWidth),buttonWidth,"center");
+          return;
+        }
+        if (entry.kind === "clipboard") {
+          text("📋 複製 Copy",y,8,panelWidth/2-16);
+          text("📥 貼上 Paste",y,panelWidth/2+8,panelWidth/2-16);
+          return;
+        }
+        if (entry.kind === "command") {
+          canvas.drawRect(CanvasKit.XYWHRect(4,y+2,panelWidth-8,row-4),renderer.paintFor(editing?[80,170,220]:[85,95,105]));
+          canvas.drawRect(CanvasKit.XYWHRect(5,y+3,panelWidth-10,row-6),renderer.paintFor([225,230,235]));
+          const placeholder = !command.length && !editing;
+          const label = placeholder ? "Click to type a command…"
+            : `${command.slice(Math.max(0,caret-24),caret).join("")}${editing?"│":""}${command.slice(caret).join("")}`;
+          renderer.drawText(label,10,y+(row-renderer.cellHeight)/2,
+            Math.max(1,Math.floor((panelWidth-20)/renderer.cellWidth)),
+            placeholder?[100,110,120]:[20,25,30],{align:"left"});
+          return;
+        }
+        const label = `${entry.label}${entry.current ? " (current)" : ""}`;
+        text(label, y);
+      });
+      const y = (visible.length + 1) * row;
+      rect(y, [35, 40, 48]); text(status || (controls ? "Tab: command · Enter · Esc" : "↑↓ / wheel · Enter · Esc"), y);
+      canvas.restore();
+    },
+  };
+}

package/initramfs/lib/bunterm/vt.js

@@ -6,7 +6,7 @@
 // hold the console device open.  Both facts live under /proc/<pid> and disappear
 // with the process; there is no persistent pid or lock file to become stale.
 
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
 import { libc, cString, check } from "../dlopen.js";
 
 const PR_SET_NAME = 15;
@@ -89,3 +89,29 @@ Switch between TTYs by Ctrl+Alt+F1-12
     try { setTaskName(previousName); } catch {}
   };
 };
+
+// Discover live owners using the same task-name + device-fd contract as claim.
+export const listVirtualTerminals = () => {
+  let initial = 1;
+  try {
+    initial = virtualConsoleNumber(readlinkSync("/proc/1/fd/0")) ?? 1;
+  } catch {}
+  const entries = new Map([[initial, { number: initial, label: `tty${initial} — initial console` }]]);
+  for (const pid of readdirSync("/proc").filter(name => /^\d+$/.test(name))) {
+    try {
+      const match = /^bunterm:tty([1-9][0-9]*)$/.exec(readFileSync(`/proc/${pid}/comm`, "utf8").trim());
+      if (!match) continue;
+      const number = Number(match[1]);
+      if (number > 63 || !processHoldsDevice(pid, statSync(`/dev/tty${number}`).rdev)) continue;
+      entries.set(number, { number, label: `tty${number} — bunterm${number === initial ? " / initial console" : ""}` });
+    } catch {} // processes can exit during the scan
+  }
+  return [...entries.values()].sort((a, b) => a.number - b.number);
+};
+
+// Match the menu: append after the last known session, reserving tty1.
+export const nextVirtualTerminal = (entries = listVirtualTerminals()) => {
+  const number = Math.max(1, ...entries.map(entry => entry.number)) + 1;
+  if (number > 63) throw new Error("沒有可用 tty / No next tty available");
+  return number;
+};

package/initramfs/lib/canvas.js

@@ -1,3 +1,4 @@
+import {rawImageData, rawImageOpaque, skiaImage} from './raw-image.js';
 // /lib/canvas.js — CanvasKit (Skia in WebAssembly) on the Linux framebuffer.
 //
 // Skia draws into a buffer inside the wasm heap that already has the
@@ -80,6 +81,17 @@ export const openCanvas = (CanvasKit, display) => {
   memory.toTypedArray().set(previousPixels.subarray(0, length));
   display.pixels = memory.toTypedArray();
   let open = true;
+  let cachedImage = null, cachedOpaque = false;
+  let imageMemory = null, imageCapacity = 0;
+  const directRaw = (image, rect, source) => {
+    const raw = rawImageData(image);
+    if (!raw || display.bitsPerPixel !== 32 || raw.colorType !== colorType) return null;
+    const [left, top, right, bottom] = rect, [sx, sy, ex, ey] = source;
+    if (![...rect, ...source].every(Number.isInteger)
+        || right - left !== ex - sx || bottom - top !== ey - sy
+        || sx < 0 || sy < 0 || ex > raw.width || ey > raw.height || ex <= sx || ey <= sy) return null;
+    return rawImageOpaque(raw) ? raw : null;
+  };
   return {
     CanvasKit,
     display,
@@ -88,6 +100,90 @@ export const openCanvas = (CanvasKit, display) => {
     colorType,
     width: display.width,
     height: display.height,
+    // Only exact, opaque 32-bit copies bypass Skia. Keep at most one decoded
+    // image (32 MiB); scaled, translucent and 16-bit images use normal drawing.
+    canDrawRawImage(image, rect, source) { return Boolean(directRaw(image, rect, source)); },
+    drawOpaqueImage(image, rect, source, bands) {
+      if (!open) throw new Error("canvas is closed");
+      const [left, top, right, bottom] = rect;
+      const [sx, sy, ex, ey] = source;
+      const width = image.width(), height = image.height();
+      if (display.bitsPerPixel !== 32 || ![...rect, ...source].every(Number.isInteger)
+          || right - left !== ex - sx || bottom - top !== ey - sy
+          || sx < 0 || sy < 0 || ex > width || ey > height
+          || ex <= sx || ey <= sy || width * height * 4 > 32 * 1024 * 1024) return false;
+      const raw = directRaw(image, rect, source);
+      if (!raw) image = skiaImage(image);
+      if (!raw && cachedImage !== image) {
+        cachedImage = image;
+        cachedOpaque = false;
+        const size = width * height * 4;
+        if (size > imageCapacity) {
+          if (imageMemory) CanvasKit.Free(imageMemory);
+          imageMemory = CanvasKit.Malloc(Uint8Array, size);
+          imageCapacity = size;
+        }
+        // Supplying a destination bypasses CanvasKit's JS return-type switch,
+        // which otherwise rejects BGRA and copies supported formats out of WASM.
+        const info = {width, height, colorType,
+          alphaType: CanvasKit.AlphaType.Unpremul, colorSpace: CanvasKit.ColorSpace.SRGB};
+        let pixels = image.readPixels(0, 0, info, imageMemory, width * 4);
+        let swap = false;
+        if (!pixels && colorType === CanvasKit.ColorType.BGRA_8888) {
+          pixels = image.readPixels(0, 0, {...info, colorType: CanvasKit.ColorType.RGBA_8888}, imageMemory, width * 4);
+          swap = true;
+        }
+        if (pixels) {
+          cachedOpaque = true;
+          for (let i = 0; i < size; i += 4) {
+            if (pixels[i + 3] !== 255) { cachedOpaque = false; break; }
+            if (swap) {
+              const red = pixels[i]; pixels[i] = pixels[i + 2]; pixels[i + 2] = red;
+            }
+          }
+        }
+      }
+      if (!raw && !cachedOpaque) return false;
+      surface.flush();
+      // Drawing elsewhere can grow the WASM heap between cache hits.
+      const sourcePixels = raw ? raw.pixels : imageMemory.toTypedArray();
+      const target = memory.toTypedArray();
+      const x0 = Math.max(0, left), x1 = Math.min(display.width, right);
+      if (x1 <= x0) return true;
+      for (const [bandTop, bandBottom] of bands) {
+        const y0 = Math.max(0, top, bandTop), y1 = Math.min(display.height, bottom, bandBottom);
+        for (let y = y0; y < y1; y++) {
+          const offset = ((sy + y - top) * width + sx + x0 - left) * 4;
+          target.set(sourcePixels.subarray(offset, offset + (x1 - x0) * 4), y * display.stride + x0 * 4);
+        }
+      }
+      return true;
+    },
+    // Save/restore small overlays in native pixel format, without decoding or
+    // channel conversion. Refresh the WASM view after every possible allocation.
+    saveRegion(left, top, right, bottom) {
+      if (!open) throw new Error("canvas is closed");
+      surface.flush();
+      const x = Math.max(0, Math.min(display.width, Math.floor(left))), y = Math.max(0, Math.min(display.height, Math.floor(top)));
+      const width = Math.max(0, Math.min(display.width, Math.ceil(right)) - x);
+      const height = Math.max(0, Math.min(display.height, Math.ceil(bottom)) - y);
+      const rowBytes = width * (display.bitsPerPixel / 8);
+      const pixels = new Uint8Array(rowBytes * height), source = memory.toTypedArray();
+      for (let row = 0; row < height; row++) {
+        const offset = (y + row) * display.stride + x * (display.bitsPerPixel / 8);
+        pixels.set(source.subarray(offset, offset + rowBytes), row * rowBytes);
+      }
+      return {x, y, height, rowBytes, pixels};
+    },
+    restoreRegion(region) {
+      if (!open) throw new Error("canvas is closed");
+      surface.flush();
+      const target = memory.toTypedArray();
+      for (let row = 0; row < region.height; row++) {
+        target.set(region.pixels.subarray(row * region.rowBytes, (row + 1) * region.rowBytes),
+          (region.y + row) * display.stride + region.x * (display.bitsPerPixel / 8));
+      }
+    },
     // Finishes pending Skia work and copies the frame to the framebuffer.
     // toTypedArray() is re-read because wasm heap growth detaches old views.
     flush() {
@@ -101,6 +197,9 @@ export const openCanvas = (CanvasKit, display) => {
     close() {
       if (!open) return;
       open = false;
+      cachedImage = null; cachedOpaque = false;
+      if (imageMemory) CanvasKit.Free(imageMemory);
+      imageMemory = null; imageCapacity = 0;
       previousPixels.set(memory.toTypedArray().subarray(0, previousPixels.length));
       display.pixels = previousPixels;
       surface.delete();

package/initramfs/lib/chvt.js

@@ -0,0 +1,31 @@
+// Use the same VT_ACTIVATE/VT_WAITACTIVE path as bunterm. Never take VT ownership.
+export function parseChvt(args) {
+  if (args.length === 1 && ["-h", "--help"].includes(args[0])) return { help: true };
+  if (args.length !== 1 || !/^[0-9]+$/.test(args[0]) || Number(args[0]) < 1 || Number(args[0]) > 63)
+    throw new Error("usage: chvt N (1–63); see chvt -h or --help");
+  return { number: Number(args[0]) };
+}
+
+export async function switchVt(number, backend) {
+  if (!Number.isInteger(number) || number < 1 || number > 63) throw new Error("VT number must be 1–63");
+  const { openConsole, activeConsole, activateConsole } = backend ?? await import("./fbdev.js");
+  const failures = [];
+  let consoleDevice;
+  // /dev/tty in bunterm is a PTY, and /dev/console may be a serial console.
+  // Probe VT_GETSTATE before accepting an open fd.
+  for (const path of ["/dev/tty0", "/dev/tty", "/dev/console"]) {
+    let candidate;
+    try {
+      candidate = openConsole([path]);
+      activeConsole(candidate);
+      consoleDevice = candidate;
+      break;
+    } catch (error) {
+      candidate?.close();
+      failures.push(`${path}: ${error.message}`);
+    }
+  }
+  if (!consoleDevice) throw new Error(`no accessible Linux VT (${failures.join("; ")})`);
+  try { activateConsole(consoleDevice, number); }
+  finally { consoleDevice.close(); }
+}

package/initramfs/lib/dhclient.js

@@ -0,0 +1,135 @@
+import {readFileSync,writeFileSync,mkdirSync,renameSync,unlinkSync,openSync,closeSync} from 'node:fs';
+import {dirname,resolve} from 'node:path';
+import {DhcpClient} from './dhcp.js';
+import {interfaceInfo,openTransport} from './dhcp-transport.js';
+export function parseDhclient(args) {
+  const o={timeout:60,dns:true,resolv:'/etc/resolv.conf',once:true,release:false,verbose:false};
+  for(let i=0;i<args.length;i++){
+    const a=args[i];
+    if(['--help','-h','-help'].includes(a))return {...o,help:true};
+    if(a==='-4'||a==='-d')continue;
+    if(a==='-1')o.once=true;
+    else if(a==='-r')o.release=true;
+    else if(a==='-v')o.verbose=true;
+    else if(a==='-q')o.quiet=true;
+    else if(a==='--no-dns')o.dns=false;
+    else if(['-timeout','-lf','-H','--resolv-conf','--metric'].includes(a)){
+      const value=args[++i];if(!value||value.startsWith('-'))throw new Error(`${a} requires a value`);
+      if(a==='-timeout'){o.timeout=Number(value);if(!Number.isFinite(o.timeout)||o.timeout<=0)throw new Error('timeout must be positive');}
+      if(a==='--metric'){o.metric=Number(value);if(!Number.isInteger(o.metric)||o.metric<0||o.metric>32766)throw new Error('metric must be between 0 and 32766');}
+      if(a==='-lf')o.leaseFile=resolve(value);
+      if(a==='-H'){if(!/^[a-zA-Z0-9][a-zA-Z0-9.-]{0,252}$/.test(value))throw new Error('invalid hostname');o.hostname=value;}
+      if(a==='--resolv-conf')o.resolv=resolve(value);
+    }else if(a.startsWith('-'))throw new Error(`unsupported option: ${a} (DHCPv4 only; see --help)`);
+    else if(o.interface)throw new Error('specify one interface per process');
+    else o.interface=a;
+  }
+  if(!o.interface||!/^[a-zA-Z0-9_.:-]{1,15}$/.test(o.interface))throw new Error('specify an Ethernet interface, e.g. dhclient usb0. Use ip link to list network interfaces; use dhclient -h or dhclient --help for help.');
+  o.leaseFile??=`/var/lib/dhclient/${o.interface}.json`;
+  if(args.includes('-1')&&o.release)throw new Error('-1 and -r cannot be combined');
+  return o;
+}
+export async function runIp(args) {
+  const p=Bun.spawn([process.execPath,`${import.meta.dir}/../bin/ip`,...args],{stdout:'pipe',stderr:'pipe'});
+  const [status,out,err]=await Promise.all([p.exited,new Response(p.stdout).text(),new Response(p.stderr).text()]);
+  if(status)throw new Error(`ip ${args.join(' ')}: ${err.trim()||out.trim()}`);
+  return out;
+}
+const readOptional=path=>{try{return readFileSync(path,'utf8');}catch(e){if(e.code==='ENOENT')return null;throw e;}};
+export function saveLease(path,lease) {
+  mkdirSync(dirname(path),{recursive:true});const tmp=`${path}.${process.pid}.tmp`;
+  writeFileSync(tmp,JSON.stringify(lease,null,2)+'\n',{mode:0o600});renameSync(tmp,path);
+}
+export class Configuration {
+  constructor(options,ip=runIp){this.options=options;this.ip=ip;}
+  metric(lease){return lease.metric===undefined?[]:['metric',String(lease.metric)];}
+  async apply(lease,previous) {
+    const o=this.options;
+    lease.metric=o.metric;
+    if(previous&&previous.routers[0]!==lease.routers[0])await this.removeRoute(previous);
+    await this.ip(['addr','replace',`${lease.address}/${lease.prefix}`,'brd','+','dev',o.interface]);
+    if(lease.routers[0])await this.ip(['route','replace','default','via',lease.routers[0],'dev',o.interface,...this.metric(lease)]);
+    if(previous?.resolver)lease.resolver=previous.resolver;
+    if(o.dns&&lease.dns.length){
+      const content=`# dhclient ${o.interface}\n`+lease.dns.map(ip=>`nameserver ${ip}\n`).join('');
+      const old=lease.resolver;
+      // Keep the original resolver across repeated invocations, unless another writer took over.
+      const current=readOptional(o.resolv);
+      lease.resolver={path:o.resolv,before:old?.path===o.resolv&&current===old.written?old.before:current,written:content};
+      writeFileSync(o.resolv,content);
+    }
+  }
+  async removeRoute(lease) {
+    if(!lease.routers[0])return;
+    try{await this.ip(['route','del','default','via',lease.routers[0],'dev',this.options.interface,...this.metric(lease)]);}
+    catch(e){if(!/No such process|No such device|Cannot find device/.test(e.message))throw e;}
+  }
+  async clear(lease) {
+    const errors=[];
+    try{await this.removeRoute(lease);}catch(e){errors.push(e);}
+    // ip addr del checks the current address before deleting it.
+    try{await this.ip(['addr','del',`${lease.address}/${lease.prefix}`,'dev',this.options.interface]);}
+    catch(e){if(!/Cannot assign requested address|Cannot find device/.test(e.message))errors.push(e);}
+    try{
+      const r=lease.resolver;
+      if(r&&readOptional(r.path)===r.written){if(r.before===null)unlinkSync(r.path);else writeFileSync(r.path,r.before);}
+    }catch(e){errors.push(e);}
+    if(errors.length)throw new AggregateError(errors,errors.map(e=>e.message).join('; '));
+  }
+}
+// A command invocation acquires once and exits. There is no renewal daemon.
+export async function manageLease(client,config,{previous,signal,log=console.log,save=()=>{},forget=()=>{}}={}) {
+  let lease,kept=false;
+  try {
+    lease=await client.acquire();
+    if(!lease){if(signal?.aborted)return 0;throw new Error('no DHCP lease received before timeout');}
+    if(signal?.aborted)return 0;
+    await config.apply(lease,previous);await save(lease);
+    log(`bound to ${lease.address}/${lease.prefix}, lease ${lease.seconds}s; configured and exiting (no automatic renewal)`);
+    kept=true;return 0;
+  }finally{
+    if(lease&&!kept){
+      try{client.release(lease);}catch(e){log(`release: ${e.message}`);}
+      await config.clear(lease);await forget();
+    }
+  }
+}
+export async function runDhclient(o) {
+  if(!['linux','android'].includes(process.platform))throw new Error('dhclient requires Linux/Android networking');
+  // Serialize this interface even when callers choose different lease files.
+  const lock=`/run/dhclient-${o.interface}.lock`;mkdirSync(dirname(lock),{recursive:true});
+  let handle;
+  try{handle=openSync(lock,'wx',0o600);}catch(e){if(e.code==='EEXIST')throw new Error(`${lock} exists; stop the other client, or remove this lock if its process died`);throw e;}
+  writeFileSync(handle,`${process.pid}\n`);
+  let transport;
+  const controller=new AbortController(),stop=()=>controller.abort();
+  process.on('SIGINT',stop);process.on('SIGTERM',stop);
+  const log=message=>{if(!o.quiet)console.log(`dhclient: ${message}`);};
+  const forget=()=>{try{unlinkSync(o.leaseFile);}catch(e){if(e.code!=='ENOENT')throw e;}};
+  try{
+    const info=interfaceInfo(o.interface);
+    await runIp(['link','set','dev',o.interface,'up']);
+    try { transport=openTransport(o.interface,info); }
+    catch(error) {
+      if(error.errno!==97)throw error; // EAFNOSUPPORT: Alpine ships AF_PACKET as a module.
+      const {modprobe}=await import('./modprobe.js');
+      modprobe('af_packet');transport=openTransport(o.interface,info);
+    }
+    const client=new DhcpClient({transport,...info,...o,signal:controller.signal,log:o.verbose?log:()=>{}});
+    const config=new Configuration(o);
+    if(o.release){
+      const text=readOptional(o.leaseFile);if(!text)throw new Error(`no saved lease: ${o.leaseFile}`);
+      const lease=JSON.parse(text);if(lease.interface!==o.interface||lease.mac!==info.mac.toString('hex'))throw new Error('saved lease belongs to another interface');
+      try{client.release(lease);}finally{await config.clear(lease);forget();}log(`released ${lease.address}`);return 0;
+    }
+    let previous;
+    const saved=readOptional(o.leaseFile);
+    if(saved){
+      const candidate=JSON.parse(saved);
+      if(candidate.interface===o.interface&&candidate.mac===info.mac.toString('hex'))previous=candidate;
+    }
+    return await manageLease(client,config,{...o,previous,signal:controller.signal,log,save:lease=>saveLease(o.leaseFile,{...lease,interface:o.interface,mac:info.mac.toString('hex')}),forget});
+  }finally{
+    transport?.close();process.off('SIGINT',stop);process.off('SIGTERM',stop);closeSync(handle);unlinkSync(lock);
+  }
+}

package/initramfs/lib/dhcp-start.js

@@ -0,0 +1,85 @@
+// Best-effort one-shot DHCP for cfg.net. Each interface owns its result and
+// bounded output buffer; a failed link never changes another link's status.
+export function createDhcpLauncher({spawn=(argv,options)=>Bun.spawn(argv,options),log=console.log,
+  acquisitionSeconds=20,watchdogMs=25000,killGraceMs=2000,outputGraceMs=250}={}) {
+  const active=new Map();
+  const messageOf=error=>String(error?.message??error);
+  const clean=text=>String(text).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g,'').replace(/[\x00-\x1f\x7f]/g,' ').trim();
+  const report=(name,message)=>{try{log(`[dhcp ${clean(name)}] ${clean(message)}`);}catch{}};
+  return function startDhcp(interfaces) {
+    const started=[];
+    try {
+      for(const [index,name] of interfaces.entries()) {
+        if(name==='lo'||active.has(name))continue;
+        let child,state;
+        try {
+          if(!/^[a-zA-Z0-9_.:-]{1,15}$/.test(name))throw new Error('invalid interface name');
+          const args=[process.execPath,`${import.meta.dir}/../bin/dhclient`,'-1','-timeout',String(acquisitionSeconds),'--metric',String(100+index)];
+          // Keep a single resolver owner; init already supplies fallback DNS.
+          if(index>0)args.push('--no-dns');
+          args.push(name);
+          child=spawn(args,{stdin:'ignore',stdout:'pipe',stderr:'pipe'});
+          state={child,done:false,timer:null,killTimer:null,timedOut:false,address:null,errors:[],notes:[],readers:[]};active.set(name,state);
+          const remember=(list,text)=>{list.push(clean(text).slice(0,512));if(list.length>4)list.shift();};
+          const kill=signal=>{try{child.kill(signal);}catch(e){remember(state.errors,`${signal}: ${messageOf(e)}`);}};
+          state.timer=setTimeout(()=>{
+            if(state.done)return;
+            state.timedOut=true;kill('SIGTERM');
+            state.killTimer=setTimeout(()=>{if(!state.done)kill('SIGKILL');},killGraceMs);
+            state.killTimer.unref?.();
+          },watchdogMs);state.timer.unref?.();
+          const line=(text,isError)=>{
+            text=clean(text);if(!text)return;
+            const bound=!isError&&/^dhclient: bound to ([^,\s]+)/.exec(text);
+            if(bound)state.address=bound[1];
+            else remember(isError?state.errors:state.notes,text.replace(/^dhclient:\s*/,''));
+          };
+          const drain=async(stream,isError)=>{
+            if(!stream)return;
+            const reader=stream.getReader();state.readers.push(reader);
+            const decoder=new TextDecoder();let pending='';
+            try {
+              for(;;){
+                const {done,value}=await reader.read();if(done)break;
+                pending+=decoder.decode(value,{stream:true});
+                let at;while((at=pending.indexOf('\n'))>=0){line(pending.slice(0,at),isError);pending=pending.slice(at+1);}
+                if(pending.length>4096){line(pending.slice(0,4096),isError);pending='';}
+              }
+              if(pending)line(pending,isError);
+            }finally{reader.releaseLock();}
+          };
+          const drains=[drain(child.stdout,false),drain(child.stderr,true)].map(p=>p.catch(e=>remember(state.errors,`output: ${messageOf(e)}`)));
+          const finish=async(code,error)=>{
+            state.done=true;clearTimeout(state.timer);clearTimeout(state.killTimer);
+            // exited can resolve before the last stderr/stdout chunk arrives.
+            // Bound the wait even if an inherited pipe never closes.
+            let outputTimer;
+            try {
+              await Promise.race([Promise.all(drains),new Promise(resolve=>{outputTimer=setTimeout(resolve,outputGraceMs);})]);
+            }finally{
+              clearTimeout(outputTimer);
+              for(const reader of state.readers){try{void reader.cancel().catch(()=>{});}catch{}}
+              if(active.get(name)===state)active.delete(name);
+            }
+            if(state.timedOut)report(name,`failed: timed out; other interfaces are unaffected`);
+            else if(error!==undefined)report(name,`failed: ${messageOf(error)}`);
+            else if(code===0&&state.address)report(name,`configured ${state.address}; command finished`);
+            else if(code===0)report(name,'finished without configuring an address');
+            else {
+              const detail=state.errors.at(-1)??state.notes.at(-1)??'no error details';
+              report(name,`failed: ${detail} (exit ${code}); other interfaces are unaffected`);
+            }
+          };
+          void Promise.resolve(child.exited).then(code=>finish(code),error=>finish(null,error??'unknown exit error')).catch(e=>report(name,`result unavailable: ${messageOf(e)}`));
+          started.push(name);report(name,'requesting configuration');
+        }catch(error){
+          if(state){clearTimeout(state.timer);clearTimeout(state.killTimer);active.delete(name);}
+          if(child){try{child.kill('SIGKILL');}catch{}}
+          report(name,`failed to start: ${messageOf(error)}; other interfaces are unaffected`);
+        }
+      }
+    }catch(error){report('setup',`failed: ${messageOf(error)}; init continues`);}
+    return started;
+  };
+}
+export const startDhcp=createDhcpLauncher();

package/initramfs/lib/dhcp-transport.js

@@ -0,0 +1,44 @@
+import {libc,ptr,check,errno,SysError,cString,withInetSocket} from './dlopen.js';
+import {ipv4,wrapIPv4,unwrapIPv4} from './dhcp.js';
+export function interfaceInfo(name) {
+  if(!/^[a-zA-Z0-9_.:-]{1,15}$/.test(name))throw new Error('invalid interface name');
+  return withInetSocket(ioctl=>{
+    const req=Buffer.alloc(40);req.write(name);ioctl(0x8933,req,'SIOCGIFINDEX');const index=req.readInt32LE(16);
+    ioctl(0x8927,req,'SIOCGIFHWADDR');if(req.readUInt16LE(16)!==1)throw new Error('DHCP requires an Ethernet-compatible interface');
+    return {index,mac:Buffer.from(req.subarray(18,24))};
+  });
+}
+const sockaddr=(ip,port)=>{const b=Buffer.alloc(16);b.writeUInt16LE(2);b.writeUInt16BE(port,2);ipv4(ip).copy(b,4);return b;};
+export function openTransport(name,{index}) {
+  const f=libc.symbols, descriptors=[];
+  try {
+    // Packet sockets work before the interface has any IPv4 address or route.
+    const raw=check('socket(AF_PACKET): requires CAP_NET_RAW',f.socket(17,2|0x800|0x80000,0x0008));descriptors.push(raw);
+    const link=Buffer.alloc(20);link.writeUInt16LE(17);link.writeUInt16BE(0x0800,2);link.writeInt32LE(index,4);link[11]=6;link.fill(255,12,18);
+    check('bind(AF_PACKET)',f.bind(raw,ptr(link),link.length));
+    // Reserve the client UDP port and use kernel routing/ARP for unicast renew
+    // and release. The packet socket receives both broadcast and unicast replies.
+    const udp=check('socket(UDP)',f.socket(2,2|0x800|0x80000,17));descriptors.push(udp);
+    const device=cString(name);check('SO_BINDTODEVICE',f.setsockopt(udp,1,25,ptr(device),device.length));
+    const local=sockaddr('0.0.0.0',68);check('bind UDP port 68 (another DHCP client may be running)',f.bind(udp,ptr(local),16));
+    const buffer=Buffer.alloc(65535);
+    return {
+      send(payload,server){
+        const destination=server?sockaddr(server,67):link;
+        const bytes=server?payload:wrapIPv4(payload,payload.subarray(12,16).join('.'));
+        check('sendto(DHCP)',Number(f.sendto(server?udp:raw,ptr(bytes),bytes.length,0,ptr(destination),destination.length)));
+      },
+      receive(){
+        // Drain the UDP copy so its receive buffer does not remain full.
+        for(let i=0;i<64;i++)if(f.recv(udp,ptr(buffer),buffer.length,0)<0)break;
+        for(let i=0;i<64;i++){
+          const n=f.recv(raw,ptr(buffer),buffer.length,0);
+          if(n<0){const code=errno();if(code===11||code===4)return null;throw new SysError('recv(DHCP)',code);}
+          const payload=unwrapIPv4(buffer.subarray(0,Number(n)));if(payload)return Buffer.from(payload);
+        }
+        return null;
+      },
+      close(){for(const fd of descriptors.splice(0))f.close(fd);},
+    };
+  }catch(error){for(const fd of descriptors)f.close(fd);throw error;}
+}