@heyramzi/review 0.0.0-stage → 1.1.0

package/dist/node/server/brand.d.ts

@@ -0,0 +1,29 @@
+import type { ServerResponse } from "node:http";
+export type FontFile = {
+    weight: number;
+    file: string;
+};
+/** The part of a brand the theme reads. */
+export type BrandTheme = {
+    roles: {
+        dark: string;
+        gray: string;
+        light: string;
+        primary: string;
+    };
+    radius: number;
+    files: {
+        text: FontFile[];
+        title: FontFile[];
+    };
+};
+export declare const contrast: (a: string, b: string) => number;
+/**
+ * The studio's chrome in their brand: dark ground, light text, primary accent, their corner and
+ * two faces. Every value is held to a reading contrast; status colours stay fixed.
+ */
+export declare function brandTheme(brand: BrandTheme): string;
+/** The theme fields of `<brandDir>/brand.json`, or null when there's no brand yet. */
+export declare function readBrandTheme(brandDir: string): BrandTheme | null;
+/** Answers `/brand.css` and `/brand/fonts/<file>`; false for any other path. Read per request, so a brand edit shows on reload. */
+export declare function serveBrand(brandDir: string, pathname: string, response: ServerResponse): boolean;

package/dist/node/server/brand.js

@@ -0,0 +1,144 @@
+/**
+ * A person's brand as review tokens, served as /brand.css with its fonts, so Editor OS and
+ * Shorts OS draw the same page in the same brand.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+const rgb = (hex) => [1, 3, 5].map((i) => Number.parseInt(hex.slice(i, i + 2), 16));
+const toHex = (c) => `#${c
+    .map((v) => Math.round(Math.min(255, Math.max(0, v)))
+    .toString(16)
+    .padStart(2, "0"))
+    .join("")}`;
+/** WCAG relative luminance. */
+const luminance = (hex) => {
+    const [r, g, b] = rgb(hex).map((v) => {
+        const s = v / 255;
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+export const contrast = (a, b) => {
+    const [hi, lo] = [luminance(a), luminance(b)].toSorted((x, y) => y - x);
+    return (hi + 0.05) / (lo + 0.05);
+};
+/** `t` is how much of `to` goes into `from`. */
+const mix = (from, to, t) => {
+    const [r1, g1, b1] = rgb(from);
+    const [r2, g2, b2] = rgb(to);
+    return toHex([r1 + (r2 - r1) * t, g1 + (g2 - g1) * t, b1 + (b2 - b1) * t]);
+};
+/** Walks `color` toward `to` until it reads at `min` against `against`: a brand colour is kept as long as it can be read. */
+const reach = (color, to, against, min, from = color) => {
+    for (let t = 0; t <= 1.0001; t += 0.04) {
+        const c = mix(from, to, t);
+        if (contrast(c, against) >= min)
+            return c;
+    }
+    return to;
+};
+/** The text colour for a button filled with `fill`: the brand's own ink or ground when one reads at 4.5, else white or black, whichever reads better. */
+const onFill = (fill, candidates) => {
+    const ok = candidates.find((c) => contrast(c, fill) >= 4.5);
+    if (ok)
+        return ok;
+    return contrast("#ffffff", fill) >= contrast("#000000", fill) ? "#ffffff" : "#000000";
+};
+/**
+ * The studio's chrome in their brand: dark ground, light text, primary accent, their corner and
+ * two faces. Every value is held to a reading contrast; status colours stay fixed.
+ */
+export function brandTheme(brand) {
+    const { dark, gray, light, primary } = brand.roles;
+    const [darker, lighter] = luminance(dark) <= luminance(light) ? [dark, light] : [light, dark];
+    // One scheme per side of the theme switch: the darker role is the dark ground, the lighter one the light.
+    const scheme = (base, ink0) => {
+        const ground = luminance(base) < 0.5;
+        const ink = contrast(ink0, base) >= 7 ? ink0 : reach(ink0, ground ? "#ffffff" : "#000000", base, 7);
+        const dim = contrast(gray, base) >= 4.5 ? gray : reach(mix(base, ink, 0.7), ink, base, 4.5);
+        const faint = reach(mix(base, ink, 0.5), ink, base, 3);
+        const accent = reach(primary, ink, base, 3);
+        return [
+            `color-scheme:${ground ? "dark" : "light"}`,
+            `--ground:${base}`,
+            `--surface:${mix(base, ink, 0.05)}`,
+            `--raised:${mix(base, ink, 0.1)}`,
+            `--line-soft:${mix(base, ink, 0.12)}`,
+            `--line:${mix(base, ink, 0.18)}`,
+            `--text:${ink}`,
+            `--dim:${dim}`,
+            `--faint:${faint}`,
+            `--accent:${accent}`,
+            `--on-accent:${onFill(accent, [base, ink])}`,
+            `--accent-deep:${reach(primary, base, ink, 4.5)}`,
+        ];
+    };
+    const radius = Math.min(20, Math.max(0, Math.round(brand.radius)));
+    const face = (family, files) => files
+        .map((f) => `@font-face{font-family:"${family}";font-weight:${f.weight};font-display:swap;src:url(/brand/fonts/${encodeURIComponent(f.file)})}`)
+        .join("\n");
+    const text = brand.files.text;
+    const title = brand.files.title.length ? brand.files.title : text;
+    const fonts = [face("brand-chrome-text", text), face("brand-chrome-title", title)]
+        .filter(Boolean)
+        .join("\n");
+    const shared = [
+        `--radius:${radius}px`,
+        `--radius-sm:${Math.min(6, radius)}px`,
+        ...(text.length ? [`--sans:"brand-chrome-text","Satoshi",system-ui,sans-serif`] : []),
+        ...(title.length ? [`--display:"brand-chrome-title","Manrope",system-ui,sans-serif`] : []),
+    ];
+    return `\n/* The person's brand, drawn over the defaults above. */\n${fonts}\n:root{${[...scheme(darker, lighter), ...shared].join(";")}}\n:root[data-theme="light"]{${scheme(lighter, darker).join(";")}}\n`;
+}
+/** The theme fields of `<brandDir>/brand.json`, or null when there's no brand yet. */
+export function readBrandTheme(brandDir) {
+    const path = join(brandDir, "brand.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const h = JSON.parse(readFileSync(path, "utf8"));
+        if (!h.roles || !h.type)
+            return null;
+        return {
+            roles: h.roles,
+            radius: h.radius ?? 10,
+            files: { text: h.type.files ?? [], title: h.type.title?.files ?? [] },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Answers `/brand.css` and `/brand/fonts/<file>`; false for any other path. Read per request, so a brand edit shows on reload. */
+export function serveBrand(brandDir, pathname, response) {
+    if (pathname === "/brand.css") {
+        const brand = readBrandTheme(brandDir);
+        response.writeHead(200, {
+            "content-type": "text/css; charset=utf-8",
+            "cache-control": "no-cache",
+        });
+        response.end(brand ? brandTheme(brand) : "");
+        return true;
+    }
+    const font = pathname.match(/^\/brand\/fonts\/([^/]+)$/);
+    if (!font)
+        return false;
+    let name;
+    try {
+        name = decodeURIComponent(font[1] ?? "");
+    }
+    catch {
+        name = "";
+    }
+    const file = join(brandDir, "fonts", basename(name));
+    if (!name || name !== basename(name) || !existsSync(file)) {
+        response.writeHead(404).end("no such font");
+        return true;
+    }
+    response.writeHead(200, {
+        "content-type": `font/${file.split(".").pop()}`,
+        "cache-control": "no-store",
+    });
+    response.end(readFileSync(file));
+    return true;
+}

package/dist/node/server/errors.d.ts

@@ -0,0 +1,5 @@
+/** Throw from an adapter to answer with a status, e.g. 404 for a video that isn't there. */
+export declare class ReviewError extends Error {
+    readonly status: number;
+    constructor(message: string, status?: number);
+}

package/dist/node/server/errors.js

@@ -0,0 +1,9 @@
+/** Throw from an adapter to answer with a status, e.g. 404 for a video that isn't there. */
+export class ReviewError extends Error {
+    status;
+    constructor(message, status = 404) {
+        super(message);
+        this.name = "ReviewError";
+        this.status = status;
+    }
+}

package/dist/node/server/guards.d.ts

@@ -0,0 +1,6 @@
+import type { Frame, NoteTarget, ReviewAction } from "../core/types.js";
+export declare function isFrame(value: unknown): value is Frame;
+export declare function isNoteTarget(value: unknown): value is NoteTarget;
+export declare function isReviewAction(value: unknown): value is ReviewAction;
+/** The action a body holds, or null when it isn't one. */
+export declare const parseAction: (body: unknown) => ReviewAction | null;

package/dist/node/server/guards.js

@@ -0,0 +1,69 @@
+/** Hand-written type guards: the body of a POST is `unknown` until it passes one of these. */
+import { BEAT_STATES, NOTE_ACTS, isOneOf } from "../core/enums.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isText = (value, max = 4000) => typeof value === "string" && value.trim().length > 0 && value.length <= max;
+const isId = (value) => typeof value === "string" && value.length > 0 && value.length <= 200;
+const isUnit = (value) => typeof value === "number" && value >= 0 && value <= 1;
+const isSeconds = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+export function isFrame(value) {
+    if (!isRecord(value) || !isUnit(value.x) || !isUnit(value.y))
+        return false;
+    const hasW = value.w !== undefined;
+    const hasH = value.h !== undefined;
+    if (hasW !== hasH)
+        return false;
+    return !hasW || (isUnit(value.w) && isUnit(value.h));
+}
+const isAnchor = (value) => isRecord(value) && isId(value.source) && isSeconds(value.at);
+export function isNoteTarget(value) {
+    if (!isRecord(value))
+        return false;
+    switch (value.kind) {
+        case "video":
+            return true;
+        case "beat":
+            return isId(value.beat);
+        case "text":
+            return (isId(value.from) &&
+                isId(value.to) &&
+                typeof value.quote === "string" &&
+                value.quote.length <= 2000);
+        case "time":
+            return (isSeconds(value.at) &&
+                (value.span === undefined || isSeconds(value.span)) &&
+                (value.frame === undefined || isFrame(value.frame)) &&
+                (value.anchor === undefined || isAnchor(value.anchor)));
+        default:
+            return false;
+    }
+}
+export function isReviewAction(value) {
+    if (!isRecord(value))
+        return false;
+    switch (value.type) {
+        case "decide":
+            return (isId(value.beat) &&
+                isOneOf(BEAT_STATES, value.state) &&
+                (value.pick === undefined || isId(value.pick)));
+        case "music":
+            return isId(value.keep) || value.skip === true || value.more === true;
+        case "note":
+            return isNoteTarget(value.target) && isText(value.text);
+        case "note.act":
+            return isId(value.note) && isOneOf(NOTE_ACTS, value.act);
+        case "note.reply":
+            return isId(value.note) && isText(value.text);
+        case "speech":
+            return (isId(value.source) &&
+                isSeconds(value.start) &&
+                isSeconds(value.end) &&
+                value.end > value.start &&
+                isText(value.text, 2000));
+        case "refresh":
+            return true;
+        default:
+            return false;
+    }
+}
+/** The action a body holds, or null when it isn't one. */
+export const parseAction = (body) => isReviewAction(body) ? body : null;

package/dist/node/server/handler.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ReviewAdapter } from "../core/types.js";
+export type ReviewHandlerOptions = {
+    /** The URL prefix, e.g. "/review". */
+    base: string;
+    heartbeatMs?: number;
+    /** Largest POST body in bytes. */
+    maxBody?: number;
+};
+export type ReviewHandler = (request: IncomingMessage, response: ServerResponse) => boolean;
+/**
+ * Serves state, act, events, media and library. Returns false for any other path.
+ */
+export declare function createReviewHandler(adapter: ReviewAdapter, options: ReviewHandlerOptions): ReviewHandler;

package/dist/node/server/handler.js

@@ -0,0 +1,143 @@
+import { ReviewError } from "./errors.js";
+import { parseAction } from "./guards.js";
+import { broadcaster, json, readBody, serveRange } from "./http.js";
+const ID = /^[\w.-]{1,120}$/;
+const problem = (response, status, error) => json(response, status, { ok: false, error });
+function fail(response, error) {
+    if (error instanceof ReviewError)
+        return problem(response, error.status, error.message);
+    console.error("[review]", error);
+    problem(response, 500, "Couldn't read this video.");
+}
+/**
+ * Serves state, act, events, media and library. Returns false for any other path.
+ */
+export function createReviewHandler(adapter, options) {
+    const base = options.base.replace(/\/+$/, "");
+    const maxBody = options.maxBody ?? 256 * 1024;
+    const streams = new Map();
+    /** One watch and one reload per video, however many pages are open on it. */
+    function stream(id) {
+        const existing = streams.get(id);
+        if (existing)
+            return existing;
+        const cast = broadcaster(options.heartbeatMs);
+        let loading = false;
+        let dirty = false;
+        const push = async () => {
+            if (loading) {
+                dirty = true;
+                return;
+            }
+            loading = true;
+            try {
+                cast.send("model", await adapter.load(id));
+            }
+            catch (error) {
+                cast.send("problem", {
+                    error: error instanceof Error ? error.message : "Couldn't read the video.",
+                });
+            }
+            finally {
+                loading = false;
+                if (dirty) {
+                    dirty = false;
+                    void push();
+                }
+            }
+        };
+        const entry = { cast, unwatch: adapter.watch(id, () => void push()) };
+        streams.set(id, entry);
+        return entry;
+    }
+    async function events(request, response, id) {
+        let model;
+        try {
+            model = await adapter.load(id);
+        }
+        catch (error) {
+            return fail(response, error);
+        }
+        const entry = stream(id);
+        entry.cast.add(response, `event: model\ndata: ${JSON.stringify(model)}\n\n`);
+        request.on("close", () => {
+            if (entry.cast.count() > 0)
+                return;
+            entry.unwatch();
+            streams.delete(id);
+        });
+    }
+    async function act(request, response, id) {
+        if (!String(request.headers["content-type"] ?? "").includes("application/json")) {
+            return problem(response, 415, "Send JSON.");
+        }
+        const raw = await readBody(request, maxBody);
+        if (raw === null)
+            return problem(response, 413, "That note is too long.");
+        let body;
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            return problem(response, 400, "That isn't JSON.");
+        }
+        const action = parseAction(body);
+        if (!action)
+            return problem(response, 400, "That isn't an action this page knows.");
+        try {
+            const result = await adapter.act(id, action);
+            json(response, result.ok ? 200 : 422, result);
+        }
+        catch (error) {
+            fail(response, error);
+        }
+    }
+    return (request, response) => {
+        const url = new URL(request.url ?? "/", "http://review.local");
+        if (!url.pathname.startsWith(`${base}/`))
+            return false;
+        const [rawId = "", route = "", ...rest] = url.pathname.slice(base.length + 1).split("/");
+        let id;
+        try {
+            id = decodeURIComponent(rawId);
+        }
+        catch {
+            problem(response, 400, "Bad video id.");
+            return true;
+        }
+        if (!ID.test(id) || rest.length > 0) {
+            problem(response, 404, "Not a review route.");
+            return true;
+        }
+        const method = request.method ?? "GET";
+        const reading = method === "GET" || method === "HEAD";
+        if (route === "state" && reading) {
+            adapter.load(id).then((model) => json(response, 200, model), (error) => fail(response, error));
+        }
+        else if (route === "events" && method === "GET") {
+            void events(request, response, id);
+        }
+        else if (route === "media" && reading) {
+            const file = url.searchParams.get("file");
+            const path = file ? adapter.media(id, file) : null;
+            if (path)
+                serveRange(request, response, path);
+            else
+                problem(response, 404, "No such file.");
+        }
+        else if (route === "library" && reading) {
+            Promise.resolve(adapter.library?.(id) ?? []).then((shelves) => json(response, 200, shelves), (error) => fail(response, error));
+        }
+        else if (route === "act" && method === "POST") {
+            void act(request, response, id);
+        }
+        else if (["state", "events", "media", "act", "library"].includes(route)) {
+            response.setHeader("allow", route === "act" ? "POST" : "GET");
+            problem(response, 405, "Wrong method.");
+        }
+        else {
+            problem(response, 404, "Not a review route.");
+        }
+        return true;
+    };
+}

package/dist/node/server/http.d.ts

@@ -0,0 +1,33 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type Range = {
+    status: 200 | 206;
+    start: number;
+    end: number;
+    headers: Record<string, string>;
+};
+/**
+ * A video served whole can't seek. Returns null for a range the file can't satisfy (416).
+ */
+export declare function rangeHeaders(size: number, header: string | undefined): Range | null;
+export declare const contentTypeOf: (path: string) => string;
+/** Stream a file with range support. Answers 404 for a missing file and 416 for a bad range. */
+export declare function serveRange(request: IncomingMessage, response: ServerResponse, path: string, contentType?: string): void;
+/** `Events` names each event and the body it carries, so a host checks every send against its pages. */
+export type Broadcaster<Events extends object = Record<string, unknown>> = {
+    add(response: ServerResponse, first?: string): void;
+    send<Name extends keyof Events & string>(event: Name, data: Events[Name]): void;
+    count(): number;
+    /** End every open stream. */
+    close(): void;
+};
+/** A set of SSE clients with a heartbeat, so a proxy or a sleeping laptop notices a dead one. */
+export declare function broadcaster<Events extends object = Record<string, unknown>>(heartbeatMs?: number): Broadcaster<Events>;
+/**
+ * The request body, or null when it ran past `max` bytes. The rest is read and dropped, not cut
+ * off, so the 413 still reaches a client that is mid-upload.
+ */
+export declare function readBytes(request: IncomingMessage, max: number): Promise<Buffer | null>;
+/** The body as text, or null past `max` bytes. */
+export declare function readBody(request: IncomingMessage, max: number): Promise<string | null>;
+/** One JSON answer. `headers` replace the defaults of the same name, such as a route's own cache rule. */
+export declare function json(response: ServerResponse, status: number, body: unknown, headers?: Record<string, string>): void;

package/dist/node/server/http.js

@@ -0,0 +1,167 @@
+/**
+ * The plumbing every review server needs: ranged file reads, a set of server-sent-event clients,
+ * a capped body read and a JSON answer.
+ */
+import { createReadStream, statSync } from "node:fs";
+import { extname } from "node:path";
+/**
+ * A video served whole can't seek. Returns null for a range the file can't satisfy (416).
+ */
+export function rangeHeaders(size, header) {
+    const base = { "accept-ranges": "bytes" };
+    if (!header)
+        return {
+            status: 200,
+            start: 0,
+            end: size - 1,
+            headers: { ...base, "content-length": String(size) },
+        };
+    const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+    if (!match || size === 0)
+        return null;
+    const [, rawStart = "", rawEnd = ""] = match;
+    let start;
+    let end;
+    if (rawStart === "") {
+        // WHY: "bytes=-500" means the last 500 bytes.
+        const tail = Number(rawEnd);
+        if (!tail)
+            return null;
+        start = Math.max(size - tail, 0);
+        end = size - 1;
+    }
+    else {
+        start = Number(rawStart);
+        end = rawEnd === "" ? size - 1 : Math.min(Number(rawEnd), size - 1);
+    }
+    if (start > end || start >= size)
+        return null;
+    return {
+        status: 206,
+        start,
+        end,
+        headers: {
+            ...base,
+            "content-range": `bytes ${start}-${end}/${size}`,
+            "content-length": String(end - start + 1),
+        },
+    };
+}
+const TYPES = {
+    ".mp4": "video/mp4",
+    ".m4v": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".m4a": "audio/mp4",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+};
+export const contentTypeOf = (path) => TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+/** Stream a file with range support. Answers 404 for a missing file and 416 for a bad range. */
+export function serveRange(request, response, path, contentType = contentTypeOf(path)) {
+    let size;
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile())
+            throw new Error("not a file");
+        size = stat.size;
+    }
+    catch {
+        response.writeHead(404).end();
+        return;
+    }
+    const range = rangeHeaders(size, request.headers.range);
+    if (!range) {
+        response.writeHead(416, { "content-range": `bytes */${size}` }).end();
+        return;
+    }
+    response.writeHead(range.status, {
+        ...range.headers,
+        "content-type": contentType,
+        "cache-control": "no-cache",
+    });
+    if (request.method === "HEAD") {
+        response.end();
+        return;
+    }
+    const stream = createReadStream(path, { start: range.start, end: range.end });
+    stream.on("error", () => response.destroy());
+    response.on("close", () => stream.destroy());
+    stream.pipe(response);
+}
+/** A set of SSE clients with a heartbeat, so a proxy or a sleeping laptop notices a dead one. */
+export function broadcaster(heartbeatMs = 15_000) {
+    const clients = new Set();
+    let timer;
+    const stop = () => {
+        if (timer && clients.size === 0)
+            clearInterval(timer);
+        if (clients.size === 0)
+            timer = undefined;
+    };
+    return {
+        add(response, first) {
+            response.writeHead(200, {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache, no-transform",
+                connection: "keep-alive",
+                "x-accel-buffering": "no",
+            });
+            response.write(`retry: 2000\n${first ?? ""}\n`);
+            clients.add(response);
+            response.on("close", () => {
+                clients.delete(response);
+                stop();
+            });
+            timer ??= setInterval(() => {
+                for (const client of clients)
+                    client.write(": ping\n\n");
+            }, heartbeatMs).unref();
+        },
+        send(event, data) {
+            const line = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+            for (const client of clients)
+                client.write(line);
+        },
+        count: () => clients.size,
+        close() {
+            for (const client of clients)
+                client.end();
+            clients.clear();
+            stop();
+        },
+    };
+}
+/**
+ * The request body, or null when it ran past `max` bytes. The rest is read and dropped, not cut
+ * off, so the 413 still reaches a client that is mid-upload.
+ */
+export async function readBytes(request, max) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        size += buffer.length;
+        if (size <= max)
+            chunks.push(buffer);
+    }
+    return size > max ? null : Buffer.concat(chunks);
+}
+/** The body as text, or null past `max` bytes. */
+export async function readBody(request, max) {
+    return (await readBytes(request, max))?.toString("utf8") ?? null;
+}
+/** One JSON answer. `headers` replace the defaults of the same name, such as a route's own cache rule. */
+export function json(response, status, body, headers = {}) {
+    response.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+        ...headers,
+    });
+    response.end(JSON.stringify(body));
+}

