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/test/lib/ttl-cache.test.ts

@@ -0,0 +1,37 @@
+import { assertEquals } from "@std/assert";
+import { FakeTime } from "@std/testing/time";
+import { TtlCache } from "../../lib/ttl-cache.ts";
+
+Deno.test("TtlCache: an entry expires ttlMs after it is written", () => {
+  using time = new FakeTime();
+  const cache = new TtlCache<string>(1000, 10);
+  cache.set("a", "x");
+  time.tick(999);
+  assertEquals(cache.get("a"), "x");
+  time.tick(1);
+  assertEquals(cache.get("a"), undefined);
+});
+
+Deno.test("TtlCache: past maxEntries, the oldest write goes first", () => {
+  const cache = new TtlCache<number>(1000, 2);
+  cache.set("a", 1);
+  cache.set("b", 2);
+  // Rewriting "a" makes it the newest, so "b" is the oldest now.
+  cache.set("a", 3);
+  cache.set("c", 4);
+  assertEquals(cache.get("a"), 3);
+  assertEquals(cache.get("b"), undefined);
+  assertEquals(cache.get("c"), 4);
+});
+
+Deno.test("TtlCache: delete with a value spares a newer entry", () => {
+  const cache = new TtlCache<object>(1000, 10);
+  const first = {};
+  const second = {};
+  cache.set("k", first);
+  cache.set("k", second);
+  cache.delete("k", first);
+  assertEquals(cache.get("k"), second);
+  cache.delete("k", second);
+  assertEquals(cache.get("k"), undefined);
+});