explicai 0.0.0-stage → 0.2.0

package/dist/core/redact.js

@@ -0,0 +1,107 @@
+import { randomUUID } from "node:crypto";
+import { readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { assetFile } from "./assets.js";
+import { ExplicaiError } from "./errors.js";
+import { imageSize } from "./export/imageSize.js";
+import { exists } from "./fs.js";
+import { ASSETS_DIR } from "./manuals.js";
+const FORMATS = { ".png": "png", ".jpg": "jpeg", ".jpeg": "jpeg", ".webp": "webp" };
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+/** Blocos do PNG que carregam metadados (EXIF e texto): não entram no arquivo tarjado. */
+const PNG_METADATA = new Set(["eXIf", "tEXt", "zTXt", "iTXt"]);
+const invalid = (why) => new ExplicaiError("redact-invalid", `A imagem tarjada não pôde ser gravada: ${why}.`, { why });
+/** PNG sem metadados e sem nenhum byte depois do IEND (o erro do aCropalypse). */
+function cleanPng(b) {
+    if (!b.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw invalid("o conteúdo não é um PNG");
+    const kept = [PNG_SIGNATURE];
+    for (let i = 8; i + 12 <= b.length;) {
+        const end = i + 12 + b.readUInt32BE(i);
+        if (end > b.length)
+            break;
+        const type = b.toString("ascii", i + 4, i + 8);
+        if (!PNG_METADATA.has(type))
+            kept.push(b.subarray(i, end));
+        if (type === "IEND")
+            return Buffer.concat(kept);
+        i = end;
+    }
+    throw invalid("o PNG está incompleto");
+}
+// shortcut: JPEG e WebP vêm do canvas do navegador, que não grava EXIF; aqui só recusa o que trouxer.
+// Quando outro cliente puder enviar, troque a recusa por limpeza dos segmentos APP1/EXIF.
+function cleanJpeg(b) {
+    const end = b.lastIndexOf(Buffer.from([0xff, 0xd9]));
+    if (b[0] !== 0xff || b[1] !== 0xd8 || end < 0)
+        throw invalid("o conteúdo não é um JPEG");
+    const clean = b.subarray(0, end + 2);
+    if (clean.includes("Exif\0\0", 0, "latin1"))
+        throw invalid("o arquivo traz EXIF");
+    return clean;
+}
+function cleanWebp(b) {
+    if (b.length < 12 || b.toString("ascii", 0, 4) !== "RIFF" || b.toString("ascii", 8, 12) !== "WEBP") {
+        throw invalid("o conteúdo não é um WebP");
+    }
+    const total = b.readUInt32LE(4) + 8;
+    if (total > b.length)
+        throw invalid("o WebP está incompleto");
+    const clean = b.subarray(0, total);
+    if (clean.includes("EXIF", 12, "latin1"))
+        throw invalid("o arquivo traz EXIF");
+    return clean;
+}
+/**
+ * Troca o arquivo de `assets/` pela versão com as tarjas já queimadas (o navegador desenha e envia).
+ * Valida o formato e que a imagem abre, grava num temporário e renomeia por cima do caminho de sempre,
+ * então Markdown e marcações seguem valendo. O original não vai para a lixeira: some, junto com
+ * qualquer cópia idêntica dele na pasta de imagens sem uso.
+ */
+export async function redactAsset(dir, assetPath, data) {
+    const target = assetFile(dir, assetPath);
+    const format = FORMATS[path.extname(target).toLowerCase()];
+    if (!format)
+        throw new ExplicaiError("redact-type", "Só dá para ocultar dados em PNG, JPEG ou WebP.");
+    if (!(await exists(target)))
+        throw new ExplicaiError("redact-missing", `A imagem ${assetPath} não existe.`, { asset: assetPath });
+    const original = await readFile(target);
+    const clean = { png: cleanPng, jpeg: cleanJpeg, webp: cleanWebp }[format](Buffer.from(data));
+    const tmp = `${target}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(tmp, clean);
+        const after = await imageSize(tmp);
+        // tamanho livre: recortar e reduzir resolução (T-118, T-119) reusam esta troca
+        if (!after)
+            throw invalid("a imagem não pôde ser lida");
+        await rename(tmp, target);
+    }
+    finally {
+        await rm(tmp, { force: true });
+    }
+    await dropTrashedCopies(dir, path.basename(target), original);
+}
+/** Cópias idênticas ao original em `.lixeira/imagens-*` (imagens sem uso) também são apagadas. */
+async function dropTrashedCopies(dir, name, original) {
+    const trash = path.join(dir, ".lixeira");
+    if (!(await exists(trash)))
+        return;
+    for (const folder of await readdir(trash)) {
+        const copy = path.join(trash, folder, ASSETS_DIR, name);
+        if (folder.startsWith("imagens-") &&
+            (await stat(copy).catch(() => null))?.isFile() &&
+            (await readFile(copy)).equals(original)) {
+            await rm(copy);
+        }
+    }
+}
+/** A pasta do manual está dentro de um repositório git? Procura `.git` na pasta e nas de cima. */
+export async function insideGitRepo(dir) {
+    for (let cur = path.resolve(dir);; cur = path.dirname(cur)) {
+        if (await exists(path.join(cur, ".git")))
+            return true;
+        if (path.dirname(cur) === cur)
+            return false;
+    }
+}
+//# sourceMappingURL=redact.js.map

package/dist/core/text.d.ts

@@ -0,0 +1,5 @@
+export declare function slugify(title: string): string;
+/** Texto obrigatório, sem espaços nas pontas. `what` entra na mensagem: "O título da página não pode ficar vazio." */
+export declare function required(value: string, what: string): string;
+/** decodeURI que não lança: um `%` solto num link ou numa imagem (`100%.png`) é texto comum, não motivo para a exportação falhar. */
+export declare function decodeUri(text: string): string;

package/dist/core/text.js

@@ -0,0 +1,28 @@
+export function slugify(title) {
+    const slug = title
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60)
+        .replace(/-+$/, "");
+    return slug || "sem-titulo";
+}
+/** Texto obrigatório, sem espaços nas pontas. `what` entra na mensagem: "O título da página não pode ficar vazio." */
+export function required(value, what) {
+    const v = value.trim();
+    if (!v)
+        throw new Error(`O ${what} não pode ficar vazio.`);
+    return v;
+}
+/** decodeURI que não lança: um `%` solto num link ou numa imagem (`100%.png`) é texto comum, não motivo para a exportação falhar. */
+export function decodeUri(text) {
+    try {
+        return decodeURI(text);
+    }
+    catch {
+        return text;
+    }
+}
+//# sourceMappingURL=text.js.map

package/dist/core/trash.d.ts

@@ -0,0 +1,25 @@
+/** Páginas excluídas ficam aqui até serem restauradas ou apagadas à mão. */
+export declare const TRASH_DIR = ".lixeira";
+export interface TrashItem {
+    trashId: string;
+    /** Id da página principal, para abrir de novo depois de restaurar. */
+    pageId: string;
+    title: string;
+    /** Quantas páginas voltam ao restaurar (a página mais as subpáginas). */
+    pages: number;
+    deletedAt: string;
+}
+/** O que está na lixeira, da exclusão mais recente para a mais antiga. */
+export declare function listTrash(dir: string): Promise<TrashItem[]>;
+/**
+ * Tira a página (e as subpáginas) da árvore e move os arquivos para a lixeira do manual.
+ * Devolve o id da lixeira, usado para desfazer. Imagens ficam em assets/, porque outras páginas podem usar.
+ */
+export declare function removePage(dir: string, id: string): Promise<{
+    trashId: string;
+}>;
+/**
+ * Devolve a página ao lugar de onde saiu. Se o pai também foi excluído, ela volta para a raiz.
+ * Se outro arquivo ocupou o nome nesse meio tempo, ela ganha um nome novo.
+ */
+export declare function restorePage(dir: string, trashId: string): Promise<void>;

package/dist/core/trash.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, rename, rm } from "node:fs/promises";
+import path from "node:path";
+import { splitFrontmatter } from "./frontmatter.js";
+import { atomicWrite, exists, readText, relativePosix, resolveInside, uniquePath } from "./fs.js";
+import { PAGES_DIR, updateManual } from "./manuals.js";
+import { childrenOf, clampIndex, findIn, findNode, flatten } from "./tree.js";
+/** Páginas excluídas ficam aqui até serem restauradas ou apagadas à mão. */
+export const TRASH_DIR = ".lixeira";
+/** O que está na lixeira, da exclusão mais recente para a mais antiga. */
+export async function listTrash(dir) {
+    const root = path.join(dir, TRASH_DIR);
+    if (!(await exists(root)))
+        return [];
+    const items = [];
+    for (const trashId of await readdir(root)) {
+        const entryFile = path.join(root, trashId, "entry.json");
+        if (!(await exists(entryFile)))
+            continue;
+        try {
+            const entry = JSON.parse(await readText(entryFile));
+            const pageFile = path.join(root, trashId, entry.node.file);
+            const data = (await exists(pageFile)) ? splitFrontmatter(await readText(pageFile)).data : {};
+            const title = typeof data.title === "string" ? data.title : "";
+            items.push({ trashId, pageId: entry.node.id, title, pages: flatten([entry.node]).length, deletedAt: entry.deletedAt });
+        }
+        catch {
+            // entry.json quebrado ou de forma errada: pula o item em vez de esconder a lixeira toda
+        }
+    }
+    return items.sort((a, b) => b.deletedAt.localeCompare(a.deletedAt));
+}
+/**
+ * Tira a página (e as subpáginas) da árvore e move os arquivos para a lixeira do manual.
+ * Devolve o id da lixeira, usado para desfazer. Imagens ficam em assets/, porque outras páginas podem usar.
+ */
+export async function removePage(dir, id) {
+    const entry = await updateManual(dir, (meta) => {
+        const { node, siblings } = findNode(meta.pages, id);
+        const index = siblings.indexOf(node);
+        siblings.splice(index, 1);
+        return { node, parentId: parentOf(meta.pages, siblings), index, deletedAt: new Date().toISOString() };
+    });
+    const trashId = randomUUID();
+    const trash = path.join(dir, TRASH_DIR, trashId);
+    await mkdir(path.join(trash, PAGES_DIR), { recursive: true });
+    for (const n of flatten([entry.node])) {
+        const from = resolveInside(dir, n.file);
+        if (await exists(from))
+            await rename(from, path.join(trash, n.file));
+    }
+    await atomicWrite(path.join(trash, "entry.json"), `${JSON.stringify(entry, null, 2)}\n`);
+    return { trashId };
+}
+/**
+ * Devolve a página ao lugar de onde saiu. Se o pai também foi excluído, ela volta para a raiz.
+ * Se outro arquivo ocupou o nome nesse meio tempo, ela ganha um nome novo.
+ */
+export async function restorePage(dir, trashId) {
+    const trash = resolveInside(path.join(dir, TRASH_DIR), trashId);
+    const entry = JSON.parse(await readText(path.join(trash, "entry.json")));
+    for (const n of flatten([entry.node])) {
+        const from = path.join(trash, n.file);
+        let to = resolveInside(dir, n.file);
+        if (await exists(to)) {
+            to = await uniquePath(path.join(dir, PAGES_DIR), path.basename(n.file, ".md"), ".md");
+            n.file = relativePosix(dir, to);
+        }
+        if (await exists(from))
+            await rename(from, to);
+    }
+    await updateManual(dir, (meta) => {
+        const parentId = entry.parentId && findIn(meta.pages, entry.parentId) ? entry.parentId : null;
+        const siblings = childrenOf(meta.pages, parentId);
+        siblings.splice(clampIndex(entry.index, siblings.length), 0, entry.node);
+    });
+    await rm(trash, { recursive: true, force: true });
+}
+function parentOf(nodes, siblings) {
+    if (siblings === nodes)
+        return null;
+    return flatten(nodes).find((n) => n.children === siblings)?.id ?? null;
+}
+//# sourceMappingURL=trash.js.map

package/dist/core/tree.d.ts

@@ -0,0 +1,13 @@
+import type { PageNode } from "./types.js";
+export interface Located {
+    node: PageNode;
+    /** O array que contém o nó, para inserir ou remover sem buscar de novo. */
+    siblings: PageNode[];
+}
+export declare function findNode(nodes: PageNode[], id: string): Located;
+export declare function findIn(nodes: PageNode[], id: string): Located | undefined;
+/** Lista de filhos onde inserir: os da página `parentId`, ou a raiz quando é null. */
+export declare function childrenOf(nodes: PageNode[], parentId: string | null | undefined): PageNode[];
+/** Percorre a árvore em ordem de leitura (pai antes dos filhos). */
+export declare function flatten(nodes: PageNode[]): PageNode[];
+export declare function clampIndex(index: number | undefined, length: number): number;

package/dist/core/tree.js

@@ -0,0 +1,28 @@
+export function findNode(nodes, id) {
+    const found = findIn(nodes, id);
+    if (!found)
+        throw new Error(`Página não encontrada: ${id}`);
+    return found;
+}
+export function findIn(nodes, id) {
+    for (const node of nodes) {
+        if (node.id === id)
+            return { node, siblings: nodes };
+        const inner = findIn(node.children, id);
+        if (inner)
+            return inner;
+    }
+    return undefined;
+}
+/** Lista de filhos onde inserir: os da página `parentId`, ou a raiz quando é null. */
+export function childrenOf(nodes, parentId) {
+    return parentId ? findNode(nodes, parentId).node.children : nodes;
+}
+/** Percorre a árvore em ordem de leitura (pai antes dos filhos). */
+export function flatten(nodes) {
+    return nodes.flatMap((n) => [n, ...flatten(n.children)]);
+}
+export function clampIndex(index, length) {
+    return index === undefined ? length : Math.max(0, Math.min(index, length));
+}
+//# sourceMappingURL=tree.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,111 @@
+/** Formato em disco de um manual. Ver docs/manual-format.md. */
+export declare const FORMAT_VERSION = 1;
+/** Nó da árvore de páginas guardada em manual.json. O título fica só no frontmatter da página. */
+export interface PageNode {
+    id: string;
+    /** Caminho relativo à pasta do manual, sempre em `pages/`. */
+    file: string;
+    /** Versão escolhida para o manual final (arquivo em `.versoes/<id>/`). Sem ela, vale o texto atual. */
+    published?: string;
+    children: PageNode[];
+}
+export interface ManualMeta {
+    version: typeof FORMAT_VERSION;
+    title: string;
+    /** Tag BCP 47, como `pt-BR` ou `en-US`. */
+    language: string;
+    /** Aparência do manual exportado. Sem ela, vale a cor da marca. */
+    theme?: ManualTheme;
+    pages: PageNode[];
+}
+/** Onde o manual exportado tem título: a capa, o título da página e os níveis 1 a 3 do editor. */
+export declare const HEADING_SLOTS: readonly ["cover", "page", "h1", "h2", "h3"];
+export type HeadingSlot = (typeof HEADING_SLOTS)[number];
+/**
+ * Cores do manual exportado, todas em hexadecimal (#2b4fe0). Campo ausente = cor da marca.
+ * Texto, títulos e destaque precisam de contraste de 4,5:1 com o branco.
+ */
+export interface ManualTheme {
+    /** Destaque: links, números dos passos e marcações sobre os prints. */
+    accent?: string;
+    /** Texto do manual. */
+    text?: string;
+    /** Marca-texto: capa, "Resultado:" e destaque das imagens. */
+    highlight?: string;
+    /** Cor de cada tipo de título. Sem escolha, saem pretos. */
+    headings?: Partial<Record<HeadingSlot, string>>;
+    /** Fontes do manual, pelo nome da lista de `export/fonts.ts` (`inter`, `lora`…). Sem escolha: Atkinson e Archivo. */
+    fonts?: {
+        text?: string;
+        headings?: string;
+    };
+    /** Logo do cliente na capa e no topo do sumário: `assets/<arquivo>`, PNG, JPG ou SVG de até 1 MB. */
+    logo?: string;
+}
+export interface Manual {
+    /** Caminho absoluto da pasta do manual. */
+    dir: string;
+    meta: ManualMeta;
+}
+/** Etapa da página no fluxo de aprovação. Sem status no arquivo, a página é rascunho. */
+export declare const PAGE_STATUSES: readonly ["rascunho", "revisao", "aprovado", "publicado"];
+export type PageStatus = (typeof PAGE_STATUSES)[number];
+export interface Page {
+    id: string;
+    title: string;
+    status: PageStatus;
+    /** Conteúdo em Markdown, sem o frontmatter. */
+    body: string;
+    file: string;
+    /** Impressão do arquivo no disco (mtime+tamanho). Muda quando alguém edita fora do Studio. */
+    version?: string;
+}
+/** Coordenadas normalizadas de 0 a 1, relativas à largura e à altura da imagem. */
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect extends Point {
+    w: number;
+    h: number;
+}
+export interface Marker extends Point {
+    id: string;
+    /** Número exibido no marcador e na legenda. */
+    n: number;
+    label?: string;
+}
+export interface Highlight extends Rect {
+    id: string;
+}
+export interface Arrow {
+    id: string;
+    from: Point;
+    to: Point;
+}
+export type HotspotTarget = {
+    type: "page";
+    pageId: string;
+} | {
+    type: "anchor";
+    pageId: string;
+    anchor: string;
+} | {
+    type: "url";
+    href: string;
+};
+export interface Hotspot extends Rect {
+    id: string;
+    target: HotspotTarget;
+}
+/** Tamanho de exibição da imagem: pequena, média ou larga. Sem o campo, a imagem aparece como sempre. */
+export type ImageDisplay = "s" | "m" | "full";
+/** Conteúdo do JSON que fica ao lado de cada imagem (`assets/foto.png.json`). */
+export interface Annotations {
+    version: typeof FORMAT_VERSION;
+    display?: ImageDisplay;
+    markers: Marker[];
+    highlights: Highlight[];
+    arrows: Arrow[];
+    hotspots: Hotspot[];
+}

package/dist/core/types.js

@@ -0,0 +1,7 @@
+/** Formato em disco de um manual. Ver docs/manual-format.md. */
+export const FORMAT_VERSION = 1;
+/** Onde o manual exportado tem título: a capa, o título da página e os níveis 1 a 3 do editor. */
+export const HEADING_SLOTS = ["cover", "page", "h1", "h2", "h3"];
+/** Etapa da página no fluxo de aprovação. Sem status no arquivo, a página é rascunho. */
+export const PAGE_STATUSES = ["rascunho", "revisao", "aprovado", "publicado"];
+//# sourceMappingURL=types.js.map

package/dist/core/versions.d.ts

@@ -0,0 +1,27 @@
+import type { Page } from "./types.js";
+/** Versões guardadas de cada página: `.versoes/<id da página>/<data>.md`, uma cópia completa por versão. */
+export declare const VERSIONS_DIR = ".versoes";
+export interface VersionInfo {
+    id: string;
+    title: string;
+    /** Nome que a pessoa deu ao guardar ("Revisado pelo suporte"). Pode ser vazio. */
+    note: string;
+    savedAt: string;
+    /** É a versão escolhida para o manual final. */
+    published: boolean;
+}
+export interface Version extends VersionInfo {
+    body: string;
+}
+/** Guarda o texto atual da página como uma versão nova. */
+export declare function saveVersion(dir: string, pageId: string, note?: string): Promise<VersionInfo>;
+/** Versões da página, da mais recente para a mais antiga. */
+export declare function listVersions(dir: string, pageId: string): Promise<VersionInfo[]>;
+export declare function readVersion(dir: string, pageId: string, versionId: string): Promise<Version>;
+/**
+ * Volta a página para o texto da versão. O texto que estava antes vira uma versão
+ * ("Antes de restaurar"), para restaurar nunca apagar nada.
+ */
+export declare function restoreVersion(dir: string, pageId: string, versionId: string): Promise<Page>;
+/** Escolhe a versão que vai para o manual final. `null` volta a valer o texto atual da página. */
+export declare function publishVersion(dir: string, pageId: string, versionId: string | null): Promise<void>;

package/dist/core/versions.js

@@ -0,0 +1,82 @@
+import { mkdir, readdir } from "node:fs/promises";
+import path from "node:path";
+import { joinFrontmatter, splitFrontmatter } from "./frontmatter.js";
+import { atomicWrite, exists, readText, resolveInside, uniquePath } from "./fs.js";
+import { readManual, updateManual } from "./manuals.js";
+import { readPage, updatePage } from "./pages.js";
+import { findNode } from "./tree.js";
+/** Versões guardadas de cada página: `.versoes/<id da página>/<data>.md`, uma cópia completa por versão. */
+export const VERSIONS_DIR = ".versoes";
+const pageVersionsDir = (dir, pageId) => resolveInside(dir, path.posix.join(VERSIONS_DIR, pageId));
+const versionFile = (dir, pageId, versionId) => resolveInside(pageVersionsDir(dir, pageId), `${versionId}.md`);
+/** Guarda o texto atual da página como uma versão nova. */
+export async function saveVersion(dir, pageId, note = "") {
+    const page = await readPage(dir, pageId);
+    const savedAt = new Date().toISOString();
+    const folder = pageVersionsDir(dir, pageId);
+    await mkdir(folder, { recursive: true });
+    // A data vira o nome do arquivo: a pasta fica em ordem e legível sem o Studio.
+    const file = await uniquePath(folder, savedAt.replace(/[:.]/g, "-"), ".md");
+    const clean = note.trim().slice(0, 200);
+    await atomicWrite(file, joinFrontmatter({ id: page.id, title: page.title, savedAt, note: clean }, page.body));
+    return { id: path.basename(file, ".md"), title: page.title, note: clean, savedAt, published: false };
+}
+/** Versões da página, da mais recente para a mais antiga. */
+export async function listVersions(dir, pageId) {
+    const { node } = findNode((await readManual(dir)).pages, pageId);
+    const folder = pageVersionsDir(dir, pageId);
+    if (!(await exists(folder)))
+        return [];
+    const list = [];
+    for (const name of await readdir(folder)) {
+        if (!name.endsWith(".md"))
+            continue;
+        const { body: _, ...info } = await readVersionFile(path.join(folder, name), node.published);
+        list.push(info);
+    }
+    return list.sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+}
+export async function readVersion(dir, pageId, versionId) {
+    const { node } = findNode((await readManual(dir)).pages, pageId);
+    return readVersionFile(versionFile(dir, pageId, versionId), node.published);
+}
+/**
+ * Volta a página para o texto da versão. O texto que estava antes vira uma versão
+ * ("Antes de restaurar"), para restaurar nunca apagar nada.
+ */
+export async function restoreVersion(dir, pageId, versionId) {
+    const version = await readVersion(dir, pageId, versionId);
+    const current = await readPage(dir, pageId);
+    if (current.title !== version.title || current.body !== version.body) {
+        await saveVersion(dir, pageId, "Antes de restaurar");
+    }
+    return updatePage(dir, pageId, { title: version.title, body: version.body });
+}
+/** Escolhe a versão que vai para o manual final. `null` volta a valer o texto atual da página. */
+export async function publishVersion(dir, pageId, versionId) {
+    if (versionId !== null)
+        await readVersion(dir, pageId, versionId);
+    await updateManual(dir, (meta) => {
+        const { node } = findNode(meta.pages, pageId);
+        if (versionId === null)
+            delete node.published;
+        else
+            node.published = versionId;
+    });
+}
+async function readVersionFile(file, published) {
+    let text;
+    try {
+        text = await readText(file);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            throw new Error(`Versão não encontrada: ${path.basename(file, ".md")}`);
+        throw err;
+    }
+    const { data, body } = splitFrontmatter(text);
+    const id = path.basename(file, ".md");
+    const str = (v) => (typeof v === "string" ? v : "");
+    return { id, title: str(data.title), note: str(data.note), savedAt: str(data.savedAt), published: id === published, body };
+}
+//# sourceMappingURL=versions.js.map

package/dist/server/errorPage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Página de erro para quem abre o Studio no navegador e o servidor não consegue entregar o editor.
+ * Sem dependências: mesma composição do ErrorPage do editor (web/src/components/ErrorPage.tsx); mexeu lá, alinhe aqui.
+ * O trecho entre asteriscos no título leva o marca-texto.
+ */
+type Lang = "pt" | "en";
+export declare function pickLang(acceptLanguage: string | undefined): Lang;
+export declare function errorPage(status: number, code: string, lang: Lang): string;
+export {};

package/dist/server/errorPage.js

@@ -0,0 +1,122 @@
+/**
+ * Página de erro para quem abre o Studio no navegador e o servidor não consegue entregar o editor.
+ * Sem dependências: mesma composição do ErrorPage do editor (web/src/components/ErrorPage.tsx); mexeu lá, alinhe aqui.
+ * O trecho entre asteriscos no título leva o marca-texto.
+ */
+import { FONTS, fontFaceCss } from "../core/export/fonts.js";
+const TEXTS = {
+    "web-missing": {
+        pt: [
+            "O editor *não foi encontrado*",
+            "O servidor do Studio está no ar, mas a pasta do editor está vazia ou não existe. Rode npm run build (ou instale o pacote de novo) e abra esta página outra vez.",
+        ],
+        en: [
+            "The editor *was not found*",
+            "The Studio server is running, but the editor folder is empty or missing. Run npm run build (or reinstall the package) and open this page again.",
+        ],
+    },
+    "forbidden-host": {
+        pt: ["Acesso só *deste computador*", "O Studio só aceita pedidos deste computador. Abra-o por localhost ou 127.0.0.1."],
+        en: [
+            "Access from *this computer* only",
+            "The Studio only accepts requests from this computer. Open it through localhost or 127.0.0.1.",
+        ],
+    },
+    "forbidden-origin": {
+        pt: ["Acesso só *deste computador*", "O Studio só aceita pedidos deste computador. Abra-o por localhost ou 127.0.0.1."],
+        en: [
+            "Access from *this computer* only",
+            "The Studio only accepts requests from this computer. Open it through localhost or 127.0.0.1.",
+        ],
+    },
+    "malformed-url": {
+        pt: ["Endereço *malformado*", "Este endereço tem um % que o Studio não entende. Volte para o início e escolha o manual."],
+        en: ["Malformed *address*", "This address has a % the Studio cannot read. Go back to the start and pick the manual."],
+    },
+    "not-found": {
+        pt: ["Página *não encontrada*", "Este endereço não existe no Studio. Volte para o início e escolha o manual."],
+        en: ["Page *not found*", "This address does not exist in the Studio. Go back to the start and pick the manual."],
+    },
+    error: {
+        pt: [
+            "O Studio *não conseguiu responder*",
+            "Algo deu errado no servidor. Recarregue a página; se continuar, feche o comando explicai no terminal e rode de novo.",
+        ],
+        en: [
+            "The Studio *could not respond*",
+            "Something went wrong on the server. Reload the page; if it keeps happening, stop the explicai command in the terminal and run it again.",
+        ],
+    },
+};
+const esc = (s) => s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c] ?? c);
+export function pickLang(acceptLanguage) {
+    return /^\s*pt/i.test(acceptLanguage ?? "") ? "pt" : "en";
+}
+const UI = {
+    pt: { home: "Ir para o início", reload: "Recarregar", copy: "Copiar código", copied: "Copiado" },
+    en: { home: "Go to the start", reload: "Reload", copy: "Copy code", copied: "Copied" },
+};
+// As fontes da marca vêm da rota /api/fonts do próprio servidor (sem CDN); se não carregarem, cai na do sistema.
+const FACES = FONTS.filter((f) => f.id === "atkinson-hyperlegible-next" || f.id === "archivo")
+    .map((f) => fontFaceCss(f).replaceAll("url(fonts/", "url(/api/fonts/"))
+    .join("");
+// Mesmos valores de web/src/styles/tokens.css e do wordmark de base.css.
+const CSS = `${FACES}
+:root{color-scheme:light dark;--p:#f5f6fa;--t:#151a33;--g:#575e78;--c:#2b4fe0;--s:#fff;--l:#dce0eb;--m:rgba(255,212,59,.55);--a:#2b4fe0}
+@media(prefers-color-scheme:dark){:root{--p:#0e1120;--t:#eceef7;--g:#9ca3bd;--c:#7088ff;--s:#0e1120;--l:#2a3050;--m:rgba(255,212,59,.3);--a:#ffd43b}}
+*{box-sizing:border-box}
+body{margin:0;min-height:100vh;display:flex;flex-direction:column;background:var(--p);color:var(--t);font:17px/1.5 "Atkinson Hyperlegible Next","Segoe UI",system-ui,sans-serif}
+header,main{width:100%;max-width:64rem;margin:0 auto}
+header{padding:1.25rem 1.25rem}
+.brand{display:inline-flex;align-items:center;gap:.5rem;color:var(--t);text-decoration:none;min-height:44px}
+.wordmark{font:800 21px/1 Archivo,"Arial Narrow",system-ui,sans-serif;font-stretch:112%;letter-spacing:-.035em}
+.wordmark i{position:relative;display:inline-block;font-style:normal}
+.wordmark i:after{content:"";position:absolute;left:.06em;bottom:.77em;width:.115em;height:.19em;background:var(--a);transform:skewX(-32deg);transform-origin:bottom left}
+.sub{font:12px ui-monospace,Consolas,monospace;color:var(--g)}
+main{margin:auto;padding:3rem 1.5rem;display:grid;justify-items:start;align-content:start;gap:1.25rem}
+main>*{max-width:min(42rem,100%)}
+@media(min-width:640px){header{padding-inline:2.25rem}main{padding-inline:2.5rem}}
+h1{margin:0;font:800 clamp(2.25rem,7vw,3rem)/1.08 Archivo,"Arial Narrow",system-ui,sans-serif;font-stretch:108%;letter-spacing:-.025em;text-wrap:balance;outline:none}
+mark{background:var(--m);color:inherit;padding:0 .25rem;margin:0 -.25rem;border-radius:2px;-webkit-box-decoration-break:clone;box-decoration-break:clone}
+p.text{text-wrap:pretty;margin:0;max-width:65ch;font-size:1.125rem;color:var(--g)}
+.actions{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem 1.25rem;padding-top:.25rem}
+.btn{display:inline-flex;align-items:center;min-height:44px;padding:0 1.25rem;border:0;border-radius:3px;background:var(--c);color:var(--s);font:700 1rem "Atkinson Hyperlegible Next","Segoe UI",system-ui,sans-serif;text-decoration:none;cursor:pointer}
+.link{min-height:44px;padding:0 .25rem;border:0;background:none;color:var(--c);font:700 1rem "Atkinson Hyperlegible Next","Segoe UI",system-ui,sans-serif;cursor:pointer}
+.link:hover{text-decoration:underline;text-underline-offset:4px}
+.btn:focus-visible,.link:focus-visible,.brand:focus-visible{outline:3px solid var(--t);outline-offset:2px}
+.code{display:flex;align-items:center;gap:.25rem;max-width:100%;margin-top:.5rem;padding:.125rem .25rem .125rem .75rem;border:1px dashed var(--l);border-radius:3px;font:12px ui-monospace,Consolas,monospace;color:var(--g)}
+.code code{min-width:0;padding:.375rem 0;overflow-wrap:anywhere}
+.code button{flex:none;min-height:44px;padding:0 .5rem;border:0;background:none;color:var(--c);font:700 12px "Atkinson Hyperlegible Next","Segoe UI",system-ui,sans-serif;cursor:pointer}
+.sr{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0)}
+`;
+const LOGO = `<svg width="26" height="26" viewBox="0 0 64 64" aria-hidden="true"><rect width="64" height="64" rx="16" fill="#2B4FE0"/><rect x="26" y="27" width="11" height="25" rx="2.5" fill="#fff"/><path d="M27.5 22 35.5 22 44.5 9.5 36.5 9.5Z" fill="#FFD43B" stroke="#FFD43B" stroke-width="1.5" stroke-linejoin="round"/></svg>`;
+export function errorPage(status, code, lang) {
+    const [title, text] = (TEXTS[code] ?? TEXTS.error)?.[lang] ?? ["", ""];
+    const ui = UI[lang];
+    const plain = title.replaceAll("*", "");
+    const marked = esc(title).replace(/\*([^*]+)\*/g, "<mark>$1</mark>");
+    return `<!doctype html>
+<html lang="${lang === "pt" ? "pt-BR" : "en"}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(plain)} · Explicaí Studio</title>
+<style>${CSS}</style>
+</head>
+<body>
+<header><a class="brand" href="/" aria-label="Explicaí Studio">${LOGO}<span class="wordmark" aria-hidden="true">explica<i>ı</i></span><span class="sub" aria-hidden="true">studio</span></a></header>
+<main role="alert">
+<h1 id="t" tabindex="-1">${marked}</h1>
+<p class="text">${esc(text)}</p>
+<div class="actions"><a class="btn" href="/">${esc(ui.home)}</a><button class="link" type="button" onclick="location.reload()">${esc(ui.reload)}</button></div>
+<div class="code"><code>HTTP ${status} ${esc(code)}</code><button type="button" id="c">${esc(ui.copy)}</button><span class="sr" role="status" id="s"></span></div>
+</main>
+<script>
+document.getElementById("t").focus();
+document.getElementById("c").onclick=function(){var b=this;navigator.clipboard&&navigator.clipboard.writeText("HTTP ${status} ${esc(code)}").then(function(){b.textContent=${JSON.stringify(ui.copied)};document.getElementById("s").textContent=${JSON.stringify(ui.copied)}})};
+</script>
+</body>
+</html>
+`;
+}
+//# sourceMappingURL=errorPage.js.map