critique 0.1.118 → 0.1.119

package/dist/agentation-api.d.ts

@@ -0,0 +1,21 @@
+import { Hono } from "hono";
+type Bindings = {
+    CommentRoom: {
+        idFromName(name: string): {
+            toString(): string;
+        };
+        get(id: {
+            toString(): string;
+        }): {
+            fetch(request: Request): Promise<Response>;
+        };
+    };
+};
+declare const api: Hono<{
+    Bindings: Bindings;
+    Variables: {
+        userId: string;
+    };
+}, import("hono/types").BlankSchema, "/">;
+export { api as agentationApi };
+//# sourceMappingURL=agentation-api.d.ts.map

package/dist/agentation-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentation-api.d.ts","sourceRoot":"","sources":["../src/agentation-api.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAE3B,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE;QACX,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG;YAAE,QAAQ,IAAI,MAAM,CAAA;SAAE,CAAA;QAChD,GAAG,CAAC,EAAE,EAAE;YAAE,QAAQ,IAAI,MAAM,CAAA;SAAE,GAAG;YAC/B,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;SAC3C,CAAA;KACF,CAAA;CACF,CAAA;AAED,QAAA,MAAM,GAAG;cAAwB,QAAQ;eAAa;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;yCAAK,CAAA;AAuK7E,OAAO,EAAE,GAAG,IAAI,aAAa,EAAE,CAAA"}

package/dist/agentation-api.js

