path: root/ocaml/lib/boot.ml

(* Boot - Arvo Kernel Boot System
 *
 * This module handles:
 * - Loading pill files (jammed Arvo kernels)
 * - Parsing pill structure
 * - Initial boot sequence
 *
 * Pill Structure:
 * - A pill is a jammed noun containing the Arvo kernel
 * - Format varies, but typically: [kernel-gate initial-state]
 * - Or just the kernel-gate itself
 *)

(* Boot error *)
type error =
  | FileNotFound of string
  | InvalidPill of string
  | BootFailed of string

(* Pill type *)
type pill = {
  kernel: Noun.noun;        (* The Arvo kernel gate *)
  boot_ova: Noun.noun list; (* Initial events to process *)
}

(* Load pill from file using Eio
 *
 * Steps:
 * 1. Read jammed pill file
 * 2. Cue to get kernel noun
 * 3. Parse pill structure
 *)
let load_pill ~fs pill_path =
  try
    Printf.printf "[Boot] Loading pill from %s...\n%!" pill_path;

    (* Read pill file *)
    let file_path = Eio.Path.(fs / pill_path) in
    let pill_bytes = Eio.Path.load file_path |> Bytes.of_string in

    Printf.printf "[Boot] Pill file: %d bytes (%.1f MB)\n%!"
      (Bytes.length pill_bytes)
      (float_of_int (Bytes.length pill_bytes) /. 1024.0 /. 1024.0);

    Printf.printf "[Boot] Cuing pill (this may take a while)...\n%!";
    let start = Unix.gettimeofday () in

    (* Cue the pill to get kernel noun *)
    let kernel_noun = Serial.cue pill_bytes in

    let elapsed = Unix.gettimeofday () -. start in
    Printf.printf "[Boot] Pill cued successfully in %.2f seconds\n%!" elapsed;

    (* For now, treat the entire pill as the kernel
     * In a real implementation, we'd parse the structure:
     *   - Check if it's a cell with [kernel boot-events]
     *   - Or just a single kernel gate
     *)
    Ok {
      kernel = kernel_noun;
      boot_ova = [];  (* No boot events for now *)
    }

  with
  | Sys_error msg ->
      Error (FileNotFound msg)
  | e ->
      Error (InvalidPill (Printexc.to_string e))

(* Create a minimal fake pill for testing
 *
 * This creates a trivial kernel that's just an atom.
 * In reality, the kernel is a huge compiled gate, but for
 * testing we can use this simple version.
 *)
let fake_pill () = {
  kernel = Noun.atom 0;  (* Minimal kernel - just 0 *)
  boot_ova = [];
}

(* Boot Arvo from a pill
 *
 * Steps:
 * 1. Set kernel state to pill's kernel
 * 2. Process boot events if any
 * 3. Initialize event counter to 0
 *)
let boot_from_pill state pill =
  Printf.printf "[Boot] Initializing Arvo kernel...\n%!";

  (* Set kernel state *)
  State.boot state pill.kernel;

  (* Process boot events if any *)
  List.iteri (fun i _ovum ->
    Printf.printf "[Boot] Processing boot event %d\n%!" i;
    (* In real implementation: State.poke state ovum *)
  ) pill.boot_ova;

  Printf.printf "[Boot] ✓ Arvo kernel booted!\n%!";
  Ok ()

(* Boot from pill file - convenience function *)
let boot_from_file ~fs state pill_path =
  match load_pill ~fs pill_path with
  | Error err ->
      let msg = match err with
        | FileNotFound s -> "File not found: " ^ s
        | InvalidPill s -> "Invalid pill: " ^ s
        | BootFailed s -> "Boot failed: " ^ s
      in
      Printf.printf "[Boot] Error: %s\n%!" msg;
      Error msg

  | Ok pill ->
      boot_from_pill state pill

(* Create minimal boot for testing (no pill file needed) *)
let boot_fake state =
  Printf.printf "[Boot] Creating fake minimal kernel...\n%!";
  let pill = fake_pill () in
  boot_from_pill state pill

(* u3v_life: Execute lifecycle formula to produce Arvo kernel
 *
 * From C Vere vortex.c:26:
 *   u3_noun lyf = u3nt(2, u3nc(0, 3), u3nc(0, 2));  // [2 [0 3] [0 2]]
 *   u3_noun gat = u3n_nock_on(eve, lyf);
 *   u3_noun cor = u3k(u3x_at(7, gat));
 *
 * The lifecycle formula [2 [0 3] [0 2]] means:
 * - [0 2] gets slot 2 (head of list) = first event or formula
 * - [0 3] gets slot 3 (tail of list) = rest of events
 * - [2 formula subject] = nock(subject formula)
 * - So this is: nock(tail head) = nock(rest-of-events first-event)
 *
 * CRITICAL: This formula expects a specific list structure!
 * The first item should be a FORMULA, and the rest should be events to process.
 *
 * KEY INSIGHT from running C Vere:
 * - When booting with `-B solid.pill`, Vere FIRST boots an embedded ivory pill
 * - The ivory pill is booted with eve = null (empty list)!
 * - THEN it processes the solid pill's events separately via poke
 *
 * So u3v_life() is used TWICE:
 * 1. On ivory pill with null/empty event list → produces initial kernel
 * 2. On solid pill's bot events → produces updated kernel
 *)
