An atmospheric personal website. Every page is a record on the AT Protocol; the site is a view layer over those records.
- Vite + React SPA, plain CSS, no state library.
- AT Protocol as the database. Records live under
is.dame.*lexicons on the user's PDS; build-time JSON snapshots come fromapp.bsky.feed.getAuthorFeed,com.atproto.repo.listRecords, andapp.bsky.actor.getProfile. - Vercel for hosting. A 6-hour cron pings
/api/rebuild, which fires the Vercel deploy hook so new records publish without a manual redeploy.
Schema-only documentation lives under lexicons/:
-
is.dame.now— short status updates ("dame.is hiking"). -
is.dame.page— page-content records keyed by literal page name. -
is.dame.profile— extended long-form bio atat://{me}/is.dame.profile/self. Carries a photo gallery, a block body (the samepub.leaflet.contenteditor the blog uses, so images can sit inline), and flags choosing how much of the Bluesky profile card/themselfshows above it. -
is.dame.creating.work— portfolio works (art, software, writing, music…). -
is.dame.resume/is.dame.resume.job/is.dame.resume.education— a backlinked resume model: many resume versions curate shared job/education records and pick which highlight bullets to show. Seelexicons/RESUME.md; renders at/resume. Bulk-import from a LinkedIn/resume PDF withscripts/import-resume.mjs. -
is.dame.annotating— stretch lexicon for book-style margin notes. -
is.dame.mothing/is.dame.mothing.observation— a mirror of moth observations from iNaturalist, rendered at/mothing. The summary singleton lives atat://{me}/is.dame.mothing/self; one observation record per iNaturalist observation is keyed by its iNat id. No location data is ever mirrored — coordinates, place names, and timezone are stripped insrc/lib/inaturalist.js. Sync withscripts/mirror-inaturalist.mjs. Once mirrored, moth observations also appear in the home feed under themothingverb, ordered by observation date. -
is.dame.observing/is.dame.observing.observation— the same mirror for every non-moth iNaturalist observation (birds, plants, fungi, butterflies, other insects…), rendered in the home feed under theobservingverb. The same sync writes both: it pulls every observation once and splits each by taxonomy — moths (Lepidoptera minus butterflies) becomeis.dame.mothing.*records, everything elseis.dame.observing.*— so one iNaturalist log shows up as mothing if it's a moth and observing otherwise, with nothing dropped or double-counted. Same location-stripping guarantee. Theis.dame.observing/selfsummary doubles as the incremental mirror's freshness marker across all observations. -
is.dame.guestbook/is.dame.guestbook.entry— a decentralized guestbook, rendered at/guestbook. The book is a singleton on my PDS (at://{me}/is.dame.guestbook/self); each signature is anis.dame.guestbook.entryrecord on the visitor's own PDS whosesubjectbacklinks to the book. Reads are assembled live from Constellation backlinks hydrated through Slingshot; writes happen in the browser via atproto OAuth. Seelexicons/GUESTBOOK.md. Create the book once withscripts/create-guestbook.mjs. -
is.dame.experiment/is.dame.experiment.reaction— quick prototypes and concepts, posted for reactions and rendered at/experimenting. An experiment is a record on my PDS; each reaction is anis.dame.experiment.reactionrecord on the visitor's own PDS whosesubjectbacklinks to it, gathered the way the guestbook's signatures are. See Experimenting andlexicons/EXPERIMENTING.md. -
is.dame.sunfarming.result— a finished island of Sunfarming, posted by the player: how many days it took. On the player's own PDS, pointing at a name for the island's board, so a board is gathered from backlinks like the reactions are. Seelexicons/SUNFARMING.md. -
is.dame.state— live iPhone-sourced physical + ambient state (heart rate, activity, battery, ambient sound, calories). An append-only log keyed by TID: the latest record is the current "right now" rendered by the atmosphere-bar vitals panel (src/components/VitalsPanel.jsx, read viasrc/hooks/useDameState.js), and the full series is the history. Each record is immutable, so anis.dame.nowstatus can strong-ref the one captured alongside it via its optionalstateRef— coupling a note to the body-state behind it, which renders as a small chip (src/components/VitalsChip.jsx) under the status in the feed and on its record page. Posted straight from an iPhone Apple Shortcut (app-passwordcreateSession→createRecord, no server), and also charts over time in the /logging dashboard (src/components/StateStats.jsx). Seelexicons/STATE.md. -
is.dame.newsletter— the newsletter's standing words, a singleton atself: its name, the form's heading, the thank-you line and the fine print. Every field falls back to the built-in sentence. Edited in the admin's Newsletter surface; see Newsletter. -
is.dame.graph.list— one record per managed Bluesky list: a rule (people I engage with, people who engage with me, or accounts close in my follow graph, over a rolling 30 days) and the list it keeps current. Synced every six hours byapi/graph-lists.js; managed in the Analytics studio's Graph tab. Seedocs/GRAPH-LISTS.md. -
is.dame.nav— optional PDS override for the nav-menu (dock sheet) route list. When itsenabledflag is set, itsitemsselect / reorder / relabel / hide the entries; otherwise the site uses the hardcoded routes insrc/lib/navRoutes.js. Edited in the admin "Nav menu" panel. -
is.dame.overlay— stream overlays and scenes for OBS (or any tool that takes a browser source; stream.place gets whatever OBS sends it). One record per overlay, keyed by the id in its address,/overlay/{id}: a 1920×1080 canvas carrying the site's own grid (16 columns × 9 rows of 92px cells on 24px gutters), painted in the hour's sky or a fixed hour, with widgets placed on whole cells — a title, a countdown, the clock, the day of life, the latest status, now playing, vitals, the stream.place chat, capture frames, the mark and links. Modelled on atpota.to'sto.atpota.poe.overlay, with its separate scenes folded in as overlays whose backdrop is the page. The page reads the record without signing in and follows saves live over Jetstream. Edited in the admin's "Stream overlays" studio; seesrc/lib/overlay.js.Also on the canvas: Poe, atpota.to's potato, ported to run here (
src/overlay/poe/): it greets chatters, thanks new followers, says weather alerts and answers!weather,!forecast,!apps,!petand!poe. The atmosphere widgets (card, strip, badge, busiest apps, forecast, pulse) draw atpota.to's weather station in this site's type; the readings come throughapi/atmosphere.js, which passes onatpota.to/api/atmosphereand/api/weather-forecast. A TID clock shows the time as an atproto record key, and optionally the repo's latest revision. Text widgets set your own words in any of the site's voices on any of its grounds (page, raised, veil, accent, ink, the hour's sky), or as a ticker. Capture frames (rectangles or circles, with an optional nameplate) can be arranged for one to four sources at once, rotated so a different source takes the main window, and the studio lists where each goes in OBS.
Plus teal.fm for the now-playing signal: fm.teal.feed.play for plays and
fm.teal.actor.status for what's on right now. teal.fm moved off its
fm.teal.alpha.* lexicons in August 2026, so both namespaces are read and
collapsed by rkey (production wins) — see src/lib/teal.js.
/listening is the play feed. /listening/albums is the same history read the
other way: every record in the recent play history (the newest thousand plays
per teal.fm lexicon, not the whole archive), ranked by how often, each with a
page of its own at /listening/albums/{slug}.
An album is not a record. teal.fm scrobbles tracks, so an album here is what
a run of plays adds up to — the same relationship a mothing night has to its
observations. src/lib/albums.js is the whole derivation,
and it runs in three places so they cannot disagree: in the browser over the
live play history, in scripts/prefetch.mjs (which writes
public/data/albums.json from a deeper pull than the feed's own cap, since an
album is an archive rather than a feed), and at the edge, where the middleware
resolves one for the crawler <head>.
The address an album answers to is derived too — albumSlug(title, artist)
gives raven-by-kelela — so nothing has to be stored for a link to keep
working. It is lossy, so a slug resolves by comparing computed slugs across the
index rather than by trusting uniqueness; the most-played album wins a fold.
An album page also links out to where you can actually play the record
(albumLinksFor, the album-shaped cousin of the
per-play musicLinksFor). Apple gets a real link whenever the release is known
— from the id the artwork lookup returns, or failing that from the album URL
hiding inside one of its plays, since an Apple track URL is
…/album/{slug}/{albumId}?i={songId} and dropping the query is the record.
Spotify is always a search: its track URLs say nothing about the release they
are off, and there is no unauthenticated way to ask. The kind on each link
(direct vs search) is what the label is written from, so a guess never
presents itself as a certainty.
/listening/albums is the one literal segment under /listening that is not a
play's record key (a teal rkey is a TID, and nothing stops one spelling a word),
so isAlbumPath in og/records.js is checked before either
the router or the middleware asks for a record.
Open Graph: a play's card is drawn by /api/og?play={rkey} — the cover, the
track, the artist, and the album named rather than implied. /api/og?album={slug}
is one album's, and /api/og?albums=1 draws the index as a shelf of covers.
Artwork has no home in the play record, so it is resolved through Apple's
catalogue from one of the album's plays (ISRC → Apple song id → track + artist;
src/lib/musicIds.js is the ladder, shared by the
browser, the /api/albumart proxy, and the card renderer) and inlined as bytes,
so one dead cover can't take a card down with it.
/experimenting is the bench: quick prototypes and half-formed concepts, put
up before they are finished to find out what people make of them. Each one is
an is.dame.experiment record (a title, a pitch, and whatever there is to show
so far: a picture, a link to try, a longer write-up) with a page of its own at
/experimenting/{rkey}.
Under each is the ask and three answers, More of this, Curious and
Not for me, as buttons that carry their own counts, so the tally and the
way to add to it are one row. A reaction is an is.dame.experiment.reaction
record on the reactor's own PDS, signed with any atproto account, with an
optional note; one per person per experiment, and theirs to change or take
back. They are read from backlinks (Constellation → Slingshot → AppView), the
same way the guestbook is, and snapshotted at build time into
public/data/experimenting.json so the tallies paint at once.
To post one, sign in and use Content → Experimenting → New in the admin
(/admin?c=is.dame.experiment&mode=new); the owner also gets a "Post an
experiment" button on the page itself. status says where it stands: open
takes reactions, pursuing and shelved close them and say how it came out.
A draft is the owner's alone. The page's own title and intro are its
is.dame.page/experimenting record, like every page's.
An experiment's url can be anywhere. One that is built into this site lives
under the bench, as /experimenting/culturing,
/experimenting/sunfarming and
/experimenting/atmospheric-workbench do. A built-in experiment is a
project of its own in experiments/, with its own
package.json, dependencies and standalone build, which the site only imports;
experiments/README.md is how that works, how to add
one, and how to take one out into a repository of its own.
The whole design, including sign-in scopes and moderation, is in
lexicons/EXPERIMENTING.md;
src/lib/experiments.js is what an experiment and
its reactions add up to, and
src/lib/experimentReactions.js reads and
writes them.
/mothing reads moth observations for the iNaturalist user configured in
src/config.js (INATURALIST_USER), scoped to Lepidoptera minus butterflies.
The page paints from the build-time public/data/mothing.json snapshot and
refreshes live from the iNaturalist API in the browser.
Observations are grouped into sessions — one night at the light, 8pm to 3am,
keyed by the evening's date (an after-midnight sighting belongs to the night that
began the evening before). Each session has a page of its own at
/mothing/{YYYY-MM-DD}, which draws that night as a card gallery. A session is
not a record: it is what a night's worth of observation records add up to, so
both the page and the crawler-facing <head> derive it from the same snapshot
(findNight in src/lib/mothing.js) rather than fetching anything of their own.
/mothing/{slug} serves two things, told apart by the shape of the slug: a date
is a night, and anything else is an iNaturalist observation id (/mothing/392585028
→ the generic record page). A night's Open Graph card is drawn by
/api/og?night={date} — the date, the counts, the hours, and the first five moths
of the night inlined as photographs.
The home feed goes further: every iNaturalist observation is mirrored onto
the PDS and surfaced there — moths under the mothing verb, everything else
(birds, plants, fungi, butterflies, other insects…) under observing. The mirror
pulls all observations once and classifies each from its taxon ancestry
(isMoth = Lepidoptera, minus butterflies) so the two feed verbs partition the
set with nothing dropped or double-counted.
To keep that owned copy on the PDS, run the mirror:
BSKY_IDENTIFIER=dame.is BSKY_APP_PASSWORD=xxxx-xxxx-xxxx-xxxx \
node scripts/mirror-inaturalist.mjs # --full to force a complete resyncThe mirror is incremental: a cheap freshness check (one small request, over all
observations) skips the run entirely when nothing changed; otherwise it re-pulls
only observations changed since the last sync (via iNaturalist's
updated_since), writes just those to the right collection plus the two
refreshed summaries, and deletes records for observations removed upstream (or
moved across the moth boundary by a re-identification). --dry-run plans without
writing; --full ignores the freshness marker. A Vercel cron runs the same
sync every 6 hours (/api/mirror-mothing, see vercel.json), just before each
/api/rebuild, so new observations reach the PDS — and the home feed — within
hours instead of a day. It uses BSKY_APP_PASSWORD (+ optional
BSKY_IDENTIFIER), and it needs CRON_SECRET: the endpoint only runs for a
request carrying Authorization: Bearer <CRON_SECRET> (Vercel sends that on
its own cron calls), and with the secret unset it refuses every request. The
freshness check makes the extra runs cheap: they no-op when nothing changed
upstream.
The /mothing page applies the same freshness check in the browser: it paints
from the snapshot and only re-pulls the full observation set from iNaturalist
when the cheap signature says something actually changed.
/experimenting/culturing is a workbench of petri dishes that aren't real:
pour a medium, put cultures on it, add a disc or a drop of dye, and leave it
in the incubator. Nothing on it is science, and everything on it is modelled
on how real colonies and biofilms look and grow; the bench says which parts
are borrowed from where, in the card on each culture and medium and in "What
is real here".
A bench is worked with its tools laid over it, so like Sunfarming its page takes the whole window and the site draws none of its own interface there. The bench carries the way back out ("Back to dame.is", under its Culturing menu, or More on a phone), and the page hands it the experiment's reactions.
It is the first experiment, and the first that is a page of
this site rather than a link away from it. The page is built in and has no
record of its own; what puts it on the bench is an is.dame.experiment record
whose url is its address. The page finds that record by the address and
links to its reactions ("Say what you make of it", under the Culturing
menu). See
Experiments built into the site
for the convention.
The workbench is a package of its own,
experiments/culturing/, which the site imports as
@dame-is/culturing into one page
(src/pages/Culturing.jsx). It is its own chunk
and never warmed: it carries a WebGL2 simulation and its shaders. How the
model, the units, the recipes, the drawing and the bench work is in its
README, along with what it can be tested
for without a GPU. It is dressed in the site's kit, and borrows that through
one file (src/host.js), which is what
would have to travel with it if it left.
/experimenting/sunfarming is a small game. Each island starts on a diesel
generator; put down solar panels where the shade allows, keep the spare in
batteries, add wind for the night, and the village grows at dawn after a well
powered day, its homes moving up through three tiers that each want power at
a harder hour. An island is finished when every home is at its best and a
whole day has passed with the generator silent, and that opens the next of
six, each with its own weather, woods and seasons. It is drawn in cel-shaded
3D (three.js): a three-step light ramp, an ink outline round everything, a
banded sea with foam on the shore, and a sky that goes through the day.
Everybody starts on a tutorial island, First Light, whose lesson points at each thing in turn (an arrow on the button to press, an arrow on the tile to build on) and moves on when it has been done. It takes a couple of minutes, and the rest of the game opens when it is finished. Going from one island to the next happens behind a crossing: the sea comes up over the picture, says where the boat is bound, and lifts on the new island.
It is the second experiment built into the site. The whole
of it is experiments/sunfarming/, a package the
site imports as @dame-is/sunfarming; its
README has the rules, the controls and how
it is put together. It is its own chunk and never warmed.
A game wants the whole window, so its page
(src/pages/Sunfarming.jsx) is the game and
nothing else. On that address the site draws none of its own interface: no
bars, no dock, no inspect layer, and its single-key shortcuts stand down
(isImmersiveExperimentPath in
src/lib/experiments.js, asked by App.jsx). The
way back out is a button in the game's top corner, and in its menu on a
phone, which the page hands it: it goes to the experiment's own page, where
the reactions are, or to the bench until a record has been posted for it. The
game's full screen button asks the browser for real full screen where there
is such a thing.
A player who finishes an island can post the result with an atproto account:
an is.dame.sunfarming.result record on their own PDS, and each island has a
board of them, read from backlinks. The game knows nothing of atproto; the
page hands it a way to post
(src/hooks/useSunfarmingSocial.js), and
without one it only offers a line to copy.
lexicons/SUNFARMING.md is the whole of it.
The game looks nothing like the rest of the site, on purpose: it carries its
own stylesheet, scoped under one class, and reads none of the site's tokens,
so it is the same game on its own (npm run dev -w @dame-is/sunfarming) as it
is in the page.
/experimenting/atmospheric-workbench is a sky on a bench, with three benches
sharing one stage. On Clouds there is a sky to look round and a turntable
to reshape one cloud on. On Halos and bows there are ice crystals in the
air, and the halos they make of the sun are traced a ray at a time: nothing is
drawn as an arc, so laying plates flat gives sun dogs and raising the sun past
32° loses the circumzenithal arc, because that is what the rays do. Rain across
from the sun makes the bow. On Rays there is one prism, crystal or raindrop
with a beam through it, which is where the angles in the sky come from. The
page says which parts are real, and gives its sources, in "What is real here"
at its foot.
It is the third experiment built into the site, and it is a page with a bench on it, found and linked to its reactions the way Culturing is.
The workbench is a package of its own,
experiments/atmospheric-workbench/,
which the site imports as @dame-is/atmospheric-workbench into one page
(src/pages/AtmosphericWorkbench.jsx).
It is its own chunk and never warmed: it carries three.js and a ray tracer
that runs in a worker. How the tracer, the picture of the sky, the rainbow,
the clouds and the ray table work is in its
README, along with what its
tests hold it to and what has not been checked. It is dressed in the site's
kit, and borrows that through one file
(src/host.js).
The blog ("dame.is blogging", BLOG_PUBLICATION) doubles as an email
newsletter, sent by Leaflet. Leaflet keeps the list and
sends the email; this site only shows the form and never sees an address. The
whole flow is described in src/lib/newsletter.js.
- Where the form shows. A post places it with Leaflet's signup block
(
pub.leaflet.blocks.signup, "Newsletter signup" in the admin block editor) wherever the author wants one. A post without any gets one after its last line, and/bloggingkeeps one at the top, at#subscribe. - Its own page.
/blogging/subscribe(src/pages/BloggingSubscribe.jsx) is the page drawn as the email: the form is its To line, and the body is the latest post's opening, with earlier posts a step away. It sits where a post's rkey would, so the edge asksisSubscribePathfirst rather than 404ing it as a post that isn't there. - Its words. The subscribe page's title and intro are its
is.dame.page/subscriberecord, like every page's. Everything else the site says about the newsletter, wherever the form is, is theis.dame.newsletterrecord (src/lib/newsletterCopy.js): the name above the page's title, the form's heading in a post, the thank-you line and the fine print ({rss}becomes the feed's link). Both are edited in the admin's Newsletter surface, and an absent record or field is the built-in sentence. - Linking to it. Link to
https://dame.is/blogging/subscribe. In a post, that link (or one written the older way, to any dame.is page's#subscribe) opens the page in the same tab; anywhere else (an email, a feed reader, Bluesky) it opens like any link. Older links to/blogging#subscribestill land on the index's form. A reader whose way back from Leaflet has lost its page comes back to the newsletter page's form. - The form is Leaflet's embeddable subscribe form as a plain GET form to
leaflet.pub/api/auth/email-login. It only does anything once newsletter mode is on for the publication in Leaflet. - The way back. Once a reader confirms, Leaflet sends them to
/receive_auth_callbackon this site, not to the form's redirect (the real redirect is sealed in a token only Leaflet can read). The form notes its page in a cookie as it leaves, andapi/newsletter-return.jssends the reader back there, where the form says thanks. The path is rewritten to that function invercel.jsonand kept out of the middleware like the other non-SPA paths.
Every link in an essay, a work or the long-form profile ends on the icon of
the site it goes to, and hovering it (or tabbing to it) opens a card saying
where it leads: a Bluesky post's author, words and counts; a profile's banner
and bio; an article's headline, byline and date; a Wikipedia summary, with the
section linked to; a post on X; a Leaflet or other standard.site document's
publication; or a site's own description and share image. The card's foot
shows the address, and where the link really lands when it redirects
(attie.ai → attie.ai/login, twitter.com → x.com). Touch opens nothing; a
tap follows the link as before.
- Looked up at build time.
scripts/prefetch.mjswalks every document's link facets and writes one file per document,public/data/link-previews/<collection>/<rkey>.json, with each link's preview, the icons (32px WebP, inlined), and the links it couldn't read. Share images are shrunk withsharpintopublic/data/link-previews/img/, so a reader's browser never asks another site for anything. A link that can't be read keeps the previous build's preview. - Each kind of place in its own terms. Bluesky posts and profiles from
the public AppView, Wikipedia from its page-summary API, X from
publish.twitter.comoEmbed, a standard.site document from the record its page declares (read through Slingshot), and everything else from the page's<head>, fetched through the SSRF guard with every redirect re-checked. The shared, pure half issrc/lib/linkPreviews.js; the fetching half isapi/_lib/linkPreviews.js. - Newer than the build. A document published or edited since the last
build asks
api/link-previews.jsfor the links its file doesn't have. It only reads the owner's own documents, takes the record's currentcid(so the CDN can keep each version's answer for a week), and sends pictures through the image proxy until the next build shrinks them. - Drawn by
src/components/LinkPreview.jsx:LeafletDocumentprovides the previews when its page passesatUriandcid; without them (the block editor's preview) links are drawn exactly as before.
npm install
npm run prefetch # writes public/data/*.json from your PDS + AppView
npm run dev # Vite dev server on http://localhost:5173npm run build runs the prefetch script, then vite build. npm run build:offline
skips the prefetch (useful when a snapshot already exists).
The repo is an npm workspace: each folder under experiments/
is a package of its own, installed and linked by the same npm install. Any of
them runs by itself with npm run dev -w @dame-is/<name> (see
experiments/README.md); npm test and
npm run lint at the root cover them too.
package.json pins sharp to ^0.35.4 through overrides, and that pin is
load-bearing rather than tidy-minded. @vercel/og declares sharp as an
optional dependency and prefers it over its WASM fallback: given both, it
rasterizes every Open Graph card with libvips rather than resvg. At 0.11.1 it
asks for ^0.34.5, which no top-level range can lift, so without the override a
second, older copy lands under node_modules/@vercel/og/ and that is the one
/api/og runs — carrying libvips and libheif CVEs into a function that decodes
remote images (album covers, moth photographs).
Which rasterizer a deployment actually used is readable off the card: libvips
writes a pHYs chunk and splits the pixel data into 8 KB IDAT chunks, resvg
writes one IDAT and no pHYs.
Dropping the override doesn't break anything visibly, which is exactly why it is
written down here. Removing sharp from devDependencies would not help either
— the copy that mattered was @vercel/og's own.
| Concept | Lives in |
|---|---|
| AT Protocol client (Node + browser) | src/lib/atproto.js |
| Build-time data fetcher | scripts/prefetch.mjs |
| Hybrid snapshot/live data hook | src/hooks/useLiveFeed.js |
| Per-route AT URI lookup | src/hooks/useAtUri.js |
<head> discoverability tags |
src/components/AtUriHead.jsx |
| Atmosphere debug overlay | src/components/DebugPane.jsx |
| Day-of-life math | src/lib/dayOfLife.js |
| Albums, derived from plays | src/lib/albums.js |
| Edge middleware (404s, meta, negotiation) | middleware.js |
| Experiments, each a package of its own | experiments/ |
The site renders on the client, so the HTML on the wire used to carry seven
characters of text and every path — real or not — answered 200. A crawler
could learn nothing from a page and an agent could not tell a typo from a real
address. middleware.js answers all of that at the edge,
before the catch-all rewrite in vercel.json fires:
- Real 404s.
og/routes.jsmirrors the<Route>table insrc/App.jsx; a path matching no route shape gets a genuine404, as does a record route whose record does not resolve. The mirror is not trusted to stay accurate —og/routes.test.jsparsesApp.jsxandvercel.jsonand fails if either drifts from it. - Content without JavaScript.
og/ssrContent.jsbuilds a heading, the page's prose, the record behind it and the site's other surfaces as real links, injected into#root. An inline script hides it wherever JavaScript runs andsrc/main.jsxremoves it before React mounts, so nothing about the rendered site changes — but curl, an AI crawler and a text browser all get a readable page. - Markdown on request.
og/markdown.jsservestext/markdownto callers that ask for it (acceptmarkdown.com; RFC 9110 §12.5.1 for the q-value ranking,406for a request that accepts neither form). Everything negotiated carriesVary: Accept. - Share cards for posts. A post with photos unfurls as
/api/og?post={rkey}: the photos as a plate (up to four, laid out the way Bluesky lays them out) and the words beside them, or the first photo's alt text when there are none. A repost or a like unfurls as/api/og?repost={rkey}/?like={rkey}: the post it points at, under its author's avatar, name and handle, in quotation marks, and the head says "Dame reposted a post by …". Only a record key rides on the query; the renderer reads the text back off the record and builds every image URL itself from a DID and a CID on the Bluesky CDN (as JPEG, so never an SVG). Photos a moderation label covers stay off the card, and an author who has opted out of signed-out viewing gets the plain verb card instead. - Share cards for passages. Select some of an essay's prose (a blog post
or a work, anything that is a
site.standard.document) and a small toolbar offers a link to that passage,/blogging/{rkey}?quote={words}. The link unfurls as/api/og?doc={rkey}"e={words}, which sets the passage in quotation marks with the essay's title under it, and a reader who follows it lands on the passage, highlighted. The words in the URL are only ever used to find a place in the record: the edge and the card renderer both look them up in the document's prose (src/lib/quote.js) and draw the record's own words, so a link with words the essay doesn't contain unfurls as the plain essay. Quotations, credits, code and embedded posts can't be quoted, since a card would present them as Dame's words. Two things about Bluesky shaped this. Its Standard Site card keeps a link's image but takes the title and description from the record, so there the image is what carries the passage. And its composer saves whichever URL a page'srel=canonicalnames, so a passage link names itself as canonical (markednoindex, which keeps the essay the one indexed page); otherwise a reader tapping the card would land at the top of the essay. - Identity.
og/jsonld.jsemits a schema.org@graph— aPerson, theWebSitethey publish, and the page — plus a per-path canonical URL. It is a Person, not an Organization: there is no company here and no address that belongs in public.
Two files are generated at build time by scripts/prefetch.mjs, from the same
snapshots, so they cannot disagree about what exists:
| File | Built by | For |
|---|---|---|
/sitemap.xml |
buildSitemap |
crawlers |
/feed.xml |
buildAtomFeed |
Atom readers |
/llms.txt |
og/llms.js |
agents — what the site is for, when to use it, when not to, and the unauthenticated atproto endpoint that serves the same data |
There is no REST API to publish and none is planned: the AT Protocol repository
behind the site is the read API, it needs no key, and /llms.txt names it with
a working curl.
After deploying, in Vercel:
- Settings → Git → Deploy Hooks → create one named
pds-rebuildand copy the URL. - Settings → Environment Variables → set
DEPLOY_HOOK_URLto that URL, andCRON_SECRETto a long random string./api/rebuildand the mirror endpoints refuse every request while it is unset, the 6-hour cron included; Vercel sends it on its own cron calls, and anything else calling them has to sendAuthorization: Bearer <CRON_SECRET>. - (Optional) point your publishing flow (Apple Shortcuts, etc.) at the same URL
so a
curl -X POSTafter writing a record kicks an instant rebuild.
bluesky-comments— comment threads on blog posts.- teal.fm — listening signal.