@@ -0,0 +1,152 @@
+// Hono sub-app mounting the Agentation HTTP API.
+// Proxies all annotation/session/SSE requests to the CommentRoom Durable Object.
+// Mounted at /a in the main worker, so Agentation client calls /a/sessions/:id/annotations etc.
+//
+// The agents SDK (built on partyserver) requires an x-partykit-room header
+// on every request to a DO stub so it can initialize its name. Without this
+// header, the DO throws "Missing namespace or room headers". We inject it
+// via proxyToDO() on every proxied request.
+import { Hono } from "hono";
+const api = new Hono();
+// Helper: proxy a request to the CommentRoom DO for a given session ID.
+// Sets x-partykit-room so the agents SDK can initialize the DO name.
+function proxyToDO(env, sessionId, url, init) {
+    const doId = env.CommentRoom.idFromName(sessionId);
+    const stub = env.CommentRoom.get(doId);
+    const headers = new Headers(init?.headers);
+    headers.set("x-partykit-room", sessionId);
+    return stub.fetch(new Request(url, { ...init, headers }));
+}
+// Helper: extract session ID from an annotation ID ({sessionId}_{uuid})
+function parseAnnotationId(annotationId) {
+    const idx = annotationId.indexOf("_");
+    if (idx === -1)
+        return null;
+    return {
+        sessionId: annotationId.slice(0, idx),
+        rawId: annotationId,
+    };
+}
+// Health check (Agentation polls this)
+api.get("/health", (c) => c.json({ status: "ok" }));
+// Create session (Agentation calls POST /sessions with { url })
+api.post("/sessions", async (c) => {
+    const body = await c.req.json();
+    const url = body.url;
+    const match = url?.match(/\/v\/([a-f0-9]{16,32})/);
+    const sessionId = match?.[1] || crypto.randomUUID();
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/session");
+    const session = await resp.json();
+    return c.json({ id: sessionId, ...session });
+});
+// List sessions — return empty for v1
+api.get("/sessions", (c) => {
+    return c.json({ sessions: [] });
+});
+// Get session with all annotations
+api.get("/sessions/:id", async (c) => {
+    const sessionId = c.req.param("id");
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/session");
+    return new Response(resp.body, resp);
+});
+// Create annotation within a session
+api.post("/sessions/:id/annotations", async (c) => {
+    const sessionId = c.req.param("id");
+    const body = await c.req.json();
+    // Prefix annotation ID with session ID for routing
+    if (typeof body.id !== "string" || !body.id.startsWith(`${sessionId}_`)) {
+        body.id = `${sessionId}_${crypto.randomUUID()}`;
+    }
+    // Support legacy createdBy field from old clients
+    const legacyCreatedBy = typeof body.createdBy === "string" ? body.createdBy : undefined;
+    body.authorId = body.authorId || legacyCreatedBy || c.get("userId");
+    delete body.createdBy;
+    body.sessionId = sessionId;
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/annotations", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    return new Response(resp.body, resp);
+});
+// Submit action request for a session
+api.post("/sessions/:id/action", async (c) => {
+    const sessionId = c.req.param("id");
+    const body = await c.req.text();
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/action", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+    });
+    return new Response(resp.body, resp);
+});
+// Get annotation by ID (annotation IDs encode session: {sessionId}_{uuid})
+api.get("/annotations/:id", async (c) => {
+    const parsed = parseAnnotationId(c.req.param("id"));
+    if (!parsed) {
+        return c.json({ error: "Invalid annotation ID format" }, 400);
+    }
+    const resp = await proxyToDO(c.env, parsed.sessionId, `https://internal/api/annotations/${parsed.rawId}`);
+    return new Response(resp.body, resp);
+});
+// Update annotation
+api.patch("/annotations/:id", async (c) => {
+    const parsed = parseAnnotationId(c.req.param("id"));
+    if (!parsed) {
+        return c.json({ error: "Invalid annotation ID format" }, 400);
+    }
+    const body = await c.req.text();
+    const resp = await proxyToDO(c.env, parsed.sessionId, `https://internal/api/annotations/${parsed.rawId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body,
+    });
+    return new Response(resp.body, resp);
+});
+// Delete annotation
+api.delete("/annotations/:id", async (c) => {
+    const parsed = parseAnnotationId(c.req.param("id"));
+    if (!parsed) {
+        return c.json({ error: "Invalid annotation ID format" }, 400);
+    }
+    const resp = await proxyToDO(c.env, parsed.sessionId, `https://internal/api/annotations/${parsed.rawId}`, {
+        method: "DELETE",
+    });
+    return new Response(resp.body, resp);
+});
+// Thread messages
+api.post("/annotations/:id/thread", async (c) => {
+    const parsed = parseAnnotationId(c.req.param("id"));
+    if (!parsed) {
+        return c.json({ error: "Invalid annotation ID format" }, 400);
+    }
+    const body = await c.req.text();
+    const resp = await proxyToDO(c.env, parsed.sessionId, `https://internal/api/annotations/${parsed.rawId}/thread`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+    });
+    return new Response(resp.body, resp);
+});
+// Pending annotations for a session
+api.get("/sessions/:id/pending", async (c) => {
+    const sessionId = c.req.param("id");
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/pending");
+    return new Response(resp.body, resp);
+});
+// SSE events — proxy to DO's SSE endpoint
+api.get("/sessions/:id/events", async (c) => {
+    const sessionId = c.req.param("id");
+    const resp = await proxyToDO(c.env, sessionId, "https://internal/api/events");
+    const headers = new Headers(resp.headers);
+    headers.set("Content-Type", "text/event-stream");
+    headers.set("Cache-Control", "no-cache");
+    headers.set("Connection", "keep-alive");
+    headers.set("Access-Control-Allow-Origin", "*");
+    return new Response(resp.body, {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers,
+    });
+});
+export { api as agentationApi };

package/dist/agentation-api.preview.e2e.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agentation-api.preview.e2e.test.d.ts.map

package/dist/agentation-api.preview.e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentation-api.preview.e2e.test.d.ts","sourceRoot":"","sources":["../src/agentation-api.preview.e2e.test.ts"],"names":[],"mappings":""}

package/dist/agentation-api.preview.e2e.test.js

