Libraries

library CB-Console;
library CB-Networking.API;
library CB-Networking.HTTP;

fn main() {
    string requestMethod = "GET";
    string requestPath = "/support/status";
    string expectedToken = "dev-token";
    string authHeader = CB-Networking.HTTP.bearer(expectedToken);

    bool routeOk = CB-Networking.API.match(requestMethod, requestPath, "GET", "/support/status");
    bool authOk = CB-Networking.API.require_token(authHeader, expectedToken);

    if (!routeOk) {
        println(CB-Networking.API.error(404, "route not found"));
        return;
    }

    if (!authOk) {
        println(CB-Networking.API.error(401, "missing or invalid token"));
        return;
    }

    string body = "support=online;queue=2;priority=normal";
    println("Route: " + CB-Networking.API.route(requestMethod, requestPath));
    println("Response: " + CB-Networking.API.ok(body));
}

Teaches: route matching, bearer-token checks, 404/401 fallbacks, and success responses for local API-style handlers.

library CB-Console;
library CB-Networking.HTTP;

fn main() {
    string base = "https://closedbit.com";
    string url = CB-Networking.HTTP.endpoint(base, "/sitemap.xml");
    string fallback = "offline=true;source=fallback";
    string response = CB-Networking.HTTP.get_or(url, fallback);

    println("Request: " + CB-Networking.HTTP.cache_key("GET", url));
    println("Header: " + CB-Networking.HTTP.accept("application/xml"));
    println("Characters: " + len(response));

    if (string.contains(response, "<urlset")) {
        println("Connected: sitemap loaded");
    } else {
        println("Fallback: " + response);
    }
}

Teaches: endpoint joining, a real runtime-backed GET, offline fallback handling, request labeling, and response inspection.

library CB-Console;
library CB-Storage;

fn main() {
    string path = "closedbit-player-save.cb";
    string initial = "player=Ada;score=1250;level=4";

    CB-Storage.write_text(path, initial);
    string loaded = CB-Storage.read_text(path);

    println("ClosedBit Storage Round Trip");
    println("Exists: " + CB-Storage.exists(path));
    println("Loaded: " + loaded);
}

library CB-Console;
library CB-GenerationOptimized;
library CB-Parsing;
library CB-Understanding;

fn main() {
    string dataset = "examples/ai/shared-mini-dataset.txt";
    string index = "build/ai/shared-mini-dataset.cbi";

    CB-GenerationOptimized.build_index(dataset, index);
    u256 indexed = CB-GenerationOptimized.warm(index);
    array batches = CB-GenerationOptimized.query_batch(dataset, index, ["ai,gpu", "game,gpu", "storage,index"], 3);
    array records = batches[0];
    string picked = CB-GenerationOptimized.pick(dataset, index, "game,gpu", 256);

    println("ClosedBit Native Indexed Retrieval");
    println("Retrieval backend: " + CB-GenerationOptimized.last_backend());
    println("Indexed records: " + indexed);
    println("Matches: " + records.length());
    println("Picked: " + CB-Parsing.normalize(picked));
    println("AI score: " + CB-Understanding.score(picked, "gpu"));
    println("Native mapping hits: " + CB-GenerationOptimized.cache_hits());
    println("Native mapping misses: " + CB-GenerationOptimized.cache_misses());
    println("Native records scanned: " + CB-GenerationOptimized.records_scanned());
}

library CB-Console;
library CB-GPU;

fn main() {
    println("ClosedBit temporary Direct3D 12 GPU status");
    println("Available: " + CB-GPU.available());
    println("Driver: " + CB-GPU.name());
    println("Backend: " + CB-GPU.backend());
    println("VRAM visible MB: " + CB-GPU.vram_total_mb());
    println("Policy cap MB: " + CB-GPU.budget_mb());
}

library CB-Library;
library CB-Library.Graphics;
library CB-Library.Threaded;
library CB-Render;
library CB-Runtime;

fn main() {
    init_window(960, 540, "ClosedBit Runtime Memory Cleanup");
    set_background_color(0x071019);
    CB-Render.starfield(8_000, 1, 0xD7F9FF);
    CB-Render.particles(2_500, 1, 0x48D1CC, 0xFFBE55);
    CB-Render.cube_field(64, 1, 0x83E8FF);
    CB-Render.flush();
    println("Renderer before cleanup: " + CB-Render.backend());
    cleanup();

    array memory = CB-Runtime.cleanup_memory();
    println("Working set bytes: " + memory[0] + " -> " + memory[1]);
    println("Pageable committed bytes: " + memory[2] + " -> " + memory[3]);
    println("Private bytes: " + memory[4] + " -> " + memory[5]);
    println("Cleanup page faults: " + (memory[7] - memory[6]));
    u256 reuse_faults_before = CB-Runtime.page_fault_count();
    CB-Runtime.raw_kernel(2_000_000, 256);
    println("Hot reuse page faults: " + (CB-Runtime.page_fault_count() - reuse_faults_before));
}