v4: what the server and the client both state is declared once — several rules were written out in two or more files, some already drifting apart. A link's site name (its host without www.) was computed in five places, now shared/url.ts's siteHost; dumpFileVersion, which the frontend and the server had to keep equal by hand, is one function in shared/dump.ts; the Markdown flattening of the chat's reply previews and the digest's quotes is shared/markdown.ts's markdownToPlainText, so the digest also keeps an image's alt text; an attachment's URL and how to find one in a text are shared/attachment.ts, which the editor, Markdown and attachment-service read, its id pattern the new UUID_RE that the file and thumbnail routes check ids with. On the server, the Bandcamp, YouTube playlist and link preview caches use one TtlCache (api/lib/ttl-cache.ts) instead of three copies of the same expiry and eviction; the link previews' theme-color and the emails' theme tokens read colours with one parser (api/lib/css-color.ts), and a transparent theme-color now gives no tint; the WebSocket route sends through ws-service's send, the welcome included, so it is type-checked; fetch.ts strips an IPv6 literal's brackets with public-address's bareHostname; and a category's slug is checked by the same validateSlug as a dump's, with its own length. The migrations keep their frozen copies, as they document. 272 backend tests and 677 frontend tests pass, and deno check, tsc, eslint and doc:lint are clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

api/lib/ttl-cache.ts

@@ -0,0 +1,60 @@
+/**
+ * Keeps what the server fetched from another site for a while, by key, so a
+ * page or a feed asking again doesn't refetch it: Bandcamp tracklists, YouTube
+ * playlists, and link previews. Each holder sets how long an entry lives and
+ * how many are kept; past that count, the oldest written goes first.
+ *
+ * @module
+ */
+
+/**
+ * A map whose entries expire `ttlMs` after they are written, holding
+ * `maxEntries` at most.
+ *
+ * @example
+ * const playlists = new TtlCache<YouTubePlaylist>(6 * 3_600_000, 200);
+ * const hit = playlists.get(listId) ?? playlists.set(listId, await fetch());
+ */
+export class TtlCache<V> {
+  #entries = new Map<string, { value: V; at: number }>();
+
+  constructor(readonly ttlMs: number, readonly maxEntries: number) {}
+
+  /** Returns the value under `key` unless it is missing or expired. */
+  get(key: string): V | undefined {
+    const hit = this.#entries.get(key);
+    if (!hit) return undefined;
+    if (Date.now() - hit.at >= this.ttlMs) {
+      this.#entries.delete(key);
+      return undefined;
+    }
+    return hit.value;
+  }
+
+  /** Stores `value` under `key` from now on, and returns it. */
+  set(key: string, value: V): V {
+    this.#entries.delete(key);
+    // A Map keeps insertion order, so the first key is the oldest write.
+    if (this.#entries.size >= this.maxEntries) {
+      const oldest = this.#entries.keys().next().value;
+      if (oldest !== undefined) this.#entries.delete(oldest);
+    }
+    this.#entries.set(key, { value, at: Date.now() });
+    return value;
+  }
+
+  /**
+   * Removes `key`, or only when `value` is still what it holds, so a late
+   * failure can't remove the entry that replaced its own.
+   */
+  delete(key: string, value?: V): void {
+    if (value === undefined || this.#entries.get(key)?.value === value) {
+      this.#entries.delete(key);
+    }
+  }
+
+  /** Empties the cache, for the tests' reset between cases. */
+  clear(): void {
+    this.#entries.clear();
+  }
+}