explicai 0.0.0-stage → 0.2.0

package/dist/server/http.d.ts

@@ -0,0 +1,31 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class HttpError extends Error {
+    readonly status: number;
+    /** Identifica o erro para a interface traduzir (a mensagem fica em português para curl e MCP). */
+    readonly code?: string | undefined;
+    constructor(status: number, message: string, 
+    /** Identifica o erro para a interface traduzir (a mensagem fica em português para curl e MCP). */
+    code?: string | undefined);
+}
+/** O que um handler devolve. O servidor transforma em resposta HTTP. */
+export type Reply = {
+    kind: "json";
+    status: number;
+    body: unknown;
+} | {
+    kind: "file";
+    path: string;
+    cache: string;
+    untrusted: boolean;
+};
+export declare const json: (body: unknown, status?: number) => Reply;
+/** `untrusted`: arquivo do manual (/files/), que pode ser um SVG com script; sai com CSP e sandbox. */
+export declare const file: (filePath: string, cache?: string, untrusted?: boolean) => Reply;
+export declare function send(res: ServerResponse, reply: Reply, req?: IncomingMessage): Promise<void>;
+export declare function sendJson(res: ServerResponse, status: number, body: unknown): void;
+export declare function readBody(req: IncomingMessage, limit: number): Promise<Uint8Array>;
+export declare function readJson(req: IncomingMessage): Promise<Record<string, unknown>>;
+/** Status HTTP para um erro vindo do core: "não encontrado" e arquivo inexistente viram 404, o resto 400. */
+export declare function statusOf(err: unknown): number;
+/** Texto do erro para a resposta: erro de arquivo do Node traz o caminho absoluto, então vira frase fixa. */
+export declare function publicMessage(err: unknown): string;

package/dist/server/http.js