let life eve =
  try
    (* Build lifecycle formula: [2 [0 3] [0 2]] *)
    let lyf = Noun.cell (Noun.atom 2)
      (Noun.cell
        (Noun.cell (Noun.atom 0) (Noun.atom 3))
        (Noun.cell (Noun.atom 0) (Noun.atom 2))) in

    Printf.printf "[Boot] Running lifecycle formula [2 [0 3] [0 2]]...\n%!";

    (* Check if eve is null (for ivory pill boot) *)
    let is_null = match eve with
      | Noun.Atom z when Z.equal z Z.zero -> true
      | _ -> false
    in

    if is_null then
      Printf.printf "[Boot] Lifecycle on NULL event list (ivory pill)\n%!"
    else begin
      (* Debug: check what's in slot 2 and slot 3 *)
      (try
        let slot2 = Noun.slot (Z.of_int 2) eve in
        let slot3 = Noun.slot (Z.of_int 3) eve in
        Printf.printf "[Boot]   Slot 2: %s\n%!"
          (if Noun.is_cell slot2 then "cell" else "atom");
        Printf.printf "[Boot]   Slot 3: %s\n%!"
          (if Noun.is_cell slot3 then "cell" else "atom");
      with _ -> ())
    end;

    (* Run lifecycle formula *)
    let gat =
      try
        Nock.nock_on eve lyf
      with e ->
        Printf.printf "[Boot] ✗ Nock failed during lifecycle: %s\n%!"
          (Printexc.to_string e);
        raise e
    in

    Printf.printf "[Boot] ✓ Lifecycle formula completed\n%!";

    (* Extract slot 7 (the kernel) from resulting gate *)
    let cor =
      try
        Noun.slot (Z.of_int 7) gat
      with e ->
        Printf.printf "[Boot] ✗ Failed to extract slot 7: %s\n%!"
          (Printexc.to_string e);
        raise e
    in

    Printf.printf "[Boot] ✓ Extracted kernel from slot 7\n%!";
    cor

  with e ->
    Printf.printf "[Boot] ✗ u3v_life failed: %s\n%!" (Printexc.to_string e);
    raise e

(* u3v_boot: Full boot sequence with event counting
 *
 * From C Vere vortex.c:39:
 * - Counts events in the list
 * - Calls u3v_life() safely
 * - Stores result in u3A->roc (global kernel state)
 * - Updates event counter u3A->eve_d
 *)
let boot state eve_list =
  (* Count events *)
  let rec count_events acc noun =
    match noun with
    | Noun.Atom _ -> acc
    | Noun.Cell (_, rest) -> count_events (acc + 1) rest
  in
  let event_count = count_events 0 eve_list in

  Printf.printf "[Boot] Booting with %d events\n%!" event_count;

  try
    (* Call u3v_life to produce kernel *)
    let kernel = life eve_list in

    (* Store in state *)
    State.boot state kernel;

    Printf.printf "[Boot] ✓ Boot complete!\n%!";
    Ok ()

  with e ->
    Error ("Boot failed: " ^ Printexc.to_string e)

(* Boot from ivory pill - the lightweight boot sequence
 *
 * Ivory pills have structure: ["ivory" core]
 * The core contains a lifecycle formula that must be executed
 *)
let boot_ivory ~fs state pill_path =
  Printf.printf "[Boot] Booting from ivory pill...\n%!";

  match load_pill ~fs pill_path with
  | Error err ->
      let msg = match err with
        | FileNotFound s -> "File not found: " ^ s
        | InvalidPill s -> "Invalid pill: " ^ s
        | BootFailed s -> "Boot failed: " ^ s
      in
      Printf.printf "[Boot] Error: %s\n%!" msg;
      Error msg

  | Ok pill ->
      (* Check if pill has ivory tag *)
      if not (Noun.is_cell pill.kernel) then
        Error "Ivory pill must be a cell"
      else begin
        let hed = Noun.head pill.kernel in
        let tal = Noun.tail pill.kernel in

        (* Check for "ivory" tag *)
        (* "ivory" as cord (little-endian): 0x79726f7669 = 521610950249 *)
        let ivory_tag = Z.of_string "521610950249" in

        match hed with
        | Noun.Atom z when Z.equal z ivory_tag ->
            Printf.printf "[Boot] ✓ Found ivory tag\n%!";
            Printf.printf "[Boot] Running lifecycle formula...\n%!";

            (try
              let start = Unix.gettimeofday () in
              let core = life tal in
              let elapsed = Unix.gettimeofday () -. start in

              Printf.printf "[Boot] ✓ Lifecycle completed in %.4fs\n%!" elapsed;
              Printf.printf "[Boot] Setting Arvo core...\n%!";

              State.boot state core;
              Printf.printf "[Boot] ✓ Ivory pill booted!\n%!";
              Ok ()
            with e ->
              Error ("Lifecycle failed: " ^ Printexc.to_string e))

        | _ ->
            Printf.printf "[Boot] Warning: No ivory tag found, trying regular boot...\n%!";
            boot_from_pill state pill
      end