Something went wrong. Try again.
Browser extension: detect and subscribe to standard.site publications on ATProto
Something went wrong. Try again.
11 kB · 280 lines
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281/** * What standard.site and feed readers read out of the built site, pinned at * the seams where two files have to agree without anything connecting them: * * - sequoia computes a record's address as siteUrl + pathPrefix + "/" + slug * from sequoia.json; Astro computes the canonical from its own `site`. * If either moves, records point at pages that are not there — and because * records are keyed by path, the next publish writes a second record * beside the stale one instead of correcting it. * - A post links its document record only once it has one: an href with * nothing behind it is a claim a verifier follows. * - Every page links the publication, and says what sequoia.json says: the * tag and the well-known are one value, read from one file. * - The well-known publication key, once it exists, must say what * sequoia.json says, or the publication cannot be verified. * - The atom feed and the built pages must agree about what was posted. * - CloudFront serves one built object for every address the site does not * have, and infra/main.tf names it by S3 key. * * Run with `npm --prefix web test`. */import { test, after } from "node:test";import assert from "node:assert/strict";import { execFileSync } from "node:child_process";import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";import { join } from "node:path";import { fileURLToPath } from "node:url";
const web = fileURLToPath(new URL("../", import.meta.url));const POSTS = join(web, "src/content/posts");const WELL_KNOWN = join(web, "public/.well-known/site.standard.publication");
const sequoia = JSON.parse(readFileSync(join(web, "sequoia.json"), "utf8"));const astro = (await import("../astro.config.mjs")).default;
// Nothing resolvable. A DID that looked real would be followed by the first// person who copied it out of here.const DOCUMENT = "at://did:plc:example/site.standard.document/fakerkey";
// Fixtures written for the build and taken away again: one published post// (the tree may not have one on any given day; the & pins feed escaping),// one draft that must not build. Under web/.astro, which is gitignored and// already the build's scratch.const fixture = join(POSTS, "fixture-mumpsimus.md");const draftFixture = join(POSTS, "fixture-widdershins-draft.md");const outDir = join(web, ".astro/standard-site");
writeFileSync( fixture, `---title: Fixture mumpsimus & sonsdescription: Fixture for the standard.site tests. Removed when they finish.publishDate: 2026-01-01atUri: ${DOCUMENT}---
Borborygmus quincunx widdershins.`,);writeFileSync( draftFixture, `---title: Fixture draftdescription: Must not appear in a build.publishDate: 2026-01-02draft: true---
Not yet.`,);
// Which posts claim a record, read while the fixtures are on disk. Slugs are// filenames, which is what Astro's glob loader makes ids from. Sequoia// writes the value quoted, so the quotes come off.const published = new Map( readdirSync(POSTS) .filter((file) => file.endsWith(".md")) .map((file) => [ file.replace(/\.md$/, ""), /^atUri:\s*["']?(at:\/\/\S+?)["']?\s*$/m.exec( readFileSync(join(POSTS, file), "utf8"), )?.[1], ]),);
try { execFileSync( join(web, "node_modules/.bin/astro"), ["build", "--outDir", outDir], { cwd: web, stdio: "pipe" }, );} finally { rmSync(fixture, { force: true }); rmSync(draftFixture, { force: true });}
after(() => rmSync(outDir, { recursive: true, force: true }));
test("sequoia.json and astro.config.mjs agree on the site", () => { assert.equal(sequoia.siteUrl, astro.site); // A trailing slash would make Astro's canonical /posts/x/ while the // record still claims /posts/x, and the two would stop being the same // address. assert.equal(astro.trailingSlash, "never"); assert.equal(sequoia.pathPrefix, "/posts");});
test("every built post is canonical at the address its record claims, and links the record only if it has one", () => { const built = readdirSync(join(outDir, "posts"), { withFileTypes: true }) .filter((entry) => entry.isDirectory()) .map((entry) => entry.name); assert.ok(built.length > 1, "the fixture and at least one post should build");
for (const slug of built) { const html = readFileSync(join(outDir, "posts", slug, "index.html"), "utf8"); const claimed = `${sequoia.siteUrl}${sequoia.pathPrefix}/${slug}`; assert.ok( html.includes(`rel="canonical" href="${claimed}"`), `${slug} is not canonical at ${claimed}`, );
const atUri = published.get(slug); if (atUri) { assert.match( html, new RegExp(`<link rel="site\\.standard\\.document" href="${atUri}"`), `${slug} has an atUri and did not link to it`, ); } else { assert.ok( !html.includes("site.standard.document"), `${slug} has no atUri and rendered a document link`, ); } }});
test("drafts are not built", () => { assert.ok(!existsSync(join(outDir, "posts/fixture-widdershins-draft")));});
test("the atom feed lists exactly the built posts, escaped and absolute", () => { const feed = readFileSync(join(outDir, "atom.xml"), "utf8"); const built = readdirSync(join(outDir, "posts"), { withFileTypes: true }) .filter((entry) => entry.isDirectory()) .map((entry) => entry.name);
const ids = [...feed.matchAll(/<id>([^<]+)<\/id>/g)] .map((m) => m[1]) .filter((id) => id.includes("/posts/")); assert.deepEqual( ids.sort(), built.map((slug) => `${sequoia.siteUrl}/posts/${slug}`).sort(), );
// The fixture's & must arrive as &, or the document ends at that byte // for every reader at once. assert.ok(feed.includes("Fixture mumpsimus & sons")); assert.ok(!/& /.test(feed), "a bare ampersand survived into the feed");});
test("the homepage previews the updates feed", () => { const html = readFileSync(join(outDir, "index.html"), "utf8"); assert.ok(html.includes('href="/posts"'), "no link to the backlog"); assert.ok(html.includes('href="/atom.xml"'), "no link to the feed");});
test("the homepage gallery ships every screenshot it renders", () => { // The manifest is generated (scripts/sync-shots.mjs) and the page is // hand-written, so the two can drift: an entry with no file on disk is a // broken image on the frontpage, and a file the page never names is dead // weight in the release tree. const html = readFileSync(join(outDir, "index.html"), "utf8"); const shots = JSON.parse(readFileSync(join(web, "src/shots.json"), "utf8")); assert.ok(shots.length > 0, "no screenshots to show");
for (const shot of shots) { assert.ok(existsSync(join(outDir, "shots", `${shot.name}.png`)), `${shot.src} did not build`); assert.match( html, new RegExp(`<img src="${shot.src}" width="${shot.width}" height="${shot.height}"`), `${shot.src} is not on the homepage at its own size`, ); assert.ok(html.includes(shot.alt.slice(0, 40)), `${shot.src} rendered without its alt text`); } assert.deepEqual( readdirSync(join(outDir, "shots")).sort(), shots.map((shot) => `${shot.name}.png`).sort(), );});
test("both origin error codes serve a 404 document the build actually emits", () => { // The bucket is private behind an origin access control, so S3 answers an // address the site does not have with 403, not 404; infra/main.tf maps both // to one built object and rewrites the status to 404. Nothing connects that // path to the build: Astro special-cases the status-code pages, so 404.astro // is the one page that is not a directory, and a change to build.format or a // renamed page would leave CloudFront fetching a key that is not there — // back to raw AccessDenied XML for every stale link. const tf = readFileSync(join(web, "../infra/main.tf"), "utf8"); const mapped = new Map( [...tf.matchAll(/custom_error_response\s*{([^}]*)}/g)].map(([, block]) => [ Number(/\berror_code\s*=\s*(\d+)/.exec(block)?.[1]), { page: /\bresponse_page_path\s*=\s*"([^"]+)"/.exec(block)?.[1], status: Number(/\bresponse_code\s*=\s*(\d+)/.exec(block)?.[1]), }, ]), );
assert.deepEqual( [...mapped.keys()].sort(), [403, 404], "infra/main.tf must map both the 403 S3 gives a missing key and a real 404", ); for (const [code, { page, status }] of mapped) { assert.equal(status, 404, `${code} from the origin is not answered as 404`); assert.ok( existsSync(join(outDir, page.replace(/^\//, ""))), `${page} is what CloudFront serves for ${code}, and the build does not emit it`, ); }});
test("the publication key, once it exists, says what sequoia.json says", () => { // `sequoia init` writes this file and the URI in sequoia.json in the same // step, and nothing rewrites either afterwards. They drift when one is // edited by hand, and the symptom is a publication nobody can verify. if (!existsSync(WELL_KNOWN)) { assert.match( sequoia.publicationUri, /PLACEHOLDER/, "sequoia.json has a real publication but public/.well-known does not serve it", ); return; }
const body = readFileSync(WELL_KNOWN, "utf8").trim(); assert.match( body, /^at:\/\/did:\S+\/site\.standard\.publication\/\S+$/, "the key must be one AT-URI and nothing else", ); assert.equal(body, sequoia.publicationUri); assert.ok( existsSync(join(outDir, ".well-known/site.standard.publication")), "public/.well-known did not survive the build", );});
test("every page links the publication it belongs to", () => { // The well-known is what verifies a publication; the link tag is what a // reader that already has the page resolves without probing. Both come from // publicationUri in sequoia.json — the test above pins the well-known to it, // this pins the pages — so there is one value to keep right. Every page, not // just posts: a reader can arrive anywhere on the site. const pages = readdirSync(outDir, { recursive: true }).filter((entry) => entry.endsWith(".html"), ); assert.ok(pages.length > 3, "the build should emit more pages than this");
const placeholder = sequoia.publicationUri.includes("PLACEHOLDER"); for (const page of pages) { const html = readFileSync(join(outDir, page), "utf8"); const linked = [ ...html.matchAll(/<link rel="site\.standard\.publication" href="([^"]*)"/g), ].map((match) => match[1]);
if (placeholder) { assert.deepEqual(linked, [], `${page} links a publication that does not exist yet`); continue; } assert.deepEqual( linked, [sequoia.publicationUri], `${page} should link the publication exactly once`, ); }});