@profullstack/builtindie 0.1.4 → 0.7.1

package/src/karma.ts

@@ -0,0 +1,179 @@
+/**
+ * Karma: points for helping the board, one network-wide rule set (built.indie and
+ * pwamart.com pay the same actions the same points).
+ *
+ * Every write goes through here and lands in one append-only ledger
+ * (karma_events, db.ts). A dedupe key per fact means a retry or a double click
+ * never pays twice; a reversal (a comment deleted, a listing taken down) is a
+ * new negative row. Signed-in members earn; anonymous actions still work and
+ * earn nothing. Acting on your own listing earns nothing. Every
+ * KARMA_PER_CREDIT karma grants a free Featured week, once per milestone.
+ */
+import { dayOf, type Product, type Store } from './db.js'
+
+export const POINTS = {
+  launch: 10,
+  vote: 1,
+  review: 5,
+  comment: 2,
+  share: 1,
+  upvoted: 1,
+  reviewed: 2,
+  claim: 5,
+  invite: 25,
+  badge: 5,
+} as const
+export type KarmaAction = keyof typeof POINTS
+
+/** Paid actions per member per UTC day; past it the action still works, it just pays nothing. */
+export const DAILY_CAPS: Partial<Record<KarmaAction, number>> = { vote: 20, comment: 10, share: 5 }
+
+/** The share intents we track: one paid click per listing per network per day. */
+export const SHARE_NETWORKS = ['x', 'bluesky', 'linkedin', 'reddit', 'hn', 'mastodon', 'copy'] as const
+export type ShareNetwork = (typeof SHARE_NETWORKS)[number]
+
+export const MIN_REVIEW_CHARS = 30
+export const MIN_COMMENT_CHARS = 10
+
+/** What each ledger action reads as, in history lists. */
+export const ACTION_LABELS: Record<string, string> = {
+  launch: 'Launched a listing',
+  vote: 'Upvoted a launch',
+  review: 'Reviewed a launch',
+  comment: 'Commented',
+  share: 'Shared a launch',
+  upvoted: 'Your launch got an upvote',
+  reviewed: 'Your launch got a review',
+  claim: 'Claimed a listing',
+  invite: 'An invited maker launched',
+  badge: 'Badge verified on your site',
+  comment_deleted: 'Comment deleted',
+  review_deleted: 'Review deleted',
+  reviewed_deleted: 'A review of your launch was deleted',
+  taken_down: 'Listing taken down',
+}
+
+/** The "how to earn" table, for the member page, the leaderboard and the docs. */
+export const HOW_TO_EARN: { action: string; points: number; rule: string }[] = [
+  { action: 'Launch a listing', points: POINTS.launch, rule: 'the first time each listing goes live' },
+  { action: 'Upvote', points: POINTS.vote, rule: `not your own listing; up to ${DAILY_CAPS.vote} paid a day` },
+  { action: 'Review', points: POINTS.review, rule: `stars and at least ${MIN_REVIEW_CHARS} characters; once per listing; not your own` },
+  { action: 'Comment', points: POINTS.comment, rule: `at least ${MIN_COMMENT_CHARS} characters; up to ${DAILY_CAPS.comment} paid a day; deleting it takes the points back` },
+  { action: 'Share', points: POINTS.share, rule: `a share button (X, Bluesky, LinkedIn, Reddit, HN, Mastodon, copy link); once per listing per network per day; up to ${DAILY_CAPS.share} a day` },
+  { action: 'Your launch gets an upvote', points: POINTS.upvoted, rule: 'from a signed-in member who is not you' },
+  { action: 'Your launch gets a review', points: POINTS.reviewed, rule: 'from someone else' },
+  { action: 'Claim your listing', points: POINTS.claim, rule: 'prove you own the domain (badge or DNS), once per listing' },
+  { action: 'Invite a maker who launches', points: POINTS.invite, rule: 'a new member from your invite link launches their first listing' },
+  { action: 'Badge verified', points: POINTS.badge, rule: 'our badge is on your homepage and we found it, once per listing' },
+]
+
+/** Who a listing's karma goes to: the owner who claimed it, else the member who launched it. */
+export const ownerOf = (p: Pick<Product, 'ownerId' | 'submitterUser'>) => p.ownerId ?? p.submitterUser ?? null
+const isSelf = (p: Pick<Product, 'ownerId' | 'submitterUser'>, userId: string) => p.ownerId === userId || p.submitterUser === userId
+
+export type KarmaSummary = { total: number; week: number; perCredit: number; nextCreditIn: number; progress: number; credits: { granted: number; used: number }; events: { action: string; label: string; ref: string; points: number; at: number }[] }
+
+export class Karma {
+  /** Called after every write that changed someone's karma: the server refreshes the board and awards badges. */
+  onChange?: (userId: string) => void
+  /** Called when a milestone grants a free Featured week. */
+  onCredit?: (userId: string, granted: number) => void
+
+  constructor(readonly store: Store, readonly perCredit = 500) {}
+
+  private pay(userId: string | null, action: KarmaAction, ref: string, dedupe: string, opts: { daily?: boolean; capped?: boolean } = {}, now = Date.now()): boolean {
+    if (!userId) return false
+    const ok = this.store.addKarma({ userId, action, ref, points: POINTS[action], dedupe, daily: opts.daily, cap: opts.capped ? DAILY_CAPS[action] : undefined }, now)
+    if (ok) this.changed(userId, now)
+    return ok
+  }
+
+  private changed(userId: string, now = Date.now()): void {
+    const granted = this.store.grantKarmaCredits(userId, this.perCredit, now)
+    if (granted) this.onCredit?.(userId, granted)
+    this.onChange?.(userId)
+  }
+
+  private reverse(dedupe: string, action: string): boolean {
+    const userId = this.store.reverseKarma(dedupe, action)
+    if (userId) this.onChange?.(userId)
+    return Boolean(userId)
+  }
+
+  /** A listing went live for the first time. Not for anonymous or admin-bearer imports (no member). */
+  launched(p: Product, userId: string | null = p.submitterUser): boolean {
+    return this.pay(userId, 'launch', p.id, `launch:${p.id}`)
+  }
+
+  /** A counted vote. The voter earns (capped), the owner earns for a vote from someone else; both only when the voter is a member and not the owner. */
+  voted(p: Product, voterId: string | null, now = Date.now()): { voter: boolean; owner: boolean } {
+    if (!voterId || isSelf(p, voterId)) return { voter: false, owner: false }
+    const voter = this.pay(voterId, 'vote', p.id, `vote:${voterId}:${p.id}`, { capped: true }, now)
+    const owner = this.pay(ownerOf(p), 'upvoted', `${p.id}:${voterId}`, `upvoted:${p.id}:${voterId}`, {}, now)
+    return { voter, owner }
+  }
+
+  /** A review saved (new or edited). Pays once per listing, when it has stars and enough words, and never on your own. */
+  reviewed(p: Product, userId: string, review: { rating: number; body: string }): { reviewer: boolean; owner: boolean } {
+    if (isSelf(p, userId) || !(review.rating >= 1 && review.rating <= 5) || review.body.trim().length < MIN_REVIEW_CHARS) return { reviewer: false, owner: false }
+    const reviewer = this.pay(userId, 'review', p.id, `review:${userId}:${p.id}`)
+    const owner = this.pay(ownerOf(p), 'reviewed', `${p.id}:${userId}`, `reviewed:${p.id}:${userId}`)
+    return { reviewer, owner }
+  }
+
+  /** A review deleted: both sides give back what it paid. Writing a new one later pays nothing again. */
+  unreviewed(p: Product, userId: string): void {
+    this.reverse(`review:${userId}:${p.id}`, 'review_deleted')
+    this.reverse(`reviewed:${p.id}:${userId}`, 'reviewed_deleted')
+  }
+
+  commented(p: Product, userId: string, comment: { id: string; body: string }, now = Date.now()): boolean {
+    if (isSelf(p, userId) || comment.body.trim().length < MIN_COMMENT_CHARS) return false
+    return this.pay(userId, 'comment', `${p.id}:${comment.id}`, `comment:${comment.id}`, { capped: true }, now)
+  }
+
+  /** A comment deleted (by its author or an admin): the points it earned go back. */
+  uncommented(commentId: string): boolean {
+    return this.reverse(`comment:${commentId}`, 'comment_deleted')
+  }
+
+  shared(p: Product, userId: string | null, network: string, now = Date.now()): boolean {
+    if (!userId || isSelf(p, userId) || !(SHARE_NETWORKS as readonly string[]).includes(network)) return false
+    return this.pay(userId, 'share', `${p.id}:${network}`, `share:${userId}:${p.id}:${network}:${dayOf(now)}`, { capped: true }, now)
+  }
+
+  claimed(p: Product, userId: string): boolean {
+    return this.pay(userId, 'claim', p.id, `claim:${p.id}`)
+  }
+
+  badgeVerified(p: Product): boolean {
+    return this.pay(ownerOf(p), 'badge', p.id, `badge:${p.id}`)
+  }
+
+  inviteConverted(inviterId: string, productId: string): boolean {
+    return this.pay(inviterId, 'invite', productId, `invite:${productId}`)
+  }
+
+  /** A listing taken down for spam: everything it paid anyone goes back. Credits already granted stay granted. */
+  takenDown(productId: string): number {
+    let n = 0
+    for (const key of this.store.karmaAbout(productId)) n += Number(this.reverse(key, 'taken_down'))
+    return n
+  }
+
+  summary(userId: string, now = Date.now()): KarmaSummary {
+    const total = this.store.karmaTotal(userId)
+    const credits = this.store.karmaCredits(userId)
+    // The next milestone is past both the karma held and the last one granted (a reversal never re-pays a milestone).
+    const next = Math.max(Math.floor(Math.max(total, 0) / this.perCredit) + 1, credits.best / this.perCredit + 1) * this.perCredit
+    return {
+      total,
+      week: this.store.karmaTotal(userId, now - 7 * 86400_000),
+      perCredit: this.perCredit,
+      nextCreditIn: next - total,
+      progress: Math.max(0, Math.min(1, 1 - (next - total) / this.perCredit)),
+      credits: { granted: credits.granted, used: credits.used },
+      events: this.store.karmaEvents(userId).map((e) => ({ action: e.action, label: ACTION_LABELS[e.action] ?? e.action, ref: e.ref, points: e.points, at: e.createdAt })),
+    }
+  }
+}