@@ -0,0 +1,132 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { ExplicaiError } from "../core/errors.js";
+export class HttpError extends Error {
+    status;
+    code;
+    constructor(status, message, 
+    /** Identifica o erro para a interface traduzir (a mensagem fica em português para curl e MCP). */
+    code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export const json = (body, status = 200) => ({ kind: "json", status, body });
+/** `untrusted`: arquivo do manual (/files/), que pode ser um SVG com script; sai com CSP e sandbox. */
+export const file = (filePath, cache = "no-cache", untrusted = false) => ({
+    kind: "file",
+    path: filePath,
+    cache,
+    untrusted,
+});
+const RASTER = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+const UNTRUSTED_CSP = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".woff2": "font/woff2",
+    ".pdf": "application/pdf",
+    ".md": "text/markdown; charset=utf-8",
+};
+export async function send(res, reply, req) {
+    if (reply.kind === "json")
+        return sendJson(res, reply.status, reply.body);
+    const info = await stat(reply.path); // ENOENT vira 404 no chamador, antes de qualquer cabeçalho
+    if (!info.isFile())
+        throw new HttpError(404, "Arquivo não encontrado.");
+    const ext = path.extname(reply.path).toLowerCase();
+    // ETag fraco por tamanho e mtime: barato, sem ler o arquivo.
+    const etag = `W/"${info.size.toString(16)}-${Math.floor(info.mtimeMs).toString(16)}"`;
+    const headers = {
+        etag,
+        "cache-control": reply.cache,
+        "x-content-type-options": "nosniff",
+        ...(reply.untrusted && !RASTER.has(ext) ? { "content-security-policy": UNTRUSTED_CSP } : {}),
+    };
+    // shortcut: só um valor em If-None-Match (o do próprio navegador), sem lista nem "*"; Range/HEAD não tratados.
+    if (req?.headers["if-none-match"] === etag) {
+        res.writeHead(304, headers);
+        res.end();
+        return;
+    }
+    res.writeHead(200, { "content-type": MIME[ext] ?? "application/octet-stream", "content-length": info.size, ...headers });
+    // Erro no meio do envio ou cliente que abortou: o pipeline destrói os dois lados; os cabeçalhos já saíram.
+    await pipeline(createReadStream(reply.path), res).catch(() => { });
+}
+export function sendJson(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(JSON.stringify(body));
+}
+export async function readBody(req, limit) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        // Passou do limite: continua lendo sem guardar. Parar no meio derruba a conexão e o navegador
+        // nunca recebe o 413. shortcut: lê o envio inteiro; tudo bem só porque o servidor é local.
+        if (size <= limit)
+            chunks.push(chunk);
+    }
+    if (size > limit)
+        throw new HttpError(413, `Arquivo maior que ${limit / 1024 / 1024} MB.`);
+    return Buffer.concat(chunks);
+}
+export async function readJson(req) {
+    const raw = await readBody(req, 5 * 1024 * 1024);
+    // Um POST text/plain de outro site não dispara preflight; exigir JSON fecha essa brecha. Corpo vazio não lê nada.
+    if (raw.length > 0 && !/^application\/json\s*(;|$)/i.test(req.headers["content-type"] ?? "")) {
+        throw new HttpError(415, "Envie o corpo como JSON, com o cabeçalho content-type: application/json.", "unsupported-media-type");
+    }
+    let text;
+    try {
+        // fatal: um cliente em Latin-1/cp1252 (curl no Windows) mandaria "í" como 0xED, e o decode comum o trocaria por U+FFFD gravado em disco.
+        text = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+    }
+    catch {
+        throw new HttpError(400, "O corpo da requisição não está em UTF-8 válido. Envie o JSON em UTF-8.", "invalid-utf8");
+    }
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        throw new HttpError(400, "O corpo da requisição não é um JSON válido.");
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new HttpError(400, "O corpo da requisição deve ser um objeto JSON.");
+    }
+    return data;
+}
+/** Status HTTP para um erro vindo do core: "não encontrado" e arquivo inexistente viram 404, o resto 400. */
+export function statusOf(err) {
+    if (err instanceof HttpError)
+        return err.status;
+    if (err instanceof ExplicaiError && err.code === "disk-conflict")
+        return 409;
+    const missing = (err instanceof Error && /não encontrad/i.test(err.message)) ||
+        ["ENOENT", "EISDIR"].includes(err?.code ?? "");
+    return missing ? 404 : 400;
+}
+const FILE_ERRORS = {
+    ENOENT: "Arquivo não encontrado.",
+    EISDIR: "Arquivo não encontrado.",
+    EACCES: "Sem permissão para acessar o arquivo.",
+    EPERM: "Sem permissão para acessar o arquivo.",
+};
+/** Texto do erro para a resposta: erro de arquivo do Node traz o caminho absoluto, então vira frase fixa. */
+export function publicMessage(err) {
+    const fixed = FILE_ERRORS[err?.code ?? ""];
+    return fixed ?? (err instanceof Error ? err.message : String(err));
+}
+//# sourceMappingURL=http.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+import { type Server } from "node:http";
+import { type StudioOptions } from "./router.js";
+export type { StudioOptions } from "./router.js";
+export declare function createStudioServer(opts: StudioOptions): Server;

package/dist/server/index.js