package/dist/node/server/index.d.ts

@@ -0,0 +1,7 @@
+export { createReviewHandler, type ReviewHandler, type ReviewHandlerOptions, } from "./handler.js";
+export { ReviewError } from "./errors.js";
+export { isFrame, isNoteTarget, isReviewAction, parseAction } from "./guards.js";
+export { broadcaster, contentTypeOf, json, rangeHeaders, readBody, readBytes, serveRange, type Broadcaster, type Range, } from "./http.js";
+export { addNote, applyNoteAct, applyReply, nextId, replyTo, type NoteExtras, type NoteInput, type NotesResult, } from "./notes.js";
+export type * from "../core/types.js";
+export { brandTheme, contrast, readBrandTheme, serveBrand, type BrandTheme, type FontFile, } from "./brand.js";

package/dist/node/server/index.js

@@ -0,0 +1,6 @@
+export { createReviewHandler, } from "./handler.js";
+export { ReviewError } from "./errors.js";
+export { isFrame, isNoteTarget, isReviewAction, parseAction } from "./guards.js";
+export { broadcaster, contentTypeOf, json, rangeHeaders, readBody, readBytes, serveRange, } from "./http.js";
+export { addNote, applyNoteAct, applyReply, nextId, replyTo, } from "./notes.js";
+export { brandTheme, contrast, readBrandTheme, serveBrand, } from "./brand.js";

package/dist/node/server/notes.d.ts

@@ -0,0 +1,31 @@
+import type { Note, NoteAct, NoteTarget } from "../core/types.js";
+export type NotesResult = {
+    ok: true;
+    notes: Note[];
+} | {
+    ok: false;
+    error: string;
+};
+/** n1, n2, n3: short enough to say out loud. */
+export declare function nextId(notes: readonly Pick<Note, "id">[]): string;
+export type NoteInput = {
+    target: NoteTarget;
+    text: string;
+};
+export type NoteExtras = {
+    pass?: string;
+    by?: Note["by"];
+    now?: Date;
+    id?: string;
+    chat?: boolean;
+    reply?: string;
+};
+/** A new note at the end of the list. */
+export declare function addNote(notes: readonly Note[], input: NoteInput, extras?: NoteExtras): NotesResult & {
+    note?: Note;
+};
+/** Run one verb on one note, only from a status where it's legal. */
+export declare function applyNoteAct(notes: readonly Note[], id: string, act: NoteAct): NotesResult;
+/** Not happy with the answer: it joins the thread with the reply, and the note goes back to open. */
+export declare function replyTo(note: Note, text: string): Note;
+export declare function applyReply(notes: readonly Note[], id: string, text: string): NotesResult;