package/src/leaderboard.ts

@@ -0,0 +1,59 @@
+/**
+ * The leaderboards, on @profullstack/leaderboard: karma (the default board) and
+ * inviters. Both project tables we already keep, the karma ledger and the
+ * invites table (an invite counts once the member it brought in launches), so
+ * there is no second copy of the facts to drift; badges, which are awarded
+ * rather than derived, live in the same SQLite file (lb_ tables).
+ *
+ * A projection is never record()ed: call award(player) after every karma or
+ * invite write, or badges never appear.
+ *
+ * The package serves /leaderboard.json, /leaderboard/<board>.json|.xml, the
+ * share card /leaderboard/u/<id> and the widget /leaderboard/embed.js; the
+ * /leaderboard page itself is ours, in the site's layout (server.ts).
+ */
+import { createLeaderboard, projectionStore, sqlStore, type Period, type Profile } from '@profullstack/leaderboard'
+import type { Store } from './db.js'
+
+const count = (p: Profile) => Number(p.totals?.invites ?? 0)
+const karma = (p: Profile) => Number(p.totals?.karma ?? 0)
+const bestRank = (p: Profile, period: Period) => Math.min(...Object.values(p.ranks ?? {}).map((r) => r?.[period] ?? Infinity))
+
+export function siteLeaderboard(store: Store, origin: string) {
+  const badges = sqlStore({ execute: ({ sql, args }) => ({ rows: store.db.query(sql).all(...((args ?? []) as never[])) as Record<string, unknown>[] }) })
+  for (const sql of badges.schema) store.db.exec(sql)
+  return createLeaderboard({
+    siteName: 'built.indie',
+    siteUrl: origin,
+    periods: ['week', 'month', 'all'],
+    defaultPeriod: 'week',
+    sides: { use: 'Members' },
+    boards: {
+      karma: { label: 'Top karma', metric: 'karma', format: 'integer', unit: 'Karma', side: 'use', actor: 'Member', min: 1 },
+      invites: { label: 'Top inviters', metric: 'invites', format: 'integer', unit: 'Makers launched', side: 'use', actor: 'Member', min: 1 },
+    },
+    badges: [
+      { id: 'first-karma', emoji: '✨', label: 'First karma', describe: 'Earned 10 karma', when: (p) => karma(p) >= 10 },
+      { id: 'karma-100', emoji: '💯', label: '100 karma', describe: 'Earned 100 karma', when: (p) => karma(p) >= 100 },
+      { id: 'karma-1000', emoji: '🔥', label: '1,000 karma', describe: 'Earned 1,000 karma', when: (p) => karma(p) >= 1000 },
+      { id: 'first-invite', emoji: '🎟️', label: 'First invite', describe: 'Brought in a maker who launched', when: (p) => count(p) >= 1 },
+      { id: 'five-invites', emoji: '🚀', label: 'Five makers', describe: 'Five invited makers launched', when: (p) => count(p) >= 5 },
+      { id: 'twenty-five-invites', emoji: '🌟', label: 'Twenty-five makers', describe: 'Twenty-five invited makers launched', when: (p) => count(p) >= 25 },
+      { id: 'top-ten-week', emoji: '🏅', label: 'Top ten this week', describe: 'In a weekly top ten (karma or inviters)', when: (p) => bestRank(p, 'week') <= 10 },
+      { id: 'number-one', emoji: '👑', label: 'Number one', describe: 'Number one for a week, a month or all time', when: (p) => [bestRank(p, 'week'), bestRank(p, 'month'), bestRank(p, 'all')].includes(1) },
+    ],
+    store: projectionStore({
+      events: async ({ since }: { since: number }) => {
+        const names = new Map<string, string>()
+        const name = (id: string) => names.get(id) ?? (names.set(id, store.publicName(id)), names.get(id)!)
+        return [
+          ...store.karmaSince(since).map((e) => ({ player: e.userId, name: name(e.userId), metric: 'karma', delta: e.points, at: e.at })),
+          ...store.earnedInvites(since).map((e) => ({ player: e.inviter, name: name(e.inviter), metric: 'invites', delta: 1, at: e.at })),
+        ]
+      },
+      badges,
+    }),
+  })
+}
+
+export type SiteBoard = ReturnType<typeof siteLeaderboard>