@@ -0,0 +1,60 @@
+import { createServer } from "node:http";
+import { ExplicaiError } from "../core/errors.js";
+import { errorPage, pickLang } from "./errorPage.js";
+import { HttpError, publicMessage, send, sendJson, statusOf } from "./http.js";
+import { matchRoute } from "./router.js";
+import { assetRoutes } from "./routes/assets.js";
+import { exportRoutes } from "./routes/export.js";
+import { fontRoutes } from "./routes/fonts.js";
+import { manualRoutes } from "./routes/manuals.js";
+import { pageRoutes } from "./routes/pages.js";
+import { versionRoutes } from "./routes/versions.js";
+import { webRoutes } from "./routes/web.js";
+import { assertLocalRequest } from "./security.js";
+/** A ordem importa: a rota genérica do editor (`/*`) fica por último. */
+const routes = [
+    ...manualRoutes,
+    ...pageRoutes,
+    ...versionRoutes,
+    ...exportRoutes,
+    ...fontRoutes,
+    ...assetRoutes,
+    ...webRoutes,
+];
+/** Um `%` malformado no endereço é erro de quem pediu (400 com código estável), não falha do servidor. */
+function decodeSegment(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        throw new HttpError(400, "O endereço pedido tem um % malformado. Confira o endereço e tente de novo.", "malformed-url");
+    }
+}
+export function createStudioServer(opts) {
+    return createServer(async (req, res) => {
+        try {
+            assertLocalRequest(req);
+            const url = new URL(req.url ?? "/", "http://localhost");
+            const segments = url.pathname.split("/").filter(Boolean).map(decodeSegment);
+            const method = req.method ?? "GET";
+            const match = matchRoute(routes, method, segments);
+            if (!match)
+                throw new HttpError(segments[0] === "api" ? 405 : 404, "Rota não encontrada.");
+            await send(res, await match.route.handle({ req, url, params: match.params, rest: match.rest, opts }), req);
+        }
+        catch (err) {
+            const { code, params } = err instanceof ExplicaiError ? err : {};
+            const errorCode = code ?? (err instanceof HttpError ? err.code : undefined);
+            const status = statusOf(err);
+            // Quem abre o Studio no navegador recebe uma página legível; a API e os arquivos continuam em JSON.
+            const [first] = (req.url ?? "/").split("?")[0]?.split("/").filter(Boolean) ?? [];
+            if (first !== "api" && first !== "files" && req.headers.accept?.includes("text/html")) {
+                const html = errorPage(status, errorCode ?? (status === 404 ? "not-found" : "error"), pickLang(req.headers["accept-language"]));
+                res.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+                return void res.end(html);
+            }
+            sendJson(res, status, { error: publicMessage(err), code: errorCode, params });
+        }
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/server/router.d.ts

@@ -0,0 +1,30 @@
+import type { IncomingMessage } from "node:http";
+import type { Reply } from "./http.js";
+export interface StudioOptions {
+    /** Pasta onde ficam os manuais. */
+    workspace: string;
+    /** Pasta com o build do editor (index.html e assets). Sem ela, só a API responde. */
+    webDir?: string;
+}
+export interface RouteContext {
+    req: IncomingMessage;
+    url: URL;
+    /** Segmentos `:nome` do padrão da rota, já decodificados. */
+    params: Record<string, string>;
+    /** O que veio depois de um `*` no fim do padrão. */
+    rest: string;
+    opts: StudioOptions;
+}
+export interface Route {
+    method: string;
+    /** Ex.: `/api/manuals/:slug/pages/:id`. Um `*` no fim aceita o resto do caminho. */
+    path: string;
+    handle: (ctx: RouteContext) => Promise<Reply> | Reply;
+}
+export type Match = {
+    route: Route;
+    params: Record<string, string>;
+    rest: string;
+};
+/** Primeira rota cujo método e padrão batem. A ordem da tabela define a prioridade. */
+export declare function matchRoute(routes: Route[], method: string, segments: string[]): Match | null;

package/dist/server/router.js

@@ -0,0 +1,28 @@
+/** Primeira rota cujo método e padrão batem. A ordem da tabela define a prioridade. */
+export function matchRoute(routes, method, segments) {
+    for (const route of routes) {
+        if (route.method !== method)
+            continue;
+        const match = matchPath(route.path, segments);
+        if (match)
+            return { route, ...match };
+    }
+    return null;
+}
+function matchPath(pattern, segments) {
+    const parts = pattern.split("/").filter(Boolean);
+    const params = {};
+    for (const [i, part] of parts.entries()) {
+        if (part === "*")
+            return { params, rest: segments.slice(i).join("/") };
+        const seg = segments[i];
+        if (seg === undefined)
+            return null;
+        if (part.startsWith(":"))
+            params[part.slice(1)] = seg;
+        else if (part !== seg)
+            return null;
+    }
+    return parts.length === segments.length ? { params, rest: "" } : null;
+}
+//# sourceMappingURL=router.js.map

package/dist/server/routes/assets.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "../router.js";
+export declare const assetRoutes: Route[];

package/dist/server/routes/assets.js

@@ -0,0 +1,63 @@
+import { cleanUnusedAssets, findUnusedAssets, insideGitRepo, readAnnotations, redactAsset, resolveInsideReal, saveAsset, writeAnnotations, } from "../../core/index.js";
+import { file, json, readBody, readJson } from "../http.js";
+import { manualDir } from "../workspace.js";
+const MAX_UPLOAD = 20 * 1024 * 1024;
+export const assetRoutes = [
+    {
+        method: "POST",
+        path: "/api/manuals/:slug/assets",
+        handle: async (ctx) => {
+            const name = ctx.url.searchParams.get("name") ?? "imagem.png";
+            const data = await readBody(ctx.req, MAX_UPLOAD);
+            return json({ path: await saveAsset(manualDir(ctx), name, data) }, 201);
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/manuals/:slug/annotations",
+        handle: async (ctx) => json(await readAnnotations(manualDir(ctx), ctx.url.searchParams.get("asset") ?? "")),
+    },
+    {
+        method: "PUT",
+        path: "/api/manuals/:slug/annotations",
+        handle: async (ctx) => json(await writeAnnotations(manualDir(ctx), ctx.url.searchParams.get("asset") ?? "", await readJson(ctx.req))),
+    },
+    {
+        // Troca o print pela versão com as tarjas já pintadas (o navegador desenha) e apaga o original.
+        method: "POST",
+        path: "/api/manuals/:slug/assets/redact",
+        handle: async (ctx) => {
+            const asset = ctx.url.searchParams.get("asset") ?? "";
+            await redactAsset(manualDir(ctx), asset, await readBody(ctx.req, MAX_UPLOAD));
+            return json({ path: asset });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/manuals/:slug/git",
+        handle: async (ctx) => json({ git: await insideGitRepo(manualDir(ctx)) }),
+    },
+    {
+        // Imagens e marcações que nenhuma página, versão ou item da lixeira usa.
+        method: "GET",
+        path: "/api/manuals/:slug/assets/unused",
+        handle: async (ctx) => json({ count: (await findUnusedAssets(manualDir(ctx))).length }),
+    },
+    {
+        // Move as sem uso para .lixeira/imagens-<data>/. Nada é apagado.
+        method: "POST",
+        path: "/api/manuals/:slug/assets/clean",
+        handle: async (ctx) => json(await cleanUnusedAssets(manualDir(ctx))),
+    },
+    {
+        // Imagens do manual, usadas pelo editor: /files/<manual>/assets/<arquivo>
+        method: "GET",
+        path: "/files/:slug/*",
+        // Só raster de assets/ (nome único, gravado uma vez) fica em cache; manual.json, logo e .md revalidam por ETag.
+        handle: async (ctx) => {
+            const cacheable = /^assets\/[^/]+\.(png|jpe?g|gif|webp)$/i.test(ctx.rest);
+            return file(await resolveInsideReal(manualDir(ctx), ctx.rest), cacheable ? "private, max-age=3600" : "no-cache", true);
+        },
+    },
+];
+//# sourceMappingURL=assets.js.map

package/dist/server/routes/export.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "../router.js";
+export declare const exportRoutes: Route[];

package/dist/server/routes/export.js

@@ -0,0 +1,43 @@
+import { EXPORT_FORMATS, exportManual, logoSizeError, setManualLogo, setManualTheme, } from "../../core/index.js";
+import { HttpError, json, readBody, readJson } from "../http.js";
+import { manualDir, optionalString } from "../workspace.js";
+export const exportRoutes = [
+    {
+        // { format: "html" | "pdf" | "markdown", onlyApproved?: true }. Devolve o arquivo gerado e o endereço para abrir no navegador.
+        method: "POST",
+        path: "/api/manuals/:slug/export",
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            const format = optionalString(body.format);
+            if (!format || !EXPORT_FORMATS.includes(format)) {
+                throw new HttpError(400, `Formato de exportação inválido. Use ${EXPORT_FORMATS.join(", ")}.`);
+            }
+            const result = await exportManual(manualDir(ctx), format, { onlyApproved: body.onlyApproved === true });
+            return json({ ...result, url: `/files/${encodeURIComponent(ctx.params.slug ?? "")}/${result.file}` });
+        },
+    },
+    {
+        // Muda só os campos enviados: { accent?, text?, highlight?, headings?: { cover?, page?, h1?, h2?, h3? } },
+        // cada um em hexadecimal ou null para voltar à cor da marca. O core confere formato e contraste (400).
+        method: "PUT",
+        path: "/api/manuals/:slug/theme",
+        handle: async (ctx) => {
+            await setManualTheme(manualDir(ctx), await readJson(ctx.req));
+            return json({ ok: true });
+        },
+    },
+    {
+        // Corpo = o arquivo do logo (PNG, JPG ou SVG, até 1 MB), nome em ?name=. Guarda em assets/ e põe no tema.
+        // O limite de leitura é maior que o do logo para o core recusar com o motivo.
+        method: "POST",
+        path: "/api/manuals/:slug/logo",
+        handle: async (ctx) => {
+            const name = ctx.url.searchParams.get("name") ?? "logo.png";
+            const data = await readBody(ctx.req, 2 * 1024 * 1024).catch((err) => {
+                throw err instanceof HttpError && err.status === 413 ? logoSizeError() : err;
+            });
+            return json({ path: await setManualLogo(manualDir(ctx), name, data) }, 201);
+        },
+    },
+];
+//# sourceMappingURL=export.js.map

package/dist/server/routes/fonts.d.ts

@@ -0,0 +1,3 @@
+import type { Route } from "../router.js";
+/** As fontes que o manual exportado pode usar, para o Studio mostrar a prévia de cada uma. */
+export declare const fontRoutes: Route[];

package/dist/server/routes/fonts.js

@@ -0,0 +1,24 @@
+import { fileURLToPath } from "node:url";
+import { FONTS, FONTS_DIR, fontFiles } from "../../core/index.js";
+import { file, HttpError, json } from "../http.js";
+const FILES = new Set(FONTS.flatMap((f) => fontFiles(f).map((x) => x.file)));
+/** As fontes que o manual exportado pode usar, para o Studio mostrar a prévia de cada uma. */
+export const fontRoutes = [
+    {
+        method: "GET",
+        path: "/api/fonts",
+        handle: () => json(FONTS.map((f) => ({ id: f.id, family: f.family, kind: f.kind, italic: f.italic, files: fontFiles(f) }))),
+    },
+    {
+        method: "GET",
+        path: "/api/fonts/:file",
+        handle: ({ params }) => {
+            const name = params.file ?? "";
+            // Só os arquivos da lista: o nome vem da URL e não vira caminho de disco.
+            if (!FILES.has(name))
+                throw new HttpError(404, "Fonte não encontrada.");
+            return file(fileURLToPath(new URL(name, FONTS_DIR)), "max-age=86400");
+        },
+    },
+];
+//# sourceMappingURL=fonts.js.map

package/dist/server/routes/manuals.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "../router.js";
+export declare const manualRoutes: Route[];

package/dist/server/routes/manuals.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { createManual, listManuals, readManual, readPageTree } from "../../core/index.js";
+import { json, readJson } from "../http.js";
+import { manualDir, optionalString } from "../workspace.js";
+const summary = (m) => ({ slug: path.basename(m.dir), title: m.meta.title, language: m.meta.language });
+export const manualRoutes = [
+    {
+        method: "GET",
+        path: "/api/manuals",
+        handle: async ({ opts }) => json((await listManuals(opts.workspace)).map(summary)),
+    },
+    {
+        method: "POST",
+        path: "/api/manuals",
+        handle: async ({ opts, req }) => {
+            const body = await readJson(req);
+            const manual = await createManual(opts.workspace, {
+                title: optionalString(body.title) ?? "",
+                language: optionalString(body.language) ?? "pt-BR",
+            });
+            return json(summary(manual), 201);
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/manuals/:slug",
+        handle: async (ctx) => {
+            const dir = manualDir(ctx);
+            const meta = await readManual(dir);
+            return json({
+                slug: ctx.params.slug,
+                title: meta.title,
+                language: meta.language,
+                theme: meta.theme ?? {},
+                pages: await readPageTree(dir),
+            });
+        },
+    },
+];
+//# sourceMappingURL=manuals.js.map

package/dist/server/routes/pages.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "../router.js";
+export declare const pageRoutes: Route[];

package/dist/server/routes/pages.js

@@ -0,0 +1,79 @@
+import { addPage, listTrash, movePage, readPage, removePage, restorePage, updatePage, } from "../../core/index.js";
+import { json, readJson } from "../http.js";
+import { manualDir, optionalNumber, optionalString } from "../workspace.js";
+const PAGE = "/api/manuals/:slug/pages/:id";
+export const pageRoutes = [
+    {
+        method: "POST",
+        path: "/api/manuals/:slug/pages",
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            const text = optionalString(body.body);
+            const index = optionalNumber(body.index);
+            const page = await addPage(manualDir(ctx), {
+                title: optionalString(body.title) ?? "",
+                parentId: optionalString(body.parentId) ?? null,
+                ...(text === undefined ? {} : { body: text }),
+                ...(index === undefined ? {} : { index }),
+            });
+            return json(page, 201);
+        },
+    },
+    {
+        method: "GET",
+        path: PAGE,
+        handle: async (ctx) => json(await readPage(manualDir(ctx), ctx.params.id ?? "")),
+    },
+    {
+        method: "PUT",
+        path: PAGE,
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            const title = optionalString(body.title);
+            const text = optionalString(body.body);
+            const status = optionalString(body.status);
+            const patch = {
+                ...(title === undefined ? {} : { title }),
+                ...(text === undefined ? {} : { body: text }),
+                ...(status === undefined ? {} : { status }),
+            };
+            const fileName = body.fileName === "keep" || body.fileName === "sync" ? body.fileName : undefined;
+            const ifMatch = ctx.req.headers["if-match"];
+            return json(await updatePage(manualDir(ctx), ctx.params.id ?? "", patch, { fileName, ifMatch }));
+        },
+    },
+    {
+        method: "DELETE",
+        path: PAGE,
+        handle: async (ctx) => {
+            // O trashId permite desfazer: POST /api/manuals/:slug/trash/:trashId/restore
+            return json(await removePage(manualDir(ctx), ctx.params.id ?? ""));
+        },
+    },
+    {
+        method: "POST",
+        path: `${PAGE}/move`,
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            await movePage(manualDir(ctx), ctx.params.id ?? "", {
+                parentId: optionalString(body.parentId) ?? null,
+                index: optionalNumber(body.index) ?? 0,
+            });
+            return json({ ok: true });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/manuals/:slug/trash",
+        handle: async (ctx) => json(await listTrash(manualDir(ctx))),
+    },
+    {
+        method: "POST",
+        path: "/api/manuals/:slug/trash/:trashId/restore",
+        handle: async (ctx) => {
+            await restorePage(manualDir(ctx), ctx.params.trashId ?? "");
+            return json({ ok: true });
+        },
+    },
+];
+//# sourceMappingURL=pages.js.map

package/dist/server/routes/versions.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "../router.js";
+export declare const versionRoutes: Route[];

package/dist/server/routes/versions.js

@@ -0,0 +1,43 @@
+import { listVersions, publishVersion, readVersion, restoreVersion, saveVersion } from "../../core/index.js";
+import { HttpError, json, readJson } from "../http.js";
+import { manualDir, optionalString } from "../workspace.js";
+const VERSIONS = "/api/manuals/:slug/pages/:id/versions";
+export const versionRoutes = [
+    {
+        method: "GET",
+        path: VERSIONS,
+        handle: async (ctx) => json(await listVersions(manualDir(ctx), ctx.params.id ?? "")),
+    },
+    {
+        method: "POST",
+        path: VERSIONS,
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            return json(await saveVersion(manualDir(ctx), ctx.params.id ?? "", optionalString(body.note) ?? ""), 201);
+        },
+    },
+    {
+        method: "GET",
+        path: `${VERSIONS}/:versionId`,
+        handle: async (ctx) => json(await readVersion(manualDir(ctx), ctx.params.id ?? "", ctx.params.versionId ?? "")),
+    },
+    {
+        method: "POST",
+        path: `${VERSIONS}/:versionId/restore`,
+        handle: async (ctx) => json(await restoreVersion(manualDir(ctx), ctx.params.id ?? "", ctx.params.versionId ?? "")),
+    },
+    {
+        // { versionId: "<id>" } escolhe a versão do manual final; { versionId: null } volta ao texto atual.
+        method: "PUT",
+        path: "/api/manuals/:slug/pages/:id/published",
+        handle: async (ctx) => {
+            const body = await readJson(ctx.req);
+            const versionId = body.versionId === null ? null : optionalString(body.versionId);
+            if (versionId === undefined)
+                throw new HttpError(400, "Informe versionId (texto ou null).");
+            await publishVersion(manualDir(ctx), ctx.params.id ?? "", versionId);
+            return json({ ok: true });
+        },
+    },
+];
+//# sourceMappingURL=versions.js.map

package/dist/server/routes/web.d.ts

@@ -0,0 +1,3 @@
+import type { Route } from "../router.js";
+/** Arquivos do editor. Caminho que não é arquivo cai no index.html (aplicação de página única). */
+export declare const webRoutes: Route[];

package/dist/server/routes/web.js

@@ -0,0 +1,29 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { resolveInside } from "../../core/index.js";
+import { file, HttpError } from "../http.js";
+/** Arquivos do editor. Caminho que não é arquivo cai no index.html (aplicação de página única). */
+export const webRoutes = [
+    {
+        method: "GET",
+        path: "/*",
+        handle: async ({ opts, rest }) => {
+            // Chamada de API errada não pode receber o index.html do editor como resposta.
+            if (!opts.webDir || rest === "api" || rest.startsWith("api/"))
+                throw new HttpError(404, "Não encontrado.");
+            const target = resolveInside(opts.webDir, rest || "index.html");
+            const isFile = await stat(target).then((s) => s.isFile(), () => false);
+            // Só os arquivos com hash no nome (assets/) podem ficar em cache; o index.html muda a cada build.
+            if (isFile && rest.startsWith("assets/"))
+                return file(target, "max-age=31536000, immutable");
+            if (isFile)
+                return file(target);
+            const index = path.join(opts.webDir, "index.html");
+            const hasIndex = await stat(index).then((s) => s.isFile(), () => false);
+            if (!hasIndex)
+                throw new HttpError(500, "O editor não foi encontrado: rode npm run build.", "web-missing");
+            return file(index);
+        },
+    },
+];
+//# sourceMappingURL=web.js.map

package/dist/server/security.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage } from "node:http";
+/**
+ * O Studio só atende o próprio computador. Checar Host e Origin (que deve ser igual ao Host) impede que um site aberto
+ * no navegador use o Studio (DNS rebinding e requisições de outra origem).
+ */
+export declare function assertLocalRequest(req: IncomingMessage): void;