@geekity/cms 0.3.0 → 0.5.0

package/dist/files/atomic.js

@@ -0,0 +1,150 @@
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+/** Every path with a write queued, keyed by its resolved absolute path. */
+const queues = new Map();
+/**
+ * Write a file atomically, behind whatever is already being written to it.
+ *
+ * The directory it lives in is created if it is missing, so a caller writing
+ * the first file under `data/keys` or `content/_data` does not have to.
+ */
+export function writeFileAtomically(file, contents, options = {}) {
+    return enqueue(file, () => write(file, contents, options));
+}
+/**
+ * Read a file, decide what it should say next, and write it — all three as one
+ * step nothing else writing that file can get between.
+ *
+ * The read-modify-write is the shape almost every file in this CMS is changed
+ * by: `site.json` keeps the keys the settings form does not manage,
+ * `followers.json` gains or loses one entry, a month's inbox log gains a line.
+ * A queue around the write alone would not be enough for any of them, because
+ * two writers could both read the old file first.
+ */
+export function updateFileAtomically(file, produce, options = {}) {
+    return withFileLock(file, async () => {
+        let current;
+        try {
+            current = await readFile(file, 'utf8');
+        }
+        catch {
+            current = undefined;
+        }
+        await write(file, await produce(current), options);
+    });
+}
+/**
+ * Run a task with one path's queue to itself, and hand back what it returned.
+ *
+ * The queue {@link updateFileAtomically} keeps around a read and a write, for
+ * a caller whose step is more than those two. The one that needs it is a file
+ * that SQLite indexes: a follower arriving has to reach `followers.json` and
+ * the `followers` table, and if the second of those were a step after the lock
+ * rather than inside it, a follow and an unfollow racing could leave the index
+ * saying something the file does not — and the file is the truth, so the index
+ * would be wrong until the next boot rebuilt it.
+ *
+ * The task is not handed a writer, because the writer it wants is the one that
+ * does not queue: {@link readFileIfPresentSync} and
+ * {@link writeFileAtomicallySync} inside the lock are the whole pattern.
+ * Calling {@link writeFileAtomically} or {@link updateFileAtomically} on the
+ * same path from inside a task would wait for a queue the task is itself at
+ * the head of, and never return.
+ */
+export function withFileLock(file, task) {
+    return enqueue(file, async () => await task());
+}
+/**
+ * The same write for a caller that cannot await: boot.
+ *
+ * `createCms` is synchronous — a site calls it and reads `cms.app` — so the
+ * once-only migrations that turn an old database's rows into files have no
+ * `await` to spend. They run before the server is listening and before
+ * anything else has written a file, so stepping outside the queue costs
+ * nothing; the rename still makes the write atomic against a reader.
+ */
+export function writeFileAtomicallySync(file, contents, options = {}) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = temporaryName(file);
+    try {
+        writeFileSync(temporary, contents, options.mode === undefined ? {} : { mode: options.mode });
+        renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            // It was never created, or the rename already moved it away.
+        }
+        throw error;
+    }
+}
+/**
+ * Read a file's whole contents as text, or `undefined` when it is not there.
+ *
+ * The counterpart of the writes above, for the same reason they exist: a file
+ * that is the source of truth is read on the way to being written, and a
+ * missing one means "nothing stored yet" everywhere in this CMS rather than an
+ * error to handle at each call site.
+ */
+export function readFileIfPresentSync(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Run a task once every task already queued for this path has finished. */
+function enqueue(file, task) {
+    const key = path.resolve(file);
+    const queue = queues.get(key) ?? { last: Promise.resolve(), waiting: 0 };
+    queue.waiting += 1;
+    queues.set(key, queue);
+    // The chain is of settled promises: a task that throws still lets the next
+    // one run, and its rejection reaches only the caller that queued it.
+    const next = queue.last.then(task, task);
+    queue.last = next.catch(() => undefined);
+    return next.finally(() => {
+        // The last one out turns the light off, so a process that has been running
+        // for a year does not hold an entry per file it has ever written.
+        queue.waiting -= 1;
+        if (queue.waiting === 0 && queues.get(key) === queue)
+            queues.delete(key);
+    });
+}
+/** The write itself: a temporary sibling, then a rename over the target. */
+async function write(file, contents, options) {
+    await mkdir(path.dirname(file), { recursive: true });
+    const temporary = temporaryName(file);
+    try {
+        await writeFile(temporary, contents, options.mode === undefined ? {} : { mode: options.mode });
+        await rename(temporary, file);
+    }
+    catch (error) {
+        try {
+            await unlink(temporary);
+        }
+        catch {
+            // It was never created, or the rename already moved it away.
+        }
+        throw error;
+    }
+}
+/** How many temporary names this process has minted. */
+let sequence = 0;
+/**
+ * A temporary name beside the file, unique to this write.
+ *
+ * Beside it rather than in the system temporary directory because `rename(2)`
+ * is only atomic within one filesystem. The process id keeps two processes on
+ * one site apart and the counter keeps two writes in one process apart, so a
+ * failed write's leftovers can never be mistaken for another's.
+ */
+function temporaryName(file) {
+    sequence += 1;
+    return `${file}.${process.pid.toString(36)}-${sequence.toString(36)}.tmp`;
+}
+//# sourceMappingURL=atomic.js.map

package/dist/files/atomic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../../src/files/atomic.ts"],"names":[],"mappings":"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"}

package/dist/files/index.d.ts

@@ -0,0 +1,3 @@
+export { readFileIfPresentSync, updateFileAtomically, withFileLock, writeFileAtomically, writeFileAtomicallySync, } from './atomic.ts';
+export type { FileContents, ProduceFileContents, WriteFileAtomicallyOptions } from './atomic.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/files/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/files/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC"}

package/dist/files/index.js

@@ -0,0 +1,2 @@
+export { readFileIfPresentSync, updateFileAtomically, withFileLock, writeFileAtomically, writeFileAtomicallySync, } from './atomic.js';
+//# sourceMappingURL=index.js.map

package/dist/files/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/files/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/dist/forms/protection.d.ts

@@ -0,0 +1,85 @@
+/**
+ * What every form on the public site defends itself with.
+ *
+ * A comment form (TASK-50) and a contact form (TASK-56) are the same problem
+ * wearing different fields: an anonymous stranger posting text at a site that
+ * has to store it. So the three cheap defences in front of both live here
+ * rather than once each, and neither feature can quietly drift into a weaker
+ * version of the other's rules.
+ *
+ * 1. **The honeypot.** A field no person can see and no person fills in. A
+ *    submission that filled it is dropped without a word, because telling a bot
+ *    why it failed is telling it how to succeed.
+ * 2. **The age of the form.** Something submitted a heartbeat after the page
+ *    loaded was not typed, and something submitted from a form rendered last
+ *    year is a replayed body. This is a speed bump rather than a control — the
+ *    field is not signed, so anything that can read the form can forge it — and
+ *    it is here because the naive half of the traffic does not bother.
+ * 3. **The address hash.** Not a defence in itself but what makes one
+ *    reviewable: a salted hash of where a submission came from, so a run from
+ *    one machine is visible without a reader's home address being written down.
+ *
+ * The fourth, the per-address rate limit, is `createLoginThrottle` in
+ * `admin/throttle.ts`, because it is the same limiter the login form uses and
+ * it belongs with the rest of that machinery.
+ */
+/**
+ * The honeypot field, named as something a form-filling robot expects to find
+ * and a person never sees.
+ *
+ * The form hides it from sight and from assistive technology and carries
+ * `autocomplete="off"` on it, so a browser does not helpfully fill it in.
+ */
+export declare const FORM_TRAP_FIELD = "website";
+/** The hidden field carrying when the form was rendered, in epoch milliseconds. */
+export declare const FORM_LOADED_FIELD = "loaded";
+/** How long a form has to have been on screen before it may be submitted. */
+export declare const MINIMUM_SUBMIT_SECONDS = 3;
+/**
+ * How long a rendered form stays submittable.
+ *
+ * A day, so a page left open overnight still works, and a `loaded` from last
+ * year — which is what a replayed body looks like — does not.
+ */
+export declare const MAXIMUM_FORM_AGE_SECONDS: number;
+/** Whether the honeypot was filled in, which no person ever does. */
+export declare function trapped(value: string): boolean;
+/** How long ago the form was rendered, or `undefined` when it did not say. */
+export declare function formAgeSeconds(loaded: string, now: Date): number | undefined;
+/** What the clock says about a submission, when it says anything. */
+export type FormTimingRefusal = 
+/** Rendered too long ago to still be the form it claims to be. */
+'stale'
+/** Submitted faster than a person types. */
+ | 'too-quick';
+/**
+ * Whether the form's age refuses this submission, and why.
+ *
+ * Staleness is decided before speed, because a `loaded` nothing can read is
+ * a forged field rather than a fast typist.
+ */
+export declare function formTimingRefusal(loaded: string, now: Date): FormTimingRefusal | undefined;
+/**
+ * Where the salt that hides submitters' addresses lives, under `dataDir`.
+ *
+ * Named after comments because comments minted it first and a site that has
+ * one must go on using it: a new salt would make every hash already in a
+ * comment file incomparable with every hash written after it.
+ */
+export declare const ADDRESS_SALT_FILE = "comment-salt";
+/**
+ * A submitter's address as the hash a stored record keeps, or `null` when the
+ * site could not tell where the request came from.
+ *
+ * Salted, and the salt is a file under `data/` rather than a constant, because
+ * an unsalted hash of an IPv4 address is the address: there are four billion
+ * of them and a laptop tries them all in seconds. The comment files are
+ * published with the site and go into git, so an address in one would be a
+ * reader's home written into a public repository.
+ *
+ * Losing the salt costs a site the ability to compare old hashes with new
+ * ones, and nothing else — which is why it lives beside the keys rather than
+ * in the content directory.
+ */
+export declare function hashClientAddress(dataDir: string, address: string | undefined): string | null;
+//# sourceMappingURL=protection.d.ts.map

package/dist/forms/protection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protection.d.ts","sourceRoot":"","sources":["../../src/forms/protection.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,YAAY,CAAC;AAEzC,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,WAAW,CAAC;AAE1C,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,QAAe,CAAC;AAErD,qEAAqE;AACrE,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAQ5E;AAED,qEAAqE;AACrE,MAAM,MAAM,iBAAiB;AAC3B,kEAAkE;AAChE,OAAO;AACT,4CAA4C;GAC1C,WAAW,CAAC;AAEhB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,iBAAiB,GAAG,SAAS,CAK1F;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAO7F"}

package/dist/forms/protection.js

@@ -0,0 +1,116 @@
+import { createHash, randomBytes } from 'node:crypto';
+import path from 'node:path';
+import { readFileIfPresentSync, writeFileAtomicallySync } from '../files/atomic.js';
+/**
+ * What every form on the public site defends itself with.
+ *
+ * A comment form (TASK-50) and a contact form (TASK-56) are the same problem
+ * wearing different fields: an anonymous stranger posting text at a site that
+ * has to store it. So the three cheap defences in front of both live here
+ * rather than once each, and neither feature can quietly drift into a weaker
+ * version of the other's rules.
+ *
+ * 1. **The honeypot.** A field no person can see and no person fills in. A
+ *    submission that filled it is dropped without a word, because telling a bot
+ *    why it failed is telling it how to succeed.
+ * 2. **The age of the form.** Something submitted a heartbeat after the page
+ *    loaded was not typed, and something submitted from a form rendered last
+ *    year is a replayed body. This is a speed bump rather than a control — the
+ *    field is not signed, so anything that can read the form can forge it — and
+ *    it is here because the naive half of the traffic does not bother.
+ * 3. **The address hash.** Not a defence in itself but what makes one
+ *    reviewable: a salted hash of where a submission came from, so a run from
+ *    one machine is visible without a reader's home address being written down.
+ *
+ * The fourth, the per-address rate limit, is `createLoginThrottle` in
+ * `admin/throttle.ts`, because it is the same limiter the login form uses and
+ * it belongs with the rest of that machinery.
+ */
+/**
+ * The honeypot field, named as something a form-filling robot expects to find
+ * and a person never sees.
+ *
+ * The form hides it from sight and from assistive technology and carries
+ * `autocomplete="off"` on it, so a browser does not helpfully fill it in.
+ */
+export const FORM_TRAP_FIELD = 'website';
+/** The hidden field carrying when the form was rendered, in epoch milliseconds. */
+export const FORM_LOADED_FIELD = 'loaded';
+/** How long a form has to have been on screen before it may be submitted. */
+export const MINIMUM_SUBMIT_SECONDS = 3;
+/**
+ * How long a rendered form stays submittable.
+ *
+ * A day, so a page left open overnight still works, and a `loaded` from last
+ * year — which is what a replayed body looks like — does not.
+ */
+export const MAXIMUM_FORM_AGE_SECONDS = 24 * 60 * 60;
+/** Whether the honeypot was filled in, which no person ever does. */
+export function trapped(value) {
+    return value.trim() !== '';
+}
+/** How long ago the form was rendered, or `undefined` when it did not say. */
+export function formAgeSeconds(loaded, now) {
+    const at = Number(loaded);
+    if (!Number.isFinite(at) || at <= 0)
+        return undefined;
+    const seconds = (now.getTime() - at) / 1000;
+    // A form stamped in the future is one somebody wrote by hand, or a clock
+    // that moved; either way it is not a form this site rendered a moment ago.
+    return seconds < 0 ? undefined : seconds;
+}
+/**
+ * Whether the form's age refuses this submission, and why.
+ *
+ * Staleness is decided before speed, because a `loaded` nothing can read is
+ * a forged field rather than a fast typist.
+ */
+export function formTimingRefusal(loaded, now) {
+    const age = formAgeSeconds(loaded, now);
+    if (age === undefined || age > MAXIMUM_FORM_AGE_SECONDS)
+        return 'stale';
+    if (age < MINIMUM_SUBMIT_SECONDS)
+        return 'too-quick';
+    return undefined;
+}
+/**
+ * Where the salt that hides submitters' addresses lives, under `dataDir`.
+ *
+ * Named after comments because comments minted it first and a site that has
+ * one must go on using it: a new salt would make every hash already in a
+ * comment file incomparable with every hash written after it.
+ */
+export const ADDRESS_SALT_FILE = 'comment-salt';
+/**
+ * A submitter's address as the hash a stored record keeps, or `null` when the
+ * site could not tell where the request came from.
+ *
+ * Salted, and the salt is a file under `data/` rather than a constant, because
+ * an unsalted hash of an IPv4 address is the address: there are four billion
+ * of them and a laptop tries them all in seconds. The comment files are
+ * published with the site and go into git, so an address in one would be a
+ * reader's home written into a public repository.
+ *
+ * Losing the salt costs a site the ability to compare old hashes with new
+ * ones, and nothing else — which is why it lives beside the keys rather than
+ * in the content directory.
+ */
+export function hashClientAddress(dataDir, address) {
+    if (address === undefined || address === '')
+        return null;
+    return createHash('sha256')
+        .update(`${addressSalt(dataDir)}:${address}`)
+        .digest('hex')
+        .slice(0, 32);
+}
+/** The site's address salt, minted on first use. */
+function addressSalt(dataDir) {
+    const file = path.join(dataDir, ADDRESS_SALT_FILE);
+    const held = readFileIfPresentSync(file)?.trim();
+    if (held !== undefined && held !== '')
+        return held;
+    const minted = randomBytes(32).toString('hex');
+    writeFileAtomicallySync(file, `${minted}\n`, { mode: 0o600 });
+    return minted;
+}
+//# sourceMappingURL=protection.js.map

package/dist/forms/protection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protection.js","sourceRoot":"","sources":["../../src/forms/protection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC;AAEzC,mFAAmF;AACnF,MAAM,CAAC,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAE1C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAErD,qEAAqE;AACrE,MAAM,UAAU,OAAO,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;AAC7B,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,GAAS;IACtD,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAEtD,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;IAC5C,yEAAyE;IACzE,2EAA2E;IAC3E,OAAO,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;AAC3C,CAAC;AASD;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc,EAAE,GAAS;IACzD,MAAM,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACxC,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,wBAAwB;QAAE,OAAO,OAAO,CAAC;IACxE,IAAI,GAAG,GAAG,sBAAsB;QAAE,OAAO,WAAW,CAAC;IACrD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe,EAAE,OAA2B;IAC5E,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAEzD,OAAO,UAAU,CAAC,QAAQ,CAAC;SACxB,MAAM,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,OAAO,EAAE,CAAC;SAC5C,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAClB,CAAC;AAED,oDAAoD;AACpD,SAAS,WAAW,CAAC,OAAe;IAClC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IACjD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAEnD,MAAM,MAAM,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/C,uBAAuB,CAAC,IAAI,EAAE,GAAG,MAAM,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9D,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/images/icons.d.ts

@@ -0,0 +1,59 @@
+import type { ImageConfig } from './paths.ts';
+/**
+ * The site's icons: the two favicons and the touch icon, derived from the
+ * site's avatar.
+ *
+ * They are derived copies of an upload like every other file under
+ * {@link VARIANT_ASSET_PREFIX} — rebuildable, disposable, never read by a feed
+ * or a remote instance — but they are not `srcset` candidates, and they are
+ * shaped differently on purpose. A responsive variant is a width and whatever
+ * height the picture has; an icon is a square, because that is what
+ * `<link rel="icon" sizes="32x32">` promises and what a browser draws in a
+ * tab. So an icon is cropped to the middle of the avatar rather than scaled to
+ * a width, is always a PNG whatever the site's formats are, and is named
+ * `icon-32.png` rather than `32.png` so it can never be confused with the
+ * width of that number.
+ *
+ * Nothing is derived until somebody asks: the head links three URLs, and the
+ * first browser to follow one encodes it. That keeps the three sizes out of
+ * every upload's variant set, where they would turn up in a `srcset` as
+ * candidates nobody wants.
+ */
+/** One icon as the head links it. */
+export interface SiteIcon {
+    /** `icon` or `apple-touch-icon`. */
+    rel: string;
+    /** The `sizes` attribute, `32x32`. */
+    sizes: string;
+    /** Where the derived file is served, as a site-root path. */
+    href: string;
+}
+/** The name one size is derived under. */
+export declare function iconFileName(size: number): string;
+/**
+ * The size a derived filename names, or `undefined` when it names no icon this
+ * site offers.
+ *
+ * The check the request path goes through, so the URL space cannot be used to
+ * make the server encode arbitrary sizes — the rule the widths already follow.
+ */
+export declare function iconSize(file: string): number | undefined;
+/**
+ * The icons of a site whose avatar is this upload, or none at all.
+ *
+ * None when the site has no avatar, when the avatar is not one of its own
+ * uploads, when it is a file no icon can be made of, or when image
+ * optimization is off — because the head must never link a file this server
+ * would answer 404 for.
+ */
+export declare function siteIcons(config: ImageConfig, avatar: string | undefined): SiteIcon[];
+/**
+ * Derive one icon, or answer `false` having written nothing.
+ *
+ * Enlarging is allowed, unlike a width variant: 180 pixels is what the touch
+ * icon has to be, and a site whose avatar is smaller than that is better
+ * served a soft icon than none. The crop is the middle of the picture, which
+ * is where a face is.
+ */
+export declare function deriveSiteIcon(config: ImageConfig, source: string, size: number): Promise<boolean>;
+//# sourceMappingURL=icons.d.ts.map

package/dist/images/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../../src/images/icons.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qCAAqC;AACrC,MAAM,WAAW,QAAQ;IACvB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAwCD,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,EAAE,CAWrF;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAuBlB"}

package/dist/images/icons.js

@@ -0,0 +1,131 @@
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import { writeFileAtomically } from '../files/atomic.js';
+import { UPLOAD_ASSET_PREFIX } from '../web/assets.js';
+import { derivedDir, sourceFile, VARIANT_ASSET_PREFIX } from './paths.js';
+/**
+ * The icons a site offers, in the order the head lists them: the 32 and 16
+ * pixel favicons and the 180 pixel touch icon Apple asks for.
+ *
+ * Three is the whole set. A site that wants a web manifest, a mask icon or a
+ * tile colour writes them into its own theme's `head` block; the package links
+ * what every browser reads and nothing that needs a second file to explain it.
+ */
+const ICONS = [
+    { rel: 'icon', size: 32 },
+    { rel: 'icon', size: 16 },
+    { rel: 'apple-touch-icon', size: 180 },
+];
+/** What a derived icon is called inside its source's directory. */
+const ICON_FILE = /^icon-(\d{1,4})\.png$/;
+/**
+ * The extensions an icon may be derived from.
+ *
+ * Wider than the responsive variants' set — an SVG has no pixels to resize but
+ * rasterises to a square perfectly well, and only the first frame of a GIF was
+ * ever going to be a favicon — and narrower than "anything sharp might open",
+ * so a site whose avatar setting points at a PDF links no icons rather than
+ * three that 404.
+ */
+const ICON_SOURCES = new Set([
+    '.avif',
+    '.gif',
+    '.jpeg',
+    '.jpg',
+    '.png',
+    '.svg',
+    '.tif',
+    '.tiff',
+    '.webp',
+]);
+/** The name one size is derived under. */
+export function iconFileName(size) {
+    return `icon-${String(size)}.png`;
+}
+/**
+ * The size a derived filename names, or `undefined` when it names no icon this
+ * site offers.
+ *
+ * The check the request path goes through, so the URL space cannot be used to
+ * make the server encode arbitrary sizes — the rule the widths already follow.
+ */
+export function iconSize(file) {
+    const size = Number(ICON_FILE.exec(file)?.[1] ?? NaN);
+    return ICONS.some((icon) => icon.size === size) ? size : undefined;
+}
+/**
+ * The icons of a site whose avatar is this upload, or none at all.
+ *
+ * None when the site has no avatar, when the avatar is not one of its own
+ * uploads, when it is a file no icon can be made of, or when image
+ * optimization is off — because the head must never link a file this server
+ * would answer 404 for.
+ */
+export function siteIcons(config, avatar) {
+    if (!config.imageOptimization)
+        return [];
+    const source = iconSource(avatar);
+    if (source === undefined)
+        return [];
+    return ICONS.map(({ rel, size }) => ({
+        rel,
+        sizes: `${String(size)}x${String(size)}`,
+        href: iconHref(source, size),
+    }));
+}
+/**
+ * Derive one icon, or answer `false` having written nothing.
+ *
+ * Enlarging is allowed, unlike a width variant: 180 pixels is what the touch
+ * icon has to be, and a site whose avatar is smaller than that is better
+ * served a soft icon than none. The crop is the middle of the picture, which
+ * is where a face is.
+ */
+export async function deriveSiteIcon(config, source, size) {
+    const file = sourceFile(config, source);
+    if (file === undefined || !ICON_SOURCES.has(path.extname(source).toLowerCase()))
+        return false;
+    const directory = derivedDir(config, source);
+    try {
+        // `autoOrient` applies the EXIF rotation, and sharp keeps no metadata
+        // unless asked, so the icon comes out the right way up carrying no camera
+        // and no location.
+        const encoded = await sharp(file, { autoOrient: true })
+            .resize({ width: size, height: size, fit: 'cover', position: 'centre' })
+            .png({ compressionLevel: 9 })
+            .toBuffer();
+        await mkdir(directory, { recursive: true });
+        await writeFileAtomically(path.join(directory, iconFileName(size)), encoded);
+        return true;
+    }
+    catch {
+        // An avatar sharp cannot read is a site with no icons, not a failed
+        // request: the handler answers 404 and the page it came from is fine.
+        return false;
+    }
+}
+/** The upload an avatar setting names, or `undefined` when it names none. */
+function iconSource(avatar) {
+    if (avatar === undefined || !avatar.startsWith(UPLOAD_ASSET_PREFIX))
+        return undefined;
+    const relative = avatar.slice(UPLOAD_ASSET_PREFIX.length);
+    if (relative === '' || relative.includes('..'))
+        return undefined;
+    if (!ICON_SOURCES.has(path.extname(relative).toLowerCase()))
+        return undefined;
+    // The setting holds a URL and the lookup wants a path, so whatever the
+    // upload endpoint encoded comes off again here.
+    try {
+        return relative.split('/').map(decodeURIComponent).join('/');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Where one size of one upload's icon is served. */
+function iconHref(source, size) {
+    const segments = [...source.split('/'), iconFileName(size)].map((segment) => encodeURIComponent(segment));
+    return `${VARIANT_ASSET_PREFIX}${segments.join('/')}`;
+}
+//# sourceMappingURL=icons.js.map

package/dist/images/icons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.js","sourceRoot":"","sources":["../../src/images/icons.ts"],"names":[],"mappings":"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"}

package/dist/images/index.d.ts

@@ -0,0 +1,7 @@
+export { IMAGE_SIZES, responsiveImages, siteImageMarkup } from './markup.ts';
+export type { DescribeImage } from './markup.ts';
+export { siteIcons } from './icons.ts';
+export type { SiteIcon } from './icons.ts';
+export { describeImage, findImageVariant, generateImageVariants, imageMediaType, removeImageVariants, variantUrl, IMAGE_DIRECTORY, IMAGE_RECORD_NAME, VARIANT_ASSET_PREFIX, } from './variants.ts';
+export type { ImageConfig, ImageRecord, ImageVariant } from './variants.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/images/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/images/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7E,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/images/index.js

@@ -0,0 +1,4 @@
+export { IMAGE_SIZES, responsiveImages, siteImageMarkup } from './markup.js';
+export { siteIcons } from './icons.js';
+export { describeImage, findImageVariant, generateImageVariants, imageMediaType, removeImageVariants, variantUrl, IMAGE_DIRECTORY, IMAGE_RECORD_NAME, VARIANT_ASSET_PREFIX, } from './variants.js';
+//# sourceMappingURL=index.js.map

package/dist/images/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/images/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,eAAe,CAAC"}