package/src/mcp.ts

@@ -3,13 +3,13 @@
  *
  *   claude mcp add builtindie -- bunx @profullstack/builtindie mcp
  *
- * Reading, launching and voting need nothing. Claiming and editing need
+ * Reading, launching and voting need nothing. Claiming, editing, commenting, reviewing and karma need
  * BUILTINDIE_KEY: an account API key from built.indie.pit.world/me.
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod'
-import { BuiltIndieClient } from './client.js'
+import { BuiltIndieClient, type SearchFilters } from './client.js'
 import { VERSION } from './version.js'
 
 const text = (value: unknown) => ({ content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] })
@@ -45,7 +45,31 @@ export function createMcpServer(client = new BuiltIndieClient()): McpServer {
     wrap((a: { window: string; limit: number }) => client.list(a.window, a.limit)),
   )
   server.tool('get_product', 'Everything about one launch: description, pictures, videos, socials, maker, votes, award.', { slug }, wrap((a: { slug: string }) => client.product(a.slug)))
-  server.tool('search', 'Search launches by name, tagline, domain or tag.', { query: z.string().min(1).max(60) }, wrap((a: { query: string }) => client.search(a.query)))
+  server.tool('list_tags', 'Every tag on built.indie with how many launches carry it, most used first.', {}, wrap(() => client.tags()))
+  server.tool(
+    'tagged',
+    'Launches with one exact tag (from list_tags), best first.',
+    { tag: z.string().min(2).max(24), limit: z.number().int().min(1).max(100).default(20) },
+    wrap((a: { tag: string; limit: number }) => client.tagged(a.tag, a.limit)),
+  )
+  server.tool(
+    'search',
+    'Search and filter launches. Words match name, tags, category, domain, tagline, maker, stack and description. Narrow with categories (see list_categories), tags, has (verified, claimed, featured, video, screenshots, llms, opensite, openprofile, openstack, opensaas, maker), stack, maker and launched. The answer carries facets: counts for each value, to narrow further.',
+    {
+      query: z.string().max(80).default(''),
+      category: z.array(z.string()).max(10).optional().describe('Category keys, e.g. developer-tools, ai, crypto, security (any of them)'),
+      tag: z.array(z.string()).max(10).optional().describe('Tags (any of them)'),
+      has: z.array(z.string()).max(10).optional().describe('Every one must hold: verified, claimed, featured, video, screenshots, llms, opensite, openprofile, openstack, opensaas, maker'),
+      stack: z.array(z.string()).max(10).optional().describe('Built with (from the product\'s OpenStack.md)'),
+      maker: z.array(z.string()).max(10).optional(),
+      launched: z.enum(['today', 'week', 'month', 'year']).optional(),
+      sort: z.enum(['relevance', 'top', 'new', 'name']).optional(),
+      page: z.number().int().min(1).max(500).optional(),
+      limit: z.number().int().min(1).max(100).default(20),
+    },
+    wrap(({ query, ...filters }: { query: string } & SearchFilters) => client.search(query, filters)),
+  )
+  server.tool('list_categories', 'Every category and tag on built.indie, with how many launches each has.', {}, wrap(() => client.categories()))
   server.tool('upvote', 'Upvote a product (one vote per visitor).', { slug }, wrap((a: { slug: string }) => client.vote(a.slug)))
   server.tool(
     'edit_product',
@@ -66,11 +90,38 @@ export function createMcpServer(client = new BuiltIndieClient()): McpServer {
   )
   server.tool(
     'claim_product',
-    'Claim a listing for its domain owner (needs BUILTINDIE_KEY). Returns the DNS TXT record to add, plus `markdown`: step-by-step instructions for whoever has DNS access. Call again once it is in DNS and claimed comes back true.',
+    'Claim a listing for its domain owner (needs BUILTINDIE_KEY). Two proofs, either works. Easiest: put the `badge` HTML on the product homepage; it is <img src="https://built.indie.pit.world/images.svg?id=<id>"> with an id unique to this listing and this account, and it also earns the followed link and the ✓. Or add the DNS TXT `record`. Also returns `markdown`: step-by-step instructions for whoever has site or DNS access. Call again once either is live; claimed comes back true with `method` badge or dns.',
     { slug },
     wrap((a: { slug: string }) => client.claim(a.slug)),
   )
   server.tool('my_products', 'Your launches and claims (needs BUILTINDIE_KEY).', {}, wrap(() => client.me()))
+  server.tool('my_invites', 'Your invite link and credits (needs BUILTINDIE_KEY). Each new member who signs up through the link and launches a listing earns one credit: a free Featured week.', {}, wrap(() => client.invites()))
+  server.tool('feature_with_credit', 'Spend one invite credit to feature a listing you own for a week (needs BUILTINDIE_KEY).', { slug }, wrap((a: { slug: string }) => client.credit(a.slug)))
+  server.tool('redeem_code', 'Redeem a credit code (CR-XXXX-XXXX-XXXX-XXXX) for Featured days on your balance (needs BUILTINDIE_KEY).', { code: z.string().min(4).describe('The credit code') }, wrap((a: { code: string }) => client.redeem(a.code)))
+  server.tool('create_invite', 'Make one of your 3 single-use invite codes (needs BUILTINDIE_KEY). Someone new who signs up through the link gives you both Featured days. The link is shown once.', { note: z.string().max(80).optional().describe('Who it is for, only you see it') }, wrap((a: { note?: string }) => client.inviteCode(a.note ?? '')))
+  server.tool('feature_with_days', 'Spend Featured days from your balance (from codes and invites) on a listing you own (needs BUILTINDIE_KEY).', { slug, days: z.number().int().min(1).describe('How many days') }, wrap((a: { slug: string; days: number }) => client.featureDays(a.slug, a.days)))
+  server.tool('feature_paid', 'Pay to feature a listing you own (needs BUILTINDIE_KEY): returns a CoinPay hosted checkout_url where the buyer picks any coin or PayPal. The receipt goes to email (default: your account email).', { slug, email: z.string().email().optional().describe('Where the receipt goes') }, wrap((a: { slug: string; email?: string }) => client.feature(a.slug, a.email)))
+  server.tool('my_karma', 'Your karma on built.indie (needs BUILTINDIE_KEY): total, this week, recent history, how many karma to the next free Featured week, and the how-to-earn table.', {}, wrap(() => client.karma()))
+  server.tool(
+    'leaderboard',
+    'The built.indie leaderboard: top karma (default) or top inviters, for a week, a month or all time.',
+    { board: z.enum(['karma', 'invites']).default('karma'), period: z.enum(['week', 'month', 'all']).default('week'), limit: z.number().int().min(1).max(100).default(10) },
+    wrap((a: { board: string; period: string; limit: number }) => client.leaderboard(a.board, a.period, a.limit)),
+  )
+  server.tool('list_comments', 'The comments on a launch, oldest first, with each author\'s karma; replies carry their parent id.', { slug }, wrap((a: { slug: string }) => client.comments(a.slug)))
+  server.tool(
+    'comment',
+    'Comment on a launch (needs BUILTINDIE_KEY). 10+ characters earns 2 karma (10 paid a day; not on your own listing). parent replies to a comment.',
+    { slug, body: z.string().min(2).max(2000), parent: z.string().optional().describe('A comment id to reply to') },
+    wrap((a: { slug: string; body: string; parent?: string }) => client.comment(a.slug, a.body, a.parent)),
+  )
+  server.tool('list_reviews', 'The reviews of a launch with its average rating.', { slug }, wrap((a: { slug: string }) => client.reviews(a.slug)))
+  server.tool(
+    'review',
+    'Review a launch (needs BUILTINDIE_KEY): 1-5 stars and text; one per member per launch, posting again updates it. 30+ characters earns 5 karma, once; not on your own listing.',
+    { slug, rating: z.number().int().min(1).max(5), body: z.string().max(2000).default('') },
+    wrap((a: { slug: string; rating: number; body: string }) => client.review(a.slug, a.rating, a.body)),
+  )
   return server
 }
 

