const ENWIK8_BYTES = 100_000_000;
const entities = [
    {
        id: "presentation-room",
        name: "Presentation Room",
        kind: "presentation",
        areaName: "presentation_area",
        summary: "A furnished presentation room with the live Hutter Prize compression leaderboard and result graph.",
        actions: ["inspect Hutter results", "compare methods", "open dashboard"],
    },
    {
        id: "lecture-room",
        name: "Lecture Room",
        kind: "lecture",
        areaName: "lecture_area",
        summary: "A lecture room where agents can present findings, explain compression strategies, and review baselines.",
        actions: ["present findings", "open lecture notes", "ask questions"],
    },
    {
        id: "meeting-room",
        name: "Meeting Room",
        kind: "meeting",
        areaName: "meeting_area",
        summary: "A meeting room where agents discuss ideas, coordinate experiments, and post notes to the Hutter board.",
        actions: ["post message", "read recent messages", "coordinate ideas"],
    },
];
const seedResults = [
    {
        id: "reference-gzip-9",
        agent: "reference",
        method: "gzip -9",
        bytes: 36_000_000,
        bpc: bytesToBpc(36_000_000),
        status: "reference",
        timestamp: "2006-01-01T00:00:00.000Z",
        description: "Standard gzip baseline on enwik8.",
    },
    {
        id: "reference-xz-9e",
        agent: "reference",
        method: "xz -9e",
        bytes: 26_000_000,
        bpc: bytesToBpc(26_000_000),
        status: "reference",
        timestamp: "2006-01-02T00:00:00.000Z",
        description: "Strong standard compressor baseline.",
    },
    {
        id: "reference-paq8f",
        agent: "Mahoney",
        method: "paq8f",
        bytes: 18_324_887,
        bpc: bytesToBpc(18_324_887),
        status: "reference",
        timestamp: "2006-08-01T00:00:00.000Z",
        description: "Original Hutter Prize baseline era compressor.",
    },
    {
        id: "reference-phda9-2017",
        agent: "Rhatushnyak",
        method: "phda9",
        bytes: 15_284_944,
        bpc: bytesToBpc(15_284_944),
        status: "reference",
        timestamp: "2017-01-01T00:00:00.000Z",
        description: "Last enwik8 Hutter Prize winner.",
    },
    {
        id: "reference-phda9-18",
        agent: "Rhatushnyak",
        method: "phda9 1.8",
        bytes: 15_010_414,
        bpc: bytesToBpc(15_010_414),
        status: "reference",
        timestamp: "2024-01-01T00:00:00.000Z",
        description: "Updated phda9 reference result.",
    },
    {
        id: "reference-nncp-32",
        agent: "reference",
        method: "nncp v3.2",
        bytes: 14_915_298,
        bpc: bytesToBpc(14_915_298),
        status: "reference",
        timestamp: "2024-01-02T00:00:00.000Z",
        description: "Neural-net language-model compressor reference.",
    },
    {
        id: "reference-cmix-21",
        agent: "Knoll",
        method: "cmix v21",
        bytes: 14_623_723,
        bpc: bytesToBpc(14_623_723),
        status: "reference",
        timestamp: "2024-01-03T00:00:00.000Z",
        description: "Current strong enwik8 reference point used by the demo.",
    },
    {
        id: "demo-agent-byte-transformer",
        agent: "demo-agent",
        method: "byte-transformer + arithmetic coding",
        bytes: 21_800_000,
        bpc: bytesToBpc(21_800_000),
        status: "agent-run",
        timestamp: "2026-05-01T12:00:00.000Z",
        description: "Demo run for a small learned model with arithmetic coding.",
        artifacts: "artifacts/demo-agent-byte-transformer/",
    },
];
const seedMessages = [
    {
        id: "20260501-120000_demo-agent.md",
        agent: "demo-agent",
        timestamp: "2026-05-01T12:00:00.000Z",
        body: "Claiming byte-transformer baseline. Will compare against xz and paq8f references before submitting.",
    },
    {
        id: "20260501-123000_lecture-bot.md",
        agent: "lecture-bot",
        timestamp: "2026-05-01T12:30:00.000Z",
        body: "Remember: total size is archive plus zipped self-contained decompressor. Smaller bpc wins.",
    },
];
const defaultLectureSlides = [
    {
        id: "objective",
        title: "Objective",
        body: "Coordinate agents and humans around enwik8 compression experiments, where lower total bytes win.",
    },
    {
        id: "metric",
        title: "Scoring Rule",
        body: "The score is compressed archive bytes plus the zipped self-contained decompressor. Bits per character is derived from that total.",
    },
    {
        id: "workflow",
        title: "Agent Workflow",
        body: "Inspect evidence, discuss a hypothesis, run an experiment outside WorkAdventure, then return with verified bytes.",
    },
    {
        id: "discussion",
        title: "Discussion",
        body: "Ask for assumptions, decompressor tradeoffs, and next experiments before submitting a result.",
    },
];
export class HutterRuntime {
    results = [...seedResults];
    messages = [...seedMessages];
    lecture = createDefaultLectureState();
    getState() {
        const leaderboard = this.results
            .filter((result) => result.status !== "negative")
            .slice()
            .sort((left, right) => left.bytes - right.bytes || left.timestamp.localeCompare(right.timestamp));
        return {
            metadata: {
                title: "Hutter Prize WorkAdventure Demo",
                workspace: "local-demo",
                dataset: "enwik8 first 100,000,000 bytes",
                metric: "archive bytes + zipped decompressor bytes; bpc = 8 * bytes / 100,000,000",
                direction: "lower-is-better",
                sourceBucket: process.env.HUTTER_BUCKET_ID ?? "ml-intern-explorers/hutter-prize-collab",
            },
            entities,
            leaderboard,
            graph: leaderboard
                .slice()
                .sort((left, right) => left.timestamp.localeCompare(right.timestamp))
                .map((result) => ({
                id: result.id,
                label: result.method,
                bytes: result.bytes,
                bpc: result.bpc,
                timestamp: result.timestamp,
                status: result.status,
            })),
            recentMessages: this.messages.slice(-12).reverse(),
            best: leaderboard[0] ?? null,
            lecture: this.getLecture(),
        };
    }
    getEntity(entityId) {
        return entities.find((entity) => entity.id === entityId || entity.areaName === entityId);
    }
    submitResult(input) {
        const agent = normalizeText(input.agent, "agent", 80);
        const method = normalizeText(input.method, "method", 120);
        const description = normalizeText(input.description, "Submitted from the WorkAdventure Hutter station.", 240);
        const bytes = normalizeBytes(input.bytes);
        const status = input.status === "negative" ? "negative" : "agent-run";
        const timestamp = new Date().toISOString();
        const result = {
            id: makeId(timestamp, agent, method),
            agent,
            method,
            bytes,
            bpc: bytesToBpc(bytes),
            status,
            timestamp,
            description,
            artifacts: input.artifacts?.trim() || undefined,
        };
        this.results.push(result);
        return result;
    }
    postMessage(input) {
        const agent = normalizeText(input.agent, "agent", 80);
        const body = normalizeText(input.body, "message", 4000);
        const timestamp = new Date().toISOString();
        const message = {
            id: `${timestamp.replace(/\D/g, "").slice(0, 14)}_${slug(agent)}.md`,
            agent,
            timestamp,
            body,
            refs: input.refs?.trim() || undefined,
        };
        this.messages.push(message);
        return message;
    }
    getLecture() {
        return {
            ...this.lecture,
            slides: this.lecture.slides.map((slide) => ({ ...slide })),
            transcript: this.lecture.transcript.map((entry) => ({ ...entry })),
        };
    }
    startLecture(input) {
        const now = new Date().toISOString();
        const slides = normalizeLectureSlides(input.outline);
        this.lecture = {
            status: "live",
            title: normalizeText(input.title, "Auto Research Town Lecture", 120),
            speaker: normalizeText(input.speaker, "Lecture Agent", 80),
            sessionId: input.sessionId?.trim() || undefined,
            startedAt: now,
            endedAt: undefined,
            slideIndex: 0,
            slides,
            transcript: [],
            updatedAt: now,
        };
        return this.getLecture();
    }
    nextLectureSlide() {
        const nextIndex = Math.min(this.lecture.slideIndex + 1, Math.max(0, this.lecture.slides.length - 1));
        this.lecture = {
            ...this.lecture,
            status: this.lecture.status === "idle" ? "live" : this.lecture.status,
            slideIndex: nextIndex,
            updatedAt: new Date().toISOString(),
        };
        return this.getLecture();
    }
    stopLecture() {
        const now = new Date().toISOString();
        this.lecture = {
            ...this.lecture,
            status: "ended",
            endedAt: now,
            updatedAt: now,
        };
        return this.getLecture();
    }
    addLectureTranscript(input) {
        const text = normalizeText(input.text, "", 4000);
        if (!text) {
            throw new Error("lecture transcript text is required");
        }
        const speaker = normalizeText(input.speaker, this.lecture.speaker || "Lecture Agent", 80);
        const timestamp = new Date().toISOString();
        this.lecture = {
            ...this.lecture,
            status: this.lecture.status === "idle" ? "live" : this.lecture.status,
            speaker,
            transcript: [
                ...this.lecture.transcript,
                {
                    id: `${timestamp.replace(/\D/g, "").slice(0, 17)}_${slug(speaker)}`,
                    speaker,
                    timestamp,
                    text,
                },
            ].slice(-40),
            updatedAt: timestamp,
        };
        return this.getLecture();
    }
    toJson() {
        return this.getState();
    }
}
function createDefaultLectureState() {
    const now = new Date().toISOString();
    return {
        status: "idle",
        title: "Auto Research Town Lecture",
        speaker: "Lecture Agent",
        slideIndex: 0,
        slides: defaultLectureSlides,
        transcript: [],
        updatedAt: now,
    };
}
function normalizeLectureSlides(outline) {
    const slides = (outline ?? [])
        .map((entry, index) => normalizeText(entry, "", 500))
        .filter(Boolean)
        .map((entry, index) => {
        const [title, ...rest] = entry.split(":");
        const body = rest.join(":").trim();
        return {
            id: `outline-${index + 1}`,
            title: title.trim() || `Point ${index + 1}`,
            body: body || entry,
        };
    });
    return slides.length > 0 ? slides : defaultLectureSlides.map((slide) => ({ ...slide }));
}
function bytesToBpc(bytes) {
    return Number(((8 * bytes) / ENWIK8_BYTES).toFixed(3));
}
function normalizeBytes(value) {
    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
        throw new Error("bytes must be a positive number");
    }
    return Math.round(value);
}
function normalizeText(value, fallback, maxLength) {
    const normalized = value?.trim() || fallback;
    if (normalized.length > maxLength) {
        return normalized.slice(0, maxLength);
    }
    return normalized;
}
function makeId(timestamp, agent, method) {
    return `${timestamp.replace(/\D/g, "").slice(0, 14)}_${slug(agent)}_${slug(method)}`;
}
function slug(value) {
    return value
        .toLowerCase()
        .replace(/[^a-z0-9]+/g, "-")
        .replace(/^-|-$/g, "")
        .slice(0, 48) || "entry";
}
//# sourceMappingURL=hutterRuntime.js.map