@@ -0,0 +1,293 @@
+// End-to-end preview worker test for Agentation API compatibility.
+// Uses real fetch requests against preview.critique.work and validates
+// session lifecycle, annotation CRUD, multi-user cookies, and SSE events.
+import { describe, expect, test } from "bun:test";
+import crypto from "crypto";
+const BASE_URL = process.env.AGENTATION_BASE_URL || "https://preview.critique.work/a";
+const SSE_TIMEOUT_MS = 30_000;
+function randomHex(bytes) {
+    return crypto.randomBytes(bytes).toString("hex");
+}
+function asObject(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function getString(record, key, label) {
+    const value = record[key];
+    if (typeof value !== "string") {
+        throw new Error(`${label}.${key} must be a string`);
+    }
+    return value;
+}
+function getNumber(record, key, label) {
+    const value = record[key];
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new Error(`${label}.${key} must be a number`);
+    }
+    return value;
+}
+function getArray(record, key, label) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        throw new Error(`${label}.${key} must be an array`);
+    }
+    return value;
+}
+function parseJson(text) {
+    if (text.length === 0)
+        return null;
+    return JSON.parse(text);
+}
+async function requestJson(path, options) {
+    const headers = new Headers(options?.headers);
+    headers.set("Accept", "application/json");
+    if (options?.body !== undefined) {
+        headers.set("Content-Type", "application/json");
+    }
+    if (options?.userId) {
+        headers.set("Cookie", `cw_user_id=${options.userId}`);
+    }
+    const response = await fetch(`${BASE_URL}${path}`, {
+        method: options?.method || "GET",
+        headers,
+        body: options?.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    const text = await response.text();
+    const json = parseJson(text);
+    return { response, json, text };
+}
+function parseSseFrame(frame) {
+    const lines = frame.split("\n");
+    let eventName = "";
+    let id;
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith("event:")) {
+            eventName = line.slice("event:".length).trim();
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            dataLines.push(line.slice("data:".length).trimStart());
+            continue;
+        }
+        if (line.startsWith("id:")) {
+            const parsed = Number(line.slice("id:".length).trim());
+            if (Number.isFinite(parsed)) {
+                id = parsed;
+            }
+        }
+    }
+    if (!eventName)
+        return null;
+    const dataText = dataLines.join("\n");
+    if (!dataText) {
+        return { event: eventName, data: null, id };
+    }
+    try {
+        return { event: eventName, data: JSON.parse(dataText), id };
+    }
+    catch {
+        return { event: eventName, data: dataText, id };
+    }
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+async function collectSseEvents(stream, expectedEventNames) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const expectedSet = new Set(expectedEventNames);
+    const seen = new Map();
+    let buffer = "";
+    const start = Date.now();
+    try {
+        while (seen.size < expectedSet.size) {
+            const elapsed = Date.now() - start;
+            const remaining = SSE_TIMEOUT_MS - elapsed;
+            if (remaining <= 0) {
+                throw new Error(`Timed out waiting for SSE events. Seen: ${Array.from(seen.keys()).join(", ") || "none"}`);
+            }
+            const readResult = await withTimeout(reader.read(), remaining, `Timed out waiting for SSE chunk after ${SSE_TIMEOUT_MS}ms`);
+            if (readResult.done) {
+                break;
+            }
+            buffer += decoder.decode(readResult.value, { stream: true });
+            buffer = buffer.replaceAll("\r\n", "\n");
+            while (true) {
+                const delimiterIndex = buffer.indexOf("\n\n");
+                if (delimiterIndex === -1)
+                    break;
+                const rawFrame = buffer.slice(0, delimiterIndex);
+                buffer = buffer.slice(delimiterIndex + 2);
+                const parsed = parseSseFrame(rawFrame);
+                if (!parsed)
+                    continue;
+                if (!expectedSet.has(parsed.event))
+                    continue;
+                if (!seen.has(parsed.event)) {
+                    seen.set(parsed.event, parsed);
+                }
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    if (seen.size < expectedSet.size) {
+        const missing = expectedEventNames.filter((name) => !seen.has(name));
+        throw new Error(`Missing SSE events: ${missing.join(", ")}`);
+    }
+    return expectedEventNames.map((name) => seen.get(name));
+}
+describe("preview worker Agentation API", () => {
+    test("supports session lifecycle, multi-user annotation CRUD, and SSE", async () => {
+        const userA = `preview-user-a-${randomHex(4)}`;
+        const userB = `preview-user-b-${randomHex(4)}`;
+        const sessionId = randomHex(16);
+        const health = await requestJson("/health");
+        expect(health.response.status).toBe(200);
+        const healthBody = asObject(health.json, "health");
+        expect(getString(healthBody, "status", "health")).toBe("ok");
+        const createdSession = await requestJson("/sessions", {
+            method: "POST",
+            body: { url: `https://preview.critique.work/v/${sessionId}` },
+        });
+        expect(createdSession.response.status).toBe(200);
+        const sessionBody = asObject(createdSession.json, "createdSession");
+        expect(getString(sessionBody, "id", "createdSession")).toBe(sessionId);
+        const fetchedSession = await requestJson(`/sessions/${sessionId}`);
+        expect(fetchedSession.response.status).toBe(200);
+        const fetchedSessionBody = asObject(fetchedSession.json, "fetchedSession");
+        const initialAnnotations = getArray(fetchedSessionBody, "annotations", "fetchedSession");
+        expect(initialAnnotations.length).toBe(0);
+        const sseResponse = await fetch(`${BASE_URL}/sessions/${sessionId}/events`, {
+            headers: { Accept: "text/event-stream" },
+        });
+        expect(sseResponse.ok).toBe(true);
+        const sseContentType = sseResponse.headers.get("Content-Type") || "";
+        expect(sseContentType.includes("text/event-stream")).toBe(true);
+        expect(sseResponse.body).toBeTruthy();
+        const sseEventsPromise = collectSseEvents(sseResponse.body, [
+            "annotation.created",
+            "annotation.updated",
+            "action.requested",
+            "annotation.deleted",
+        ]);
+        const createdAnnotationResponse = await requestJson(`/sessions/${sessionId}/annotations`, {
+            method: "POST",
+            userId: userA,
+            body: {
+                comment: "preview smoke create",
+                elementPath: "#content > .line:nth-child(1)",
+                element: "div",
+                timestamp: Date.now(),
+                x: 12,
+                y: 32,
+                status: "pending",
+            },
+        });
+        expect(createdAnnotationResponse.response.status).toBe(201);
+        const createdAnnotation = asObject(createdAnnotationResponse.json, "createdAnnotation");
+        const annotationId = getString(createdAnnotation, "id", "createdAnnotation");
+        expect(annotationId.startsWith(`${sessionId}_`)).toBe(true);
+        expect(getString(createdAnnotation, "authorId", "createdAnnotation")).toBe(userA);
+        expect(getString(createdAnnotation, "sessionId", "createdAnnotation")).toBe(sessionId);
+        const getCreated = await requestJson(`/annotations/${annotationId}`);
+        expect(getCreated.response.status).toBe(200);
+        const getCreatedBody = asObject(getCreated.json, "getCreated");
+        expect(getString(getCreatedBody, "id", "getCreated")).toBe(annotationId);
+        const pendingBeforeResolve = await requestJson(`/sessions/${sessionId}/pending`);
+        expect(pendingBeforeResolve.response.status).toBe(200);
+        const pendingBeforeResolveBody = asObject(pendingBeforeResolve.json, "pendingBeforeResolve");
+        const pendingBeforeResolveList = getArray(pendingBeforeResolveBody, "annotations", "pendingBeforeResolve").map((item) => asObject(item, "pendingBeforeResolve.annotations"));
+        expect(pendingBeforeResolveList.some((item) => getString(item, "id", "pending item") === annotationId)).toBe(true);
+        const updatedAnnotationResponse = await requestJson(`/annotations/${annotationId}`, {
+            method: "PATCH",
+            userId: userB,
+            body: {
+                status: "resolved",
+                resolvedBy: "human",
+                comment: "preview smoke resolved",
+            },
+        });
+        expect(updatedAnnotationResponse.response.status).toBe(200);
+        const updatedAnnotation = asObject(updatedAnnotationResponse.json, "updatedAnnotation");
+        expect(getString(updatedAnnotation, "status", "updatedAnnotation")).toBe("resolved");
+        expect(getString(updatedAnnotation, "comment", "updatedAnnotation")).toBe("preview smoke resolved");
+        const threadResponse = await requestJson(`/annotations/${annotationId}/thread`, {
+            method: "POST",
+            userId: userB,
+            body: {
+                role: "human",
+                content: "confirmed in preview test",
+            },
+        });
+        expect(threadResponse.response.status).toBe(201);
+        const threadBody = asObject(threadResponse.json, "thread");
+        expect(getString(threadBody, "role", "thread")).toBe("human");
+        const pendingAfterResolve = await requestJson(`/sessions/${sessionId}/pending`);
+        expect(pendingAfterResolve.response.status).toBe(200);
+        const pendingAfterResolveBody = asObject(pendingAfterResolve.json, "pendingAfterResolve");
+        const pendingAfterResolveList = getArray(pendingAfterResolveBody, "annotations", "pendingAfterResolve").map((item) => asObject(item, "pendingAfterResolve.annotations"));
+        expect(pendingAfterResolveList.some((item) => getString(item, "id", "pending item") === annotationId)).toBe(false);
+        const actionResponse = await requestJson(`/sessions/${sessionId}/action`, {
+            method: "POST",
+            userId: userB,
+            body: {
+                output: "please handle this annotation",
+            },
+        });
+        expect(actionResponse.response.status).toBe(200);
+        const actionBody = asObject(actionResponse.json, "action");
+        expect(actionBody.success).toBe(true);
+        expect(getNumber(actionBody, "annotationCount", "action")).toBeGreaterThanOrEqual(1);
+        const delivered = asObject(actionBody.delivered, "action.delivered");
+        expect(getNumber(delivered, "total", "action.delivered")).toBeGreaterThanOrEqual(0);
+        const deleteResponse = await requestJson(`/annotations/${annotationId}`, {
+            method: "DELETE",
+            userId: userB,
+        });
+        expect(deleteResponse.response.status).toBe(200);
+        const deleteBody = asObject(deleteResponse.json, "delete");
+        expect(deleteBody.success).toBe(true);
+        const getDeleted = await requestJson(`/annotations/${annotationId}`);
+        expect(getDeleted.response.status).toBe(404);
+        const sseEvents = await sseEventsPromise;
+        const createdEvent = asObject(sseEvents[0].data, "sse.created");
+        const updatedEvent = asObject(sseEvents[1].data, "sse.updated");
+        const actionEvent = asObject(sseEvents[2].data, "sse.action");
+        const deletedEvent = asObject(sseEvents[3].data, "sse.deleted");
+        expect(getString(createdEvent, "sessionId", "sse.created")).toBe(sessionId);
+        expect(getString(updatedEvent, "sessionId", "sse.updated")).toBe(sessionId);
+        expect(getString(actionEvent, "sessionId", "sse.action")).toBe(sessionId);
+        expect(getString(deletedEvent, "sessionId", "sse.deleted")).toBe(sessionId);
+        const createdSeq = getNumber(createdEvent, "sequence", "sse.created");
+        const updatedSeq = getNumber(updatedEvent, "sequence", "sse.updated");
+        const actionSeq = getNumber(actionEvent, "sequence", "sse.action");
+        const deletedSeq = getNumber(deletedEvent, "sequence", "sse.deleted");
+        expect(createdSeq < updatedSeq).toBe(true);
+        expect(updatedSeq < actionSeq).toBe(true);
+        expect(actionSeq < deletedSeq).toBe(true);
+        const createdPayload = asObject(createdEvent.payload, "sse.created.payload");
+        const updatedPayload = asObject(updatedEvent.payload, "sse.updated.payload");
+        const actionPayload = asObject(actionEvent.payload, "sse.action.payload");
+        const deletedPayload = asObject(deletedEvent.payload, "sse.deleted.payload");
+        expect(getString(createdPayload, "id", "sse.created.payload")).toBe(annotationId);
+        expect(getString(updatedPayload, "id", "sse.updated.payload")).toBe(annotationId);
+        expect(getString(actionPayload, "output", "sse.action.payload")).toBe("please handle this annotation");
+        expect(getString(deletedPayload, "id", "sse.deleted.payload")).toBe(annotationId);
+    }, 120_000);
+});

package/dist/agentation-widget.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agentation-widget.d.ts.map

package/dist/agentation-widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentation-widget.d.ts","sourceRoot":"","sources":["../src/agentation-widget.tsx"],"names":[],"mappings":""}

package/dist/agentation-widget.js

@@ -0,0 +1,67 @@
+// Widget entry point — self-initializing script for static HTML pages.
+// Reads config from window.__CRITIQUE_CONFIG__, creates a React root,
+// and renders the Agentation component for annotation UI.
+//
+// This is used by pages that don't have React (e.g., critique's static diff pages).
+//
+// Usage: inject into HTML before </body>:
+//   <script>window.__CRITIQUE_CONFIG__ = { endpoint: "https://critique.work/a", sessionId: "abc123", userId: "user-1" }</script>
+//   <script src="/agentation-widget.js"></script>
+//
+// Performance optimization:
+//   Critique diff pages can have 185K+ DOM nodes (6,500+ div.line elements each
+//   containing many spans). We inject content-visibility: auto on .line elements
+//   so the browser only renders visible lines, skipping layout/paint for the
+//   ~6,400 off-screen lines. This brings page load from ~16s to <2s on large diffs.
+function injectContentVisibility() {
+    if (document.getElementById("critique-cv-styles"))
+        return;
+    const style = document.createElement("style");
+    style.id = "critique-cv-styles";
+    style.textContent = `
+    #content > .line {
+      content-visibility: auto;
+      contain-intrinsic-height: auto 20px;
+    }
+  `;
+    document.head.appendChild(style);
+}
+async function init() {
+    // Inject content-visibility optimization before anything else
+    injectContentVisibility();
+    // Seed agentation theme from system preference before it reads localStorage.
+    // Agentation reads localStorage["feedback-toolbar-theme"] on mount and
+    // defaults to dark if absent. We set it to match the OS color scheme so
+    // the widget looks correct on light-mode systems from the first render.
+    if (!localStorage.getItem("feedback-toolbar-theme")) {
+        const isLight = window.matchMedia("(prefers-color-scheme: light)").matches;
+        localStorage.setItem("feedback-toolbar-theme", isLight ? "light" : "dark");
+    }
+    if (document.getElementById("critique-agentation"))
+        return;
+    const config = window.__CRITIQUE_CONFIG__;
+    if (!config?.endpoint || !config?.sessionId) {
+        console.warn("[critique] Missing window.__CRITIQUE_CONFIG__");
+        return;
+    }
+    const container = document.createElement("div");
+    container.id = "critique-agentation";
+    document.body.appendChild(container);
+    // Use preact's render() directly since the build aliases react → preact/compat.
+    // preact/compat does not export createRoot from react-dom/client.
+    const [{ Agentation }, { render, h }] = await Promise.all([
+        import("@critique.work/agentation"),
+        import("preact"),
+    ]);
+    render(h(Agentation, {
+        endpoint: config.endpoint,
+        sessionId: config.sessionId,
+        showFreezeButton: config.showFreezeButton,
+    }), container);
+}
+if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+}
+else {
+    init();
+}

package/dist/ansi-html.d.ts

@@ -0,0 +1,42 @@
+import type { CapturedFrame, CapturedLine, CapturedSpan } from "@opentuah/core";
+export interface ToHtmlOptions {
+    /** Background color for the container */
+    backgroundColor?: string;
+    /** Text color for the container */
+    textColor?: string;
+    /** Font family for the output */
+    fontFamily?: string;
+    /** Trim empty lines from the end */
+    trimEmptyLines?: boolean;
+    /** Enable auto light/dark mode based on system preference */
+    autoTheme?: boolean;
+    /** HTML document title */
+    title?: string;
+    /** OG image URL for social media previews */
+    ogImageUrl?: string;
+    /** Custom line renderer - wraps or replaces the default <div class="line"> output per line.
+     *  Generic hook: receives the default HTML, the captured line data, and the 0-based line index.
+     *  Return a replacement HTML string. If not provided, the default <div class="line"> is used. */
+    renderLine?: (defaultHtml: string, line: CapturedLine, lineIndex: number) => string;
+    /** Extra CSS injected into the document style block */
+    extraCss?: string;
+    /** Extra JS injected as a separate script block before </body> */
+    extraJs?: string;
+}
+/**
+ * Converts captured frame to styled HTML.
+ * Renders HTML line by line from the CapturedFrame structure.
+ * Returns both the content HTML and a CSS block for deduplicated span styles.
+ */
+export declare function frameToHtml(frame: CapturedFrame, options?: ToHtmlOptions): {
+    html: string;
+    spanCss: string;
+};
+/**
+ * Generates a complete HTML document from captured frame.
+ * Includes proper styling for terminal output display.
+ * Font size automatically adjusts to fit content within viewport.
+ */
+export declare function frameToHtmlDocument(frame: CapturedFrame, options?: ToHtmlOptions): string;
+export type { CapturedFrame, CapturedLine, CapturedSpan };
+//# sourceMappingURL=ansi-html.d.ts.map

package/dist/ansi-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansi-html.d.ts","sourceRoot":"","sources":["../src/ansi-html.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAM/E,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,oCAAoC;IACpC,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;qGAEiG;IACjG,UAAU,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACnF,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAqHD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,aAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA4BhH;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAyL7F;AAED,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,CAAA"}