package/src/pit-footer.ts

@@ -0,0 +1,39 @@
+/**
+ * The pit.world global footer: one line (site · Search · Ring · Publish here)
+ * that pit.world serves as an HTML fragment for every site on the network.
+ *
+ * We read https://pit.world/snippets/footer.html?site=<name> in the background
+ * (3 s timeout, again every hour) and print the last good copy as the last thing
+ * in <body>, so a page never waits on pit.world. Until the first read, or if
+ * pit.world is down, it renders nothing. The fragment carries data-pit-footer,
+ * which tells the pit.world relay not to add a second copy.
+ */
+const SNIPPET = 'https://pit.world/snippets/footer.html'
+
+let cached = ''
+
+/** The last good footer fragment, or '' before the first read. */
+export function pitFooter(): string {
+  return cached
+}
+
+/** Accept a fragment only if it looks like the footer; anything else is ignored. */
+export function setPitFooter(html: unknown): boolean {
+  if (typeof html !== 'string' || !html.includes('data-pit-footer') || html.length > 64_000) return false
+  cached = html.trim()
+  return true
+}
+
+/** Refresh from pit.world now and every `everyMs`. Failures keep the last good copy. */
+export function startPitFooterRefresh(site: string, fetchImpl: typeof fetch = fetch, everyMs = 60 * 60_000): () => void {
+  const url = `${SNIPPET}?site=${encodeURIComponent(site)}`
+  const refresh = () =>
+    fetchImpl(url, { signal: AbortSignal.timeout(3000) })
+      .then((r) => (r.ok ? r.text() : null))
+      .then((html) => html && setPitFooter(html))
+      .catch(() => {})
+  refresh()
+  const timer = setInterval(refresh, everyMs)
+  timer.unref?.()
+  return () => clearInterval(timer)
+}

package/src/profile.ts

@@ -0,0 +1,34 @@
+/**
+ * The shared Profullstack profile (@profullstack/profile): email, first and last
+ * name, company domain, job title and LinkedIn URL, in the package's own
+ * `user_profiles` table keyed by users.id. Private to the member: nothing here is
+ * shown on a public page.
+ */
+import type { Database } from 'bun:sqlite'
+import { createProfileStore, migrate, splitFullName, type ProfileStore } from '@profullstack/profile'
+
+/** The store, and `ready` once its table exists (created when the database opens). */
+export function openProfiles(db: Database): { store: ProfileStore; ready: Promise<ProfileStore> } {
+  const store = createProfileStore(db, { keyType: 'text' })
+  const ready = migrate(store).then(async () => {
+    await backfill(db, store)
+    return store
+  })
+  ready.catch((error) => console.error(`[profile] migration failed: ${(error as Error).message}`))
+  return { store, ready }
+}
+
+/**
+ * One-time and idempotent: a display name typed as "First Last" becomes the
+ * profile's names. A single word is a handle, not a name, and is left alone, and
+ * fillBlanks never overwrites what a member saved.
+ */
+async function backfill(db: Database, store: ProfileStore) {
+  const rows = db.query(`SELECT u.id, u.email, u.display_name FROM users u
+    WHERE instr(trim(u.display_name), ' ') > 0 AND NOT EXISTS (SELECT 1 FROM user_profiles p WHERE p.user_id = u.id)`)
+    .all() as { id: string; email: string; display_name: string }[]
+  for (const row of rows) {
+    const email = row.email.endsWith('.invalid') ? {} : { email: row.email }
+    try { await store.fillBlanks(row.id, { ...splitFullName(row.display_name), ...email }) } catch { /* a name the validator refuses is skipped */ }
+  }
+}

package/src/ring-footer.ts

@@ -0,0 +1,53 @@
+/**
+ * built.indie's footer: its links, the << Profullstack >> webring nav and the
+ * copyright line, from @profullstack/footer. It is rendered into the HTML on the
+ * server because rssamplifier's ring verifier reads the page and never runs script.
+ *
+ * Pages render synchronously, so the footer is kept as a string: the bundled
+ * template at boot, then the @latest template from the CDN, refreshed every 15
+ * minutes (a footer release reaches us with no redeploy). A failed refresh keeps
+ * the last good copy. Our CSP allows inline styles, so the template CSS stays on.
+ */
+import { footerHtml, footerHtmlSync } from '@profullstack/footer'
+
+type FooterOptions = Parameters<typeof footerHtmlSync>[0]
+
+export function ringFooterOptions(links: { label: string; href: string }[]): FooterOptions {
+  return {
+    site: 'https://built.indie.pit.world/',
+    links,
+    since: 2026,
+    tagline: 'Free, open source (MIT)',
+  }
+}
+
+let options: FooterOptions | null = null
+let html = ''
+
+export function setRingFooterOptions(next: FooterOptions): void {
+  options = next
+  html = footerHtmlSync(next)
+}
+
+/** The footer markup, never empty once options are set. */
+export function ringFooter(): string {
+  return html
+}
+
+/** Accept a rendered footer only when it still links the ring. */
+export function setRingFooter(next: unknown): boolean {
+  if (typeof next !== 'string' || !next.includes('/ring/profullstack') || next.length > 64_000) return false
+  html = next
+  return true
+}
+
+export function startRingFooterRefresh(everyMs = 15 * 60_000): () => void {
+  const run = () => {
+    if (!options) return
+    footerHtml(options).then(setRingFooter, () => {})
+  }
+  run()
+  const timer = setInterval(run, everyMs)
+  ;(timer as { unref?: () => void }).unref?.()
+  return () => clearInterval(timer)
+}

package/src/ring.ts

@@ -69,6 +69,7 @@ export function siteHref(site: RingSite, direct: boolean): string {
   return site.moshpit && !direct ? relayUrl(site.name) : `https://${site.name}/`
 }
 
+/** The ring, the site you are on between its neighbours, random, and the way in for a builder (pit.world/start). */
 export function ringBar(self: string, direct: boolean): string {
   const at = sites.findIndex((s) => s.name === self)
   const i = at < 0 ? 0 : at
@@ -76,11 +77,14 @@ export function ringBar(self: string, direct: boolean): string {
   const next = sites[(i + 1) % sites.length]!
   const link = (s: RingSite, text = s.name) =>
     `<a href="${esc(siteHref(s, direct))}"${s.name === self ? ' aria-current="page"' : ''} title="${esc(s.about)}">${esc(text)}</a>`
+  const current = sites.find((s) => s.name === self)
+  const here = current ? link(current) : `<span aria-current="page">${esc(self)}</span>`
   return `<nav class="ring-bar" aria-label="Moshpit ring">
   <a class="ring-home" href="${RING_HOME}">◉ <span>Moshpit </span>ring</a>
   ${link(prev, `‹ ${prev.name}`)}
-  <span class="ring-sites">${sites.map((s) => link(s)).join('')}</span>
+  <span class="ring-sites">${here}</span>
   ${link(next, `${next.name} ›`)}
   <a href="${RING_HOME}/random?from=${encodeURIComponent(self)}${direct ? '&amp;direct=1' : ''}">random</a>
+  <a class="ring-start" href="https://pit.world/start">Start building here…</a>
 </nav>`
 }