@profullstack/builtindie 0.6.0 → 0.7.1

package/README.md

@@ -22,6 +22,13 @@ Viral bits: a live badge with the upvote count (`/badge/<slug>.svg`) that turns
 
 **Invite program.** Every account has an invite link, `/i/<code>` (on `/invite`, `/me`, `builtindie invite`, `GET /api/v1/invites`, MCP `my_invites`). When a new member who signed up through it gets their first listing live, the inviter earns a credit: a free **Featured** week (the same slot that costs $19 in crypto). Spend it on any listing you own from `/invite`, the listing's page, `builtindie credit <slug>`, `POST /api/v1/products/<slug>/credit` or MCP `feature_with_credit`. Once per new member, never yourself; the code rides in the magic link, so it counts when the mail opens in another browser; an admin takedown of the listing takes back an unspent credit. The inviter gets an email when a credit lands.
 
+**Credit codes and invite codes (0.7.0).** A credit code (`CR-XXXX-XXXX-XXXX-XXXX`, [@profullstack/redeem-credits](https://www.npmjs.com/package/@profullstack/redeem-credits), unit `featured_days`) adds Featured days to a member's balance: "Have a code?" on `/me`, `POST /api/v1/redeem`, `builtindie redeem <code>`, MCP `redeem_code`. The days go on any live listing you own through the same `featured_until` a paid week extends (`/me`, the listing's Feature card, `POST /api/v1/products/<slug>/feature-days {"days":n}`, `builtindie feature-days <slug> <n>`, MCP `feature_with_days`). Every member also has **3 single-use invite codes** ([@profullstack/affiliates](https://www.npmjs.com/package/@profullstack/affiliates)) on `/invite#codes`, `POST /api/v1/invites`, `builtindie invite-code`, MCP `create_invite`: someone new who signs up through `/i/INV-…` gives both people **2 Featured days**, and the sign-up counts once in the invite program above (same `invites` row). `?ref=<your invite code>` on any page is your invite link too (the same `bi_ref` cookie, first touch). Mint codes on the server:
+
+```sh
+cd /opt/built.indie && /root/.bun/bin/bun $(readlink -f node_modules/.bin/redeem-credits) mint \
+  --db /root/.local/share/built-indie/built-indie.db --unit featured_days --amount 7 --label "for Ada"
+```
+
 **Leaderboard.** `/leaderboard` ranks the top inviters (week, month, all time) with badges, on [@profullstack/leaderboard](https://github.com/profullstack/leaderboard). It projects the `invites` table, so there is no second ledger; badges live in the `lb_` tables of the same database. The package also serves `/leaderboard.json`, `/leaderboard/invites.json|.xml`, a share card per member at `/leaderboard/u/<id>`, and a widget any site can embed (`/leaderboard/embed.js`). Members appear by the name they set on `/invite`, else as "Maker of <their best listing>"; never by email.
 
 **Browse and search.** A search box in the header of every page (press `/`; it suggests launches as you type) opens `/search`: a facet rail in the style of [r4ck.dev](https://r4ck.dev) with counts for category, tags, when it launched, what it has (✓ verified, claimed, video, llms.txt, OpenSite/OpenProfile/OpenStack/OpenSaaS), what it is built with (OpenStack.md) and maker, plus sort and active-filter chips. Values in one facet are OR'd, facets are AND'd, and each facet counts as if only it changed. Tags are what the page or the maker said; categories are a fixed set of twenty-one read from a listing's tags, name, tagline and description (`src/browse.ts`), so every launch is filed even with no tags. `/c/<category>` and `/t/<tag>` are indexable pages for one filter; the same query is `GET /api/v1/search` (products + facets), `GET /api/v1/categories`, `builtindie search … --category ai --has verified --facets`, and the MCP `search` / `list_categories` tools.
@@ -44,6 +51,8 @@ BUILTINDIE_KEY=bi_… builtindie claim linear   # prints your badge and the TXT
 BUILTINDIE_KEY=bi_… builtindie edit linear --tagline "…"
 BUILTINDIE_KEY=bi_… builtindie invite          # your invite link and free Featured credits
 BUILTINDIE_KEY=bi_… builtindie credit linear   # spend one: Featured for a week
+BUILTINDIE_KEY=bi_… builtindie redeem CR-…      # a credit code: Featured days
+BUILTINDIE_KEY=bi_… builtindie invite-code     # one of your 3 single-use invites
 BUILTINDIE_KEY=bi_… builtindie feature linear  # or pay: a CoinPay checkout link (any coin or PayPal)
 
 claude mcp add builtindie -- bunx @profullstack/builtindie mcp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/builtindie",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "built.indie: launch your indie product with one URL. We fetch the logo, screenshots, videos, llms.txt, OpenSite and OpenProfile from your homepage; people upvote; you get a badge. Web (PWA), API, CLI, TUI and MCP.",
   "license": "MIT",
   "type": "module",
@@ -23,18 +23,24 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@profullstack/affiliates": "0.1.0",
     "@profullstack/coinpay-onboard": "0.2.0",
     "@profullstack/footer": "latest",
-    "@profullstack/hqtui": "^0.10.3",
+    "@profullstack/hqtui": "^0.11.1",
     "@profullstack/leaderboard": "^0.3.1",
     "@profullstack/openprofile": "^0.2.0",
+    "@profullstack/profile": "0.1.6",
+    "@profullstack/redeem-credits": "0.1.0",
     "@profullstack/stack": "0.5.0",
-    "hono": "^4.13.13",
-    "zod": "^3.25.0"
+    "hono": "^4.13.14",
+    "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.3",
+    "@types/bun": "^1.4.4",
     "typescript": "^7.0.2"
+  },
+  "overrides": {
+    "zod": "^4.6.7"
   }
 }

package/public/style.css

@@ -257,3 +257,8 @@ table.earn td.pts { color: var(--gold); font-weight: 700; white-space: nowrap; }
 @media (max-width: 640px) { table.earn td:nth-child(3) { display: block; padding-top: 0; border: 0; } }
 .or { text-align: center; margin: .6rem 0; }
 .coinpay-btn { display: flex; justify-content: center; gap: .4rem; }
+
+/* The shared profile fields (@profullstack/profile renderProfileFields), made to read like the email box beside them. */
+.pfs-profile { border: 0; margin: 0; padding: 0; min-width: 0; }
+.pfs-profile__optional { color: var(--muted); font-weight: 400; }
+.pfs-profile__error { color: var(--fail); font-size: 0.85rem; margin: 0.25rem 0 0; }

package/src/auth.ts

@@ -50,7 +50,7 @@ export class Auth {
   constructor(private store: Store, private mailer: Mailer, private now = () => Date.now()) {}
 
   /** Always resolves the same way, so nobody learns who has an account. */
-  async sendLink(emailInput: string, next: string | null, base: string, ref: string | null = null): Promise<boolean> {
+  async sendLink(emailInput: string, next: string | null, base: string, ref: string | null = null, profile: object | null = null): Promise<boolean> {
     const email = validEmail(emailInput)
     if (!email) return false
     const db = this.store.db
@@ -58,7 +58,7 @@ export class Auth {
     if (recent >= 5) return true
     const token = randomBytes(24).toString('base64url')
     // The invite code rides in the link, so it counts even when the mail opens in another browser.
-    db.query('INSERT INTO magic_links (token_hash, email, next, ref, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)').run(hashKey(token), email, safeNext(next), ref ? String(ref).slice(0, 32) : null, this.now(), this.now() + LINK_MINUTES * 60_000)
+    db.query('INSERT INTO magic_links (token_hash, email, next, ref, created_at, expires_at, profile) VALUES (?, ?, ?, ?, ?, ?, ?)').run(hashKey(token), email, safeNext(next), ref ? String(ref).slice(0, 80) : null, this.now(), this.now() + LINK_MINUTES * 60_000, profile ? JSON.stringify(profile) : null)
     const url = `${base}/auth/verify?token=${token}`
     const text = `Sign in to built.indie:\n\n${url}\n\nThe link works once, for ${LINK_MINUTES} minutes. If you did not ask for it, ignore this email.`
     const html = `<p>Sign in to <strong>built.indie</strong>:</p><p><a href="${url}" style="display:inline-block;padding:10px 18px;background:#ff5c39;color:#fff;border-radius:8px;text-decoration:none;font-weight:700">Sign in</a></p><p style="color:#666;font-size:13px">Or open ${url}<br>The link works once, for ${LINK_MINUTES} minutes. If you did not ask for it, ignore this email.</p>`
@@ -70,15 +70,15 @@ export class Auth {
     return true
   }
 
-  /** One use, then it is gone. Returns the user (made on first sign-in, `created`), where to go, and the invite code it carried. */
-  consumeLink(token: string): { user: User; next: string | null; created: boolean; ref: string | null } | null {
+  /** One use, then it is gone. Returns the user (made on first sign-in, `created`), where to go, the invite code it carried, and the signup form's profile fields. */
+  consumeLink(token: string): { user: User; next: string | null; created: boolean; ref: string | null; profile: Record<string, unknown> | null } | null {
     const hash = hashKey(String(token))
     const db = this.store.db
-    const row = db.query('SELECT email, next, ref, expires_at FROM magic_links WHERE token_hash = ?').get(hash) as { email: string; next: string | null; ref: string | null; expires_at: number } | null
+    const row = db.query('SELECT email, next, ref, expires_at, profile FROM magic_links WHERE token_hash = ?').get(hash) as { email: string; next: string | null; ref: string | null; expires_at: number; profile: string | null } | null
     db.query('DELETE FROM magic_links WHERE token_hash = ? OR expires_at < ?').run(hash, this.now())
     if (!row || row.expires_at < this.now()) return null
     const created = !this.store.userByEmail(row.email)
-    return { user: this.store.findOrCreateUser(row.email), next: row.next, created, ref: row.ref }
+    return { user: this.store.findOrCreateUser(row.email), next: row.next, created, ref: row.ref, profile: row.profile ? JSON.parse(row.profile) : null }
   }
 
   createSession(userId: string): string {

package/src/cli.ts

@@ -14,6 +14,9 @@
  *   builtindie me                      your launches, BUILTINDIE_KEY
  *   builtindie invite                  your invite link and free Featured credits, BUILTINDIE_KEY
  *   builtindie credit <slug>           spend a credit: feature a listing you own, BUILTINDIE_KEY
+ *   builtindie redeem <code>           a credit code: Featured days to your balance, BUILTINDIE_KEY
+ *   builtindie invite-code [note]      one of your 3 single-use invite codes, BUILTINDIE_KEY
+ *   builtindie feature-days <slug> <n> spend Featured days on a listing you own, BUILTINDIE_KEY
  *   builtindie feature <slug>          pay to feature it: a CoinPay checkout link (any coin or PayPal), BUILTINDIE_KEY
  *   builtindie karma                   your karma, history, next free Featured week, BUILTINDIE_KEY
  *   builtindie leaderboard [karma|invites] [--period week|month|all]
@@ -49,6 +52,9 @@ export const HELP = `builtindie ${VERSION}: launch your indie product with one U
   builtindie me                       your launches
   builtindie invite                   your invite link; each maker it brings in who launches = a free Featured week
   builtindie credit <slug>            spend a credit to feature a listing you own
+  builtindie redeem <code>            redeem a credit code: Featured days to your balance
+  builtindie invite-code [note]       make one of your 3 single-use invite codes (both get Featured days)
+  builtindie feature-days <slug> <n>  spend n Featured days on a listing you own
   builtindie feature <slug> [--email you@x]  pay to feature it: prints a CoinPay checkout link (any coin or PayPal)
   builtindie karma                    your karma, history and how far to the next free Featured week
   builtindie leaderboard [karma|invites] [--period week|month|all]
@@ -243,6 +249,21 @@ export async function main(argv = process.argv.slice(2), out: Out = console, cli
         show(r, `${rest[0]} is Featured until ${r.featured_until.slice(0, 10)} ★  (${r.credits} credit${r.credits === 1 ? '' : 's'} left)`)
         return 0
       }
+      case 'redeem': {
+        const r = await client.redeem(rest[0] ?? '')
+        show(r, `${r.message}\nFeatured days: ${r.featured_days}${r.featured_days ? '  (use them: builtindie feature-days <slug> <n>)' : ''}`)
+        return 0
+      }
+      case 'invite-code': {
+        const r = await client.inviteCode(rest.join(' '))
+        show(r, `Your invite (works once, for someone new; you both get ${r.bonus_days} Featured days):\n${r.link}\n${r.left} left`)
+        return 0
+      }
+      case 'feature-days': {
+        const r = await client.featureDays(rest[0] ?? '', Number(rest[1] ?? 0))
+        show(r, `${rest[0]} is Featured until ${r.featured_until.slice(0, 10)} ★  (${r.featured_days} day${r.featured_days === 1 ? '' : 's'} left)`)
+        return 0
+      }
       case 'feature': {
         const r = await client.feature(rest[0] ?? '', str('email'))
         show(r, `Pay $${r.usd} for ${r.days} days Featured (${r.methods.join(', ')}):\n${r.checkout_url}`)

package/src/client.ts

@@ -38,7 +38,7 @@ export type ApiProduct = {
   award?: { day: string; rank: number } | null
 }
 
-export type Invites = { link: string; code: string; invited: number; launched: number; credits: number; karma_credits?: number; used: number; feature_days: number }
+export type Invites = { link: string; code: string; invited: number; launched: number; credits: number; karma_credits?: number; used: number; feature_days: number; invite_codes?: { quota: { total: number; used: number; left: number }; bonus_days: number; invites: { id: string; note: string; created_at: string; expires_at: string | null; used: boolean; used_at: string | null }[] } }
 
 export type KarmaInfo = { total: number; week: number; per_credit: number; next_credit_in: number; credits: { earned: number; used: number }; events: { action: string; label: string; ref: string; points: number; at: string }[]; how_to_earn: { action: string; points: number; rule: string }[]; leaderboard: string }
 export type BoardRows = { board: string; period: string; total: number; rows: { rank: number | null; id: string; name: string; value: number; badges: { emoji: string; label: string }[]; url: string }[]; web: string }
@@ -143,6 +143,21 @@ export class BuiltIndieClient {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/credit`, {}, this.needKey())
   }
 
+  /** Redeem a credit code: Featured days added to your balance. */
+  redeem(code: string): Promise<{ ok: boolean; message: string; featured_days: number }> {
+    return this.call('POST', '/api/v1/redeem', { code }, this.needKey())
+  }
+
+  /** Make one of your scarce single-use invite codes; the link is shown once. */
+  inviteCode(note = ''): Promise<{ link: string; code: string; expires_at: string | null; left: number; bonus_days: number }> {
+    return this.call('POST', '/api/v1/invites', { note }, this.needKey())
+  }
+
+  /** Spend Featured days from your balance on a listing you own. */
+  featureDays(slug: string, days: number): Promise<{ featured_until: string; featured_days: number }> {
+    return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/feature-days`, { days }, this.needKey())
+  }
+
   /** Pay to feature a listing you own: opens a CoinPay checkout session (any coin or PayPal); send the buyer to checkout_url. */
   feature(slug: string, email?: string): Promise<{ checkout_url: string; checkout_session_id: string; methods: string[]; payment: string; usd: number; days: number }> {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/feature`, email ? { email } : {}, this.needKey())

package/src/db.ts

@@ -257,6 +257,8 @@ export class Store {
     const has = (table: string, col: string) => (this.db.query(`PRAGMA table_info(${table})`).all() as { name: string }[]).some((c) => c.name === col)
     if (!has('users', 'display_name')) this.db.exec('ALTER TABLE users ADD COLUMN display_name TEXT')
     if (!has('magic_links', 'ref')) this.db.exec('ALTER TABLE magic_links ADD COLUMN ref TEXT')
+    // The signup form's profile fields ride on the link until it is spent (profile.ts saves them).
+    if (!has('magic_links', 'profile')) this.db.exec('ALTER TABLE magic_links ADD COLUMN profile TEXT')
     // Hosted checkout sessions (0.5.0): the session is how CoinPay's webhook finds the row.
     for (const col of ['checkout_session_id', 'customer_email', 'account_id', 'payment_id']) if (!has('payments', col)) this.db.exec(`ALTER TABLE payments ADD COLUMN ${col} TEXT`)
     // Karma (0.6.0): who cast a vote, when they were signed in; review totals beside the vote count.
@@ -479,7 +481,7 @@ export class Store {
         .run(productId, now, userId)
       // No invite credit left: a karma credit is the same free week.
       if (!r.changes && !this.db.query('UPDATE karma_credits SET redeemed_product = ?, redeemed_at = ? WHERE rowid = (SELECT rowid FROM karma_credits WHERE user_id = ? AND redeemed_at IS NULL ORDER BY milestone LIMIT 1)').run(productId, now, userId).changes) return false
-      this.db.query('UPDATE products SET featured_until = MAX(COALESCE(featured_until, 0), ?) + ? WHERE id = ?').run(now, days * 86400_000, productId)
+      this.extendFeatured(productId, days, now)
       return true
     })()
   }
@@ -788,11 +790,16 @@ export class Store {
     return r ? { ref: r.ref, productId: r.product_id, days: r.days, status: r.status } : null
   }
 
+  /** The one way a listing gets Featured time: paid weeks, invite and karma credits, and redeemed Featured days. */
+  extendFeatured(productId: string, days: number, now = Date.now()): void {
+    this.db.query('UPDATE products SET featured_until = MAX(COALESCE(featured_until, 0), ?) + ? WHERE id = ?').run(now, days * 86400_000, productId)
+  }
+
   /** Mark a payment settled and extend the product's featured time, exactly once per payment. */
   settle(ref: string, now = Date.now()): boolean {
     const r: any = this.db.query("UPDATE payments SET status = 'paid', updated_at = ? WHERE ref = ? AND status != 'paid' RETURNING product_id, days").get(now, ref)
     if (!r) return false
-    this.db.query('UPDATE products SET featured_until = MAX(COALESCE(featured_until, 0), ?) + ? WHERE id = ?').run(now, r.days * 86400_000, r.product_id)
+    this.extendFeatured(r.product_id, r.days, now)
     return true
   }
 

package/src/html.ts

@@ -12,6 +12,7 @@ import { pitFooter } from './pit-footer.js'
 import { RING_PLACEHOLDER } from './ring.js'
 import { ringFooter, ringFooterOptions, setRingFooterOptions } from './ring-footer.js'
 import { icon, SOCIAL_ICONS } from './icons.js'
+import { COLUMNS as PROFILE_COLUMNS, renderProfileFields } from '@profullstack/profile'
 
 export const REPO = 'https://github.com/moshcoder/built.indie'
 
@@ -452,7 +453,7 @@ function pricingHtml(p: Product): string {
 
 const SOCIAL_LABELS: Record<string, string> = { x: 'X', github: 'GitHub', linkedin: 'LinkedIn', discord: 'Discord', youtube: 'YouTube', bluesky: 'Bluesky', instagram: 'Instagram', tiktok: 'TikTok', reddit: 'Reddit', telegram: 'Telegram', producthunt: 'Product Hunt', appstore: 'App Store', playstore: 'Google Play', chrome: 'Chrome Web Store' }
 
-export function productPage(ctx: Ctx, d: { comments?: CommentView[]; reviews?: ReviewView[]; myReview?: Review | null; selfListing?: boolean; error?: string; product: Product; award: { day: string; rank: number } | null; maker: Maker | null; featuredOk?: boolean; featuredCredit?: boolean; launched?: boolean; canEdit?: boolean; credits?: number; buyerEmail?: string; featureUsd: number; featureDays: number; payments: boolean }): string {
+export function productPage(ctx: Ctx, d: { comments?: CommentView[]; reviews?: ReviewView[]; myReview?: Review | null; selfListing?: boolean; error?: string; product: Product; award: { day: string; rank: number } | null; maker: Maker | null; featuredOk?: boolean; featuredCredit?: boolean; featuredDaysUsed?: boolean; launched?: boolean; canEdit?: boolean; credits?: number; daysBalance?: number; buyerEmail?: string; featureUsd: number; featureDays: number; payments: boolean }): string {
   const p = d.product
   const shots = [p.screenshot, ...p.images, p.ogImage].filter((f): f is string => Boolean(f))
   const rel = p.verifiedAt ? 'noopener' : 'noopener nofollow ugc'
@@ -470,6 +471,7 @@ export function productPage(ctx: Ctx, d: { comments?: CommentView[]; reviews?: R
     body: `${d.error ? `<p class="note error" role="alert">${esc(d.error)}</p>` : ''}${d.launched && live ? `<div class="note launched"><b>🚀 ${esc(p.name)} is live.</b> Today’s board resets at midnight UTC: share it now. ${p.ownerId ? '' : `Is it yours? <a href="/p/${esc(p.slug)}/claim">Claim it</a> with your badge (or a DNS record) to edit it and get the ✓.`}</div>` : ''}
 ${d.featuredOk ? '<p class="note">Thanks! Your payment is on its way; the Featured spot starts the moment CoinPay confirms it.</p>' : ''}
 ${d.featuredCredit ? `<p class="note launched">★ Featured for ${d.featureDays} more days with an invite credit. <a href="/invite">Invite another maker</a> to earn the next one.</p>` : ''}
+${d.featuredDaysUsed ? `<p class="note launched">★ Featured with your Featured days${p.featuredUntil ? ` until ${new Date(p.featuredUntil).toISOString().slice(0, 10)}` : ''}.</p>` : ''}
 ${!live ? `<p class="note">${p.status === 'draft' ? 'Draft: only people with the edit link see this.' : 'Taken down.'}</p>` : ''}
 <section class="product-head">
   ${logoImg(p, 72)}
@@ -505,9 +507,10 @@ ${commentsHtml(ctx, p, d.comments ?? [])}
   <pre><code>${esc(badgeSnippet(ctx.origin, p))}</code></pre>
   <div class="row"><button class="chip" data-copy="${esc(badgeSnippet(ctx.origin, p))}">Copy badge HTML</button><form method="post" action="/p/${esc(p.slug)}/verify"><button class="chip">I added it: check</button></form></div>
 </details>
-${d.payments || d.canEdit ? `<details class="card" id="feature"${d.canEdit && d.credits ? ' open' : ''}><summary>Feature it: ${esc(`$${d.featureUsd}`)} for ${d.featureDays} days, or free with an invite</summary>
+${d.payments || d.canEdit ? `<details class="card" id="feature"${d.canEdit && (d.credits || d.daysBalance) ? ' open' : ''}><summary>Feature it: ${esc(`$${d.featureUsd}`)} for ${d.featureDays} days, or free with an invite</summary>
   <p class="muted">Pinned above today’s board on the homepage for ${d.featureDays} days.</p>
   ${d.canEdit && d.credits ? `<form method="post" action="/p/${esc(p.slug)}/credit" class="row"><button class="btn">${icon('star')} Use a free invite credit</button><span class="muted small">${d.credits} left</span></form>` : `<p class="muted small">Free: ${esc(inviteOffer(d.featureDays, d.featureUsd))} <a href="/invite">Get your invite link</a>.</p>`}
+  ${d.canEdit && d.daysBalance ? featureDaysForm(p, d.daysBalance) : ''}
   ${d.payments ? `<form method="post" action="/p/${esc(p.slug)}/feature" class="row"><label class="sr" for="feature-email">Your email</label><input id="feature-email" name="email" type="email" required autocomplete="email" placeholder="you@example.com" value="${esc(d.buyerEmail ?? '')}"><button class="btn${d.canEdit && d.credits ? ' ghost' : ''}">Pay $${esc(d.featureUsd)}</button></form><p class="muted small">You pick any coin or PayPal on CoinPay's checkout page. The receipt goes to your email.</p>` : ''}
 </details>` : ''}` : ''}`,
   })
@@ -670,22 +673,30 @@ ${d.result && !d.result.ok ? `<p class="note error" role="alert">We did not find
   })
 }
 
-export function loginPage(ctx: Ctx, d: { next: string | null; sent?: boolean; error?: string; email?: string; invitedBy?: string | null }): string {
+/** The shared profile fields (@profullstack/profile) beside the form's own email box. */
+const PROFILE_FIELDS = PROFILE_COLUMNS.filter((f) => f !== 'email')
+
+export function loginPage(ctx: Ctx, d: { next: string | null; sent?: boolean; error?: string; email?: string; invitedBy?: string | null; signup?: boolean; values?: Record<string, string>; errors?: Record<string, string> }): string {
+  const signup = Boolean(d.signup) && !d.sent
   return layout({
     ctx,
-    title: 'Sign in · built.indie',
-    description: 'Sign in with a link by email.',
-    path: '/login',
+    title: signup ? 'Create your account · built.indie' : 'Sign in · built.indie',
+    description: signup ? 'Create a built.indie account with a link by email.' : 'Sign in with a link by email.',
+    path: signup ? '/signup' : '/login',
     noindex: true,
-    body: `<section class="hero narrow"><h1>${d.sent ? 'Check your email' : 'Sign in'}</h1>
-${d.sent ? '<p class="lede">If that address can receive mail, a sign-in link is on its way. It works once, for 20 minutes.</p>' : `<p class="lede">No password. We email you a link; a new address makes an account. You need one only to claim and edit a listing. Launching is free and needs nothing.</p>
+    body: `<section class="hero narrow"><h1>${d.sent ? 'Check your email' : signup ? 'Create your account' : 'Sign in'}</h1>
+${d.sent ? '<p class="lede">If that address can receive mail, a sign-in link is on its way. It works once, for 20 minutes.</p>' : `<p class="lede">No password. We email you a link${signup ? '' : '; a new address makes an account'}. You need one only to claim and edit a listing. Launching is free and needs nothing.</p>
 ${d.invitedBy ? `<p class="note launched">${esc(d.invitedBy)} invited you. Sign up here, then launch your product: it is free, and it earns them a Featured week.</p>` : ''}
 ${d.error ? `<p class="note error" role="alert">${esc(d.error)}</p>` : ''}
 <form method="post" action="/login" class="card">
   <input type="hidden" name="next" value="${esc(d.next ?? '')}">
+  ${signup ? '<input type="hidden" name="mode" value="signup">' : ''}
   <label for="email">Email</label><input id="email" name="email" type="email" autocomplete="email" required value="${esc(d.email ?? '')}">
-  <p><button class="btn wide">Email me a link</button></p>
+  ${signup ? renderProfileFields({ fields: PROFILE_FIELDS, values: d.values, errors: d.errors }) : ''}
+  <p><button class="btn wide">${signup ? 'Create account' : 'Email me a link'}</button></p>
 </form>
+<p class="muted small">${signup ? `Already a member? <a href="/login${d.next ? `?next=${encodeURIComponent(d.next)}` : ''}">Sign in</a>` : `New here? <a href="/signup${d.next ? `?next=${encodeURIComponent(d.next)}` : ''}">Create an account</a>`}</p>
+${signup ? '<script src="/vendor-profile.js" defer></script>' : ''}
 ${ctx.coinpay ? `<p class="or muted small">or</p>${coinpayButton(d.next)}<p class="muted small">One CoinPay account signs you in here and on the rest of the network.</p>` : ''}`}</section>`,
   })
 }
@@ -701,7 +712,23 @@ ${k.events.length ? `<h3 class="mini-h">History</h3><ol class="ledger">${k.event
 </div>`
 }
 
-export function mePage(ctx: Ctx, d: { user: User; products: Product[]; apiKey?: string; invite: InviteStats; karma?: KarmaSummary; howToEarn?: { action: string; points: number; rule: string }[]; featureDays?: number; coinpay?: { name: string | null } | null; emailless?: boolean; coinpayNote?: string | null }): string {
+/** Spend Featured days from the balance on one listing. */
+function featureDaysForm(p: Product, balance: number): string {
+  return `<form method="post" action="/p/${esc(p.slug)}/feature-days" class="row"><label class="sr" for="days-${esc(p.slug)}">Days</label><input id="days-${esc(p.slug)}" name="days" type="number" min="1" max="${balance}" value="${balance}" inputmode="numeric" style="inline-size:6em"><button class="chip">${icon('star')} Feature ${esc(p.name)} with your days</button><span class="muted small">${balance} day${balance === 1 ? '' : 's'} left</span></form>`
+}
+
+/** "Have a code?": redeem a credit code, see the Featured days it added, spend them on a listing. */
+function featuredDaysCard(d: { products: Product[]; daysBalance?: number; redeemNote?: string; redeemError?: boolean }): string {
+  const balance = d.daysBalance ?? 0
+  const live = d.products.filter((p) => p.status === 'live')
+  return `<div class="card" id="redeem"><h2>${icon('star')} Featured days <span class="karma-total">${balance}</span></h2>
+${d.redeemNote ? `<p class="note${d.redeemError ? ' error' : ' launched'}" role="status">${esc(d.redeemNote)}</p>` : ''}
+<form method="post" action="/me/redeem" class="row"><label class="sr" for="redeem-code">Credit code</label><input id="redeem-code" name="code" required placeholder="Have a code? CR-XXXX-XXXX-XXXX-XXXX" autocomplete="off" spellcheck="false"><button class="chip">Redeem</button></form>
+<p class="muted small">A code or an invite adds days to pin any live listing you own on the homepage, the same Featured slot a paid week buys.</p>
+${balance ? (live.length ? live.map((p) => featureDaysForm(p, balance)).join('') : '<p class="muted">You have no live listing yet. <a href="/submit">Launch one</a>, then come back to feature it.</p>') : ''}</div>`
+}
+
+export function mePage(ctx: Ctx, d: { user: User; products: Product[]; apiKey?: string; invite: InviteStats; daysBalance?: number; redeemNote?: string; redeemError?: boolean; karma?: KarmaSummary; howToEarn?: { action: string; points: number; rule: string }[]; featureDays?: number; coinpay?: { name: string | null } | null; emailless?: boolean; coinpayNote?: string | null; profile?: object | null; detailsNote?: string | null; detailsError?: boolean; detailsErrors?: Record<string, string> }): string {
   return layout({
     ctx,
     title: 'Your launches · built.indie',
@@ -712,9 +739,13 @@ export function mePage(ctx: Ctx, d: { user: User; products: Product[]; apiKey?:
 ${d.coinpayNote ? `<p class="note">${esc(d.coinpayNote)}</p>` : ''}
 <p class="muted">Signed in ${d.emailless ? `with CoinPay${d.coinpay?.name ? ` as ${esc(d.coinpay.name)}` : ''}` : `as ${esc(d.user.email)}`}. <form class="inline" method="post" action="/logout"><button class="linkish">Sign out</button></form></p>
 ${d.products.length ? `<ol class="board">${d.products.map((p) => `<li class="row-item"><a class="row-main" href="/p/${esc(p.slug)}">${logoImg(p)}<span class="row-text"><b>${esc(p.name)}</b><span class="muted">${p.status === 'draft' ? 'draft' : `▲ ${p.votes}`} · ${p.ownerId === d.user.id ? 'claimed ✓' : 'submitted by you, not claimed'}</span></span></a><a class="chip" href="/p/${esc(p.slug)}/edit">Edit</a>${p.ownerId === d.user.id ? '' : `<a class="chip" href="/p/${esc(p.slug)}/claim">Claim</a>`}</li>`).join('')}</ol>` : '<p class="empty">Nothing yet. <a href="/submit">Launch something</a>, or open a listing that is yours and claim it.</p>'}
+${featuredDaysCard(d)}
 ${d.karma ? karmaCard(d.karma, d.howToEarn ?? [], d.featureDays ?? 7) : ''}
 <div class="card"><h2>${icon('star')} Invites</h2><p class="muted">${d.invite.invited} joined through your link · ${d.invite.launched} launched · <b>${d.invite.credits}</b> free Featured week${d.invite.credits === 1 ? '' : 's'} to use${d.invite.karmaCredits ? ` (${d.invite.karmaCredits} from karma)` : ''}.</p><p><a class="chip" href="/invite">Your invite link and credits</a></p></div>
 ${ctx.coinpay || d.coinpay ? `<div class="card" id="signin"><h2>Sign in with CoinPay</h2>${d.coinpay ? `<p class="muted">Connected${d.coinpay.name ? ` (${esc(d.coinpay.name)})` : ''}: your CoinPay account signs you in here.</p>` : `<p class="muted">Connect your CoinPay account to sign in with it, here and across the network. We link the account itself, never by email.</p>${coinpayButton('/me', 'Connect CoinPay')}`}</div>` : ''}
+<div class="card" id="details"><h2>Your details</h2><p class="muted small">Private to your account, never shown on a public page.</p>
+${d.detailsNote ? `<p class="note${d.detailsError ? ' error' : ''}" role="status">${esc(d.detailsNote)}</p>` : ''}
+<form method="post" action="/me/profile">${renderProfileFields({ fields: PROFILE_FIELDS, values: (d.profile ?? {}) as Record<string, string | null>, errors: d.detailsErrors, idPrefix: 'details-' })}<p><button class="chip">Save details</button></p></form></div>
 <div class="card" id="api"><h2>API key</h2>
 ${d.apiKey ? `<p class="note"><b>Copy it now</b>, we show it once. Making a new one retires this one.</p><div class="address"><code>${esc(d.apiKey)}</code><button class="copy" data-copy="${esc(d.apiKey)}">Copy</button></div><pre>export BUILTINDIE_KEY=${esc(d.apiKey)}</pre>` : '<p class="muted">For the CLI, the TUI and the MCP server: edit and claim from the terminal or an agent.</p>'}
 <form method="post" action="/me/key"><button class="chip">${d.apiKey ? 'Make another' : 'Make an API key'}</button></form></div>`,
@@ -767,6 +798,9 @@ curl -X POST ${o}/api/v1/products/&lt;slug&gt;/refetch -H 'authorization: Bearer
 curl -X POST ${o}/api/v1/products/&lt;slug&gt;/publish -H 'authorization: Bearer bi_…'
 curl ${o}/api/v1/invites -H 'authorization: Bearer bi_…'                 # your invite link and credits
 curl -X POST ${o}/api/v1/products/&lt;slug&gt;/credit -H 'authorization: Bearer bi_…'   # spend one: Featured for a week
+curl -X POST ${o}/api/v1/redeem -H 'authorization: Bearer bi_…' -d '{"code":"CR-…"}'   # a credit code: Featured days to your balance
+curl -X POST ${o}/api/v1/products/&lt;slug&gt;/feature-days -H 'authorization: Bearer bi_…' -d '{"days":3}'   # spend Featured days on a listing
+curl -X POST ${o}/api/v1/invites -H 'authorization: Bearer bi_…' -d '{"note":"for Ada"}'   # one of your 3 single-use invite codes (both get Featured days)
 curl -X POST ${o}/api/v1/products/&lt;slug&gt;/feature -H 'authorization: Bearer bi_…' -d '{"email":"you@…"}'   # pay: a CoinPay checkout_url (any coin or PayPal)
 curl ${o}/leaderboard/invites.json?period=week                       # top inviters (all|week|month)
 curl '${o}/api/v1/leaderboard?board=karma&amp;period=week'             # top karma (board karma|invites)
@@ -809,7 +843,24 @@ bunx @profullstack/builtindie preview any.site --json</pre></div>
 }
 
 /** Your invite link, what it has earned, and the listings a credit can feature. */
-export function invitePage(ctx: Ctx, d: { featureDays: number; featureUsd: number; inviters: InviterRow[]; me?: { link: string; stats: InviteStats; name: string; displayName: string | null; listings: Product[]; flash?: string; error?: string } }): string {
+export type InviteCodes = {
+  quota: { total: number; used: number; left: number }
+  invites: { id: string; note: string; createdAt: number; expiresAt: number | null; usedAt: number | null; revokedAt?: number | null }[]
+  bonusDays: number
+  newLink?: string
+}
+
+/** Scarce single-use invite codes: a few each, and both people get Featured days when one is used. */
+function inviteCodesCard(c: InviteCodes): string {
+  const state = (i: InviteCodes['invites'][number]) => (i.usedAt ? `used ${new Date(i.usedAt).toISOString().slice(0, 10)}` : i.revokedAt ? 'withdrawn' : i.expiresAt && i.expiresAt < Date.now() ? 'expired' : `open${i.expiresAt ? ` until ${new Date(i.expiresAt).toISOString().slice(0, 10)}` : ''}`)
+  return `<div class="card" id="codes"><h2>${icon('mail')} Invite codes <span class="karma-total">${c.quota.left}/${c.quota.total}</span></h2>
+<p class="muted">Your link above is open to anyone. These are not: you get ${c.quota.total}, each works once, for someone new. When they sign up with it, you both get <b>${c.bonusDays} Featured days</b>.</p>
+${c.newLink ? `<p class="note launched">Your new invite, shown once. Send it to one person:</p><div class="address"><code>${esc(c.newLink)}</code><button class="copy" data-copy="${esc(c.newLink)}">Copy</button></div>` : ''}
+${c.quota.left > 0 ? `<form method="post" action="/invite/code" class="row"><label class="sr" for="invite-note">Who is it for?</label><input id="invite-note" name="note" maxlength="80" placeholder="Who is it for? (only you see this)"><button class="chip">Make an invite code</button></form>` : '<p class="muted small">All used. Thank you for bringing people in.</p>'}
+${c.invites.length ? `<ol class="ledger">${c.invites.map((i) => `<li>${esc(i.note || 'invite')} <span class="muted small">${esc(state(i))}</span></li>`).join('')}</ol>` : ''}</div>`
+}
+
+export function invitePage(ctx: Ctx, d: { featureDays: number; featureUsd: number; inviters: InviterRow[]; me?: { link: string; stats: InviteStats; name: string; displayName: string | null; listings: Product[]; codes?: InviteCodes; flash?: string; error?: string } }): string {
   const m = d.me
   const text = 'I launch my indie products on built.indie: one URL and it pulls in the logo, screenshots and story. Launch yours free:'
   const shares: [string, string, string][] = m
@@ -846,6 +897,7 @@ ${
       }</div>`
     : ''
 }
+${m.codes ? inviteCodesCard(m.codes) : ''}
 <div class="card"><h2>Your name on the board</h2><p class="muted small">Shown as <b>${esc(m.name)}</b>. We never show your email.</p>
 <form method="post" action="/invite/name" class="row"><label class="sr" for="displayName">Display name</label><input id="displayName" name="displayName" maxlength="40" placeholder="Your name or handle" value="${esc(m.displayName ?? '')}"><button class="chip">Save</button></form></div>`
     : '<p class="center"><a class="btn" href="/login?next=/invite">Sign in to get your invite link</a></p>'
@@ -862,7 +914,20 @@ ${d.inviters.length ? invitersList(d.inviters) : '<p class="empty">Nobody yet. O
 }
 
 /** Where an invite link lands: who invited you, and one step to launch. */
-export function inviteLanding(ctx: Ctx, d: { inviter: string }): string {
+export function inviteLanding(ctx: Ctx, d: { inviter: string | null; bonusDays?: number }): string {
+  // A scarce invite code: nobody is named until it is used, and both people get Featured days.
+  if (!d.inviter)
+    return layout({
+      ctx,
+      title: "You're invited to built.indie",
+      description: 'Launch your indie product with one URL. We fetch the logo, screenshots and story; people upvote; you get a badge. Free.',
+      path: '/invite',
+      noindex: true,
+      body: `<section class="hero"><h1>You're invited.</h1>
+<p class="lede">Someone on built.indie spent one of their few invites on you. Sign up and you both get <b>${d.bonusDays ?? 0} Featured days</b>: your launch pinned on the homepage.</p>
+${ctx.user ? '<p class="muted">You are already signed in, so this invite is for someone new. Pass it on.</p>' : `<p><a class="btn" href="/signup?next=/me">${icon('rocket')} Accept: sign up</a></p><p class="muted small">Already a member? Invites are for new members; your days come from <a href="/me#redeem">codes</a> and your own invites.</p>`}
+</section>`,
+    })
   return layout({
     ctx,
     title: `${d.inviter} invited you to launch on built.indie`,

package/src/mcp.ts

@@ -97,6 +97,9 @@ export function createMcpServer(client = new BuiltIndieClient()): McpServer {
   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(

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/server.ts

@@ -22,10 +22,12 @@ import { HOW_TO_EARN, SHARE_NETWORKS } from './karma.js'
 import { IMAGE_TYPES, Media } from './media.js'
 import { startPitFooterRefresh } from './pit-footer.js'
 import { RING_PLACEHOLDER, ringBar, startRingRefresh, visitorOnMoshpit } from './ring.js'
-import { BuiltIndie, CLAIM_LABEL, CLAIM_PREFIX, InputError, type Config, type Edit } from './service.js'
+import { BuiltIndie, CLAIM_LABEL, CLAIM_PREFIX, INVITE_BONUS_DAYS, INVITES_PER_PERSON, InputError, type Config, type Edit } from './service.js'
 import { autofetch, FetchError } from './fetch.js'
 import { COINPAY_ERRORS, coinpayOAuthFromEnv, isPlaceholder, mountCoinPaySignin, PROVIDER as COINPAY, type CoinPayOAuth } from './coinpay-signin.js'
 import { VERSION } from './version.js'
+import { mountProfileRoutes, PROFILE_ENHANCE_SCRIPT, saveSignupProfile, validateProfile } from '@profullstack/profile'
+import { openProfiles } from './profile.js'
 
 export { VERSION }
 
@@ -36,7 +38,8 @@ const CSP = [
   "default-src 'none'",
   "style-src 'self' 'unsafe-inline'",
   "script-src 'self' https://crawlproof.com",
-  "img-src 'self' data:",
+  // The shared footer's badges: ours is same-origin, pwamart's is not.
+  "img-src 'self' data: https://pwamart.com",
   "connect-src 'self' https://crawlproof.com",
   'frame-src https://crawlproof.com https://www.youtube-nocookie.com https://player.vimeo.com https://www.loom.com',
   "manifest-src 'self'",
@@ -58,6 +61,10 @@ export type Deps = { service: BuiltIndie; auth: Auth; adminKey?: string; secureC
 
 /** The invite code from /i/<code>, kept until the visitor signs up (it also rides in the magic link). */
 const REF_COOKIE = 'bi_ref'
+/** A scarce single-use invite code (INV-XXXX-XXXX-XXXX) from /i/<code>, kept until the visitor signs up. */
+const INVITE_COOKIE = 'bi_invite'
+/** An @profullstack/affiliates invite code, as opposed to a member's open invite-link code. */
+const isInviteCode = (code: string | null | undefined): code is string => Boolean(code && /^INV-?[0-9A-Z]{4}-?[0-9A-Z]{4}-?[0-9A-Z]{4}$/i.test(code.trim()))
 type Env = { Bindings: { ip?: string } }
 
 /** A small fixed-window limit per key, in memory: enough to stop a loop, not a fortress. */
@@ -87,7 +94,10 @@ export function createApp(deps: Deps) {
   const voteLimit = new Limiter(60, 10 * 60_000)
   const commentLimit = new Limiter(10, 10 * 60_000)
   const shareLimit = new Limiter(60, 10 * 60_000)
+  const redeemLimit = new Limiter(10, 10 * 60_000)
   const origin = config.origin
+  // The shared profile fields (profile.ts); user_profiles is created as the app starts.
+  const profiles = openProfiles(store.db)
 
   const direct = (c: Context) => visitorOnMoshpit(SELF, c.req.header('host'), c.req.header('x-moshpit-name'))
   const ip = (c: Context<Env>) => c.env?.ip ?? 'local'
@@ -153,6 +163,14 @@ export function createApp(deps: Deps) {
     if (!c.res.headers.has('content-security-policy')) for (const [k, v] of Object.entries(SECURITY_HEADERS)) c.header(k, v)
   })
 
+  // ?ref=<a member's invite code> on any page is their invite link too: the same bi_ref cookie
+  // /i/<code> sets, first touch wins, so one sign-up is counted once, in one place (the invites table).
+  app.use('*', async (c, next) => {
+    const ref = c.req.query('ref')
+    if (ref && ref.length <= 40 && !getCookie(c, REF_COOKIE) && store.inviterOf(ref) && !sessionUser(c)) setCookie(c, REF_COOKIE, ref, { httpOnly: true, secure: secure(c), sameSite: 'Lax', path: '/', maxAge: 30 * 86400 })
+    await next()
+  })
+
   app.get('/health', (c) => c.json({ ok: true, version: VERSION }))
 
   // Static files.
@@ -242,7 +260,7 @@ export function createApp(deps: Deps) {
     const rv = (x: Review): ReviewView => ({ rating: x.rating, body: x.body, at: x.updatedAt, author: who(x.userId), karma: karmaOf.get(x.userId) ?? 0, mine: Boolean(me && x.userId === me.id) })
     return { comments: comments.map(cv), reviews: reviews.map(rv), myReview: me ? store.review(p.id, me.id) : null }
   }
-  const productView = (c: Context<Env>, p: Product, extra: { error?: string } = {}, status = 200) =>
+  const productView = async (c: Context<Env>, p: Product, extra: { error?: string } = {}, status = 200) =>
     page(
       c,
       productPage(ctxOf(c), {
@@ -257,6 +275,11 @@ export function createApp(deps: Deps) {
         maker: p.makerId ? store.maker(p.makerId) : null,
         featuredOk: c.req.query('featured') === '1',
         featuredCredit: c.req.query('featured') === 'credit',
+        featuredDaysUsed: c.req.query('featured') === 'days',
+        daysBalance: await (async () => {
+          const u = sessionUser(c)
+          return u && store.canEdit(p, u) ? service.featuredDays(u) : 0
+        })(),
         launched: c.req.query('launched') === '1',
         canEdit: store.canEdit(p, sessionUser(c)),
         credits: (() => {
@@ -354,12 +377,29 @@ export function createApp(deps: Deps) {
     return claimView(c, store.product(p.id)!, user, { result })
   })
 
+  /**
+   * A new member: a scarce invite code (bi_invite) gives both people Featured days, and an
+   * invite link (bi_ref, /i/<code> or ?ref=) makes their first live listing earn the inviter a credit.
+   * Both write the same invites row, first one wins, so a sign-up is counted once.
+   */
+  const joined = async (c: Context, user: User, carried: string | null) => {
+    const parts = (carried ?? '').split(' ').filter(Boolean)
+    const invite = parts.find(isInviteCode) ?? getCookie(c, INVITE_COOKIE)
+    const ref = parts.find((x) => !isInviteCode(x)) ?? getCookie(c, REF_COOKIE)
+    if (invite) await service.acceptInvite(invite, user).catch((e) => console.error(`[invite] accept failed: ${(e as Error).message}`))
+    if (ref) store.recordInvite(user.id, ref)
+    for (const name of [REF_COOKIE, INVITE_COOKIE]) deleteCookie(c, name, { path: '/' })
+  }
+
   // Signing in: an emailed link, which is also sign-up.
   const invitedBy = (c: Context) => {
     const inviter = store.inviterOf(getCookie(c, REF_COOKIE) ?? '')
     return inviter && !sessionUser(c) ? store.publicName(inviter) : null
   }
   app.get('/login', (c) => page(c, loginPage(ctxOf(c), { next: safeNext(c.req.query('next')), invitedBy: invitedBy(c), error: COINPAY_ERRORS[c.req.query('error') ?? ''] })))
+  // Creating an account asks for the shared profile fields; plain sign-in never does.
+  app.get('/signup', (c) => page(c, loginPage(ctxOf(c), { next: safeNext(c.req.query('next')), invitedBy: invitedBy(c), signup: true })))
+  app.get('/vendor-profile.js', (c) => c.body(PROFILE_ENHANCE_SCRIPT, 200, { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': 'public, max-age=86400' }))
   // Sign in with CoinPay (coinpay-signin.ts): /api/v1/coinpay/login and /callback.
   mountCoinPaySignin(app, {
     store,
@@ -369,26 +409,32 @@ export function createApp(deps: Deps) {
     secure,
     sessionUser,
     // A new member who came through an invite link counts, as with a magic link.
-    onNewMember: (c, user) => {
-      const ref = getCookie(c, REF_COOKIE)
-      if (ref) store.recordInvite(user.id, ref), deleteCookie(c, REF_COOKIE, { path: '/' })
-    },
+    onNewMember: (c, user) => void joined(c, user, null),
   })
   app.post('/login', async (c) => {
     const form = (await c.req.parseBody()) as Record<string, string>
     const next = safeNext(form.next)
-    if (!validEmail(form.email)) return page(c, loginPage(ctxOf(c), { next, error: 'That does not look like an email address.', email: form.email }), 400)
-    if (!crossSite(c) && readLimit.allow(`mail:${ip(c)}`)) await deps.auth.sendLink(form.email ?? '', next, here(c), getCookie(c, REF_COOKIE) ?? null)
+    const signup = form.mode === 'signup'
+    if (!validEmail(form.email)) return page(c, loginPage(ctxOf(c), { next, error: 'That does not look like an email address.', email: form.email, signup, values: form }), 400)
+    // The signup fields are checked before any link exists; they ride on the link and are saved on verify.
+    let profile: object | null = null
+    if (signup) {
+      const check = validateProfile(form)
+      if (!check.ok) return page(c, loginPage(ctxOf(c), { next, error: 'Some fields need fixing.', email: form.email, signup, values: form, errors: check.errors }), 400)
+      profile = check.profile
+    }
+    // The invites ride in the link (space-separated), so opening it in another browser still counts.
+    if (!crossSite(c) && readLimit.allow(`mail:${ip(c)}`)) await deps.auth.sendLink(form.email ?? '', next, here(c), [getCookie(c, INVITE_COOKIE), getCookie(c, REF_COOKIE)].filter(Boolean).join(' ') || null, profile)
     return page(c, loginPage(ctxOf(c), { next, sent: true }))
   })
-  app.get('/auth/verify', (c) => {
+  app.get('/auth/verify', async (c) => {
     const r = deps.auth.consumeLink(c.req.query('token') ?? '')
     if (!r) return page(c, messagePage(ctxOf(c), { title: 'That link is used up', message: 'Sign-in links work once, for 20 minutes. Ask for a new one.' }), 400)
     setCookie(c, SESSION_COOKIE, deps.auth.createSession(r.user.id), { httpOnly: true, secure: secure(c), sameSite: 'Lax', path: '/', maxAge: 90 * 86400 })
-    // A new member who came through an invite link: their first live listing will earn the inviter a credit.
-    const ref = r.ref ?? getCookie(c, REF_COOKIE)
-    if (r.created && ref) store.recordInvite(r.user.id, ref)
-    if (ref) deleteCookie(c, REF_COOKIE, { path: '/' })
+    if (r.created) await joined(c, r.user, r.ref ?? null)
+    else for (const name of [REF_COOKIE, INVITE_COOKIE]) deleteCookie(c, name, { path: '/' })
+    // The signup form's fields, now that the account exists. A failure never costs the sign-in: /me asks again.
+    if (r.profile) await saveSignupProfile(await profiles.ready, r.user.id, r.profile, { email: r.user.email }).catch((error) => console.error(`[auth] signup profile save failed: ${(error as Error).message}`))
     return c.redirect(r.next ?? '/me')
   })
   app.post('/logout', (c) => {
@@ -401,33 +447,98 @@ export function createApp(deps: Deps) {
     emailless: isPlaceholder(user.email),
     coinpayNote: ({ connected: 'CoinPay is connected: sign in with it next time.', taken: 'That CoinPay account is already linked to another built.indie member.', welcome: 'Welcome! You signed in with CoinPay.' } as Record<string, string>)[c.req.query('coinpay') ?? ''] ?? null,
   })
-  app.get('/me', (c) => {
+  app.get('/me', async (c) => {
     const user = sessionUser(c)
-    return user ? page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, ...signinInfo(c, user) })) : toLogin(c)
+    return user ? page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, daysBalance: await service.featuredDays(user), ...signinInfo(c, user), profile: await (await profiles.ready).get(user.id), detailsNote: c.req.query('details') === 'saved' ? 'Your details are saved.' : null })) : toLogin(c)
   })
-  app.post('/me/key', (c) => {
+  // "Have a code?": a credit code (@profullstack/redeem-credits) adds Featured days to the balance.
+  app.post('/me/redeem', async (c) => {
     const user = sessionUser(c)
     if (!user) return toLogin(c)
     if (crossSite(c)) return c.redirect('/me')
-    return page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), apiKey: store.newApiKey(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, ...signinInfo(c, user) }))
+    const code = String(((await c.req.parseBody()) as Record<string, string>).code ?? '')
+    let note: string
+    let status = 200
+    if (!redeemLimit.allow(`redeem:${user.id}`) || !redeemLimit.allow(`redeem-ip:${ip(c)}`)) (note = 'Too many tries. Wait a few minutes.'), (status = 429)
+    else
+      try {
+        note = (await service.redeem(user, code)).message
+      } catch (e) {
+        note = e instanceof Error ? e.message : String(e)
+        status = 400
+      }
+    return page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, daysBalance: await service.featuredDays(user), redeemNote: note, redeemError: status !== 200, ...signinInfo(c, user), profile: await (await profiles.ready).get(user.id) }), status)
+  })
+  // Spend Featured days from the balance on a listing you own.
+  app.post('/p/:slug/feature-days', async (c) => {
+    const user = sessionUser(c)
+    if (!user) return toLogin(c)
+    const p = store.bySlug(c.req.param('slug'))
+    if (!p || p.status === 'hidden') return c.notFound()
+    if (crossSite(c) || !store.canEdit(p, user)) return c.redirect(`/p/${p.slug}`)
+    const days = Number(((await c.req.parseBody()) as Record<string, string>).days ?? 0)
+    try {
+      await service.spendFeaturedDays(p, user, days)
+      return c.redirect(`/p/${p.slug}?featured=days`)
+    } catch (e) {
+      return productView(c, p, { error: e instanceof Error ? e.message : String(e) }, 400)
+    }
+  })
+  // The shared profile (@profullstack/profile): the /me form, and GET/PUT/PATCH /api/v1/me/profile for a session or an API key.
+  app.post('/me/profile', async (c) => {
+    const user = sessionUser(c)
+    if (!user) return toLogin(c)
+    if (crossSite(c)) return c.redirect('/me')
+    const form = (await c.req.parseBody()) as Record<string, string>
+    const email = isPlaceholder(user.email) ? null : user.email
+    const check = validateProfile({ ...form, email }, { required: ['first_name', 'last_name'] })
+    if (!check.ok) return page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, daysBalance: await service.featuredDays(user), ...signinInfo(c, user), profile: form, detailsNote: 'Some fields need fixing.', detailsError: true, detailsErrors: check.errors }), 400)
+    await (await profiles.ready).save(user.id, check.profile)
+    return c.redirect('/me?details=saved#details')
+  })
+  app.post('/me/key', async (c) => {
+    const user = sessionUser(c)
+    if (!user) return toLogin(c)
+    if (crossSite(c)) return c.redirect('/me')
+    return page(c, mePage(ctxOf(c), { user, products: store.mine(user.id), apiKey: store.newApiKey(user.id), invite: store.inviteStats(user.id), karma: service.karma.summary(user.id), howToEarn: HOW_TO_EARN, featureDays: config.featureDays, daysBalance: await service.featuredDays(user), ...signinInfo(c, user) }))
   })
 
   // Invites: a link per member; a new member it brings in who launches earns the inviter a free Featured week.
   app.get('/i/:code', (c) => {
     const code = c.req.param('code')
+    // A scarce invite code: whoever made it stays private until it is used.
+    if (isInviteCode(code)) {
+      if (!sessionUser(c)) setCookie(c, INVITE_COOKIE, code.trim().toUpperCase(), { httpOnly: true, secure: secure(c), sameSite: 'Lax', path: '/', maxAge: 30 * 86400 })
+      return page(c, inviteLanding(ctxOf(c), { inviter: null, bonusDays: INVITE_BONUS_DAYS }))
+    }
     const inviter = store.inviterOf(code)
     if (!inviter) return c.redirect('/invite')
     if (!sessionUser(c)) setCookie(c, REF_COOKIE, code, { httpOnly: true, secure: secure(c), sameSite: 'Lax', path: '/', maxAge: 30 * 86400 })
     return page(c, inviteLanding(ctxOf(c), { inviter: store.publicName(inviter) }))
   })
-  const inviteView = async (c: Context<Env>, extra: { flash?: string; error?: string } = {}, status = 200) => {
+  const inviteCodes = async (user: User) => ({ quota: await service.affiliates.quota(user.id), invites: await service.affiliates.invites(user.id), bonusDays: INVITE_BONUS_DAYS })
+  const inviteView = async (c: Context<Env>, extra: { flash?: string; error?: string; newCode?: string } = {}, status = 200) => {
     const user = sessionUser(c)
     const me = user
-      ? { link: inviteLink(user), stats: store.inviteStats(user.id), name: store.publicName(user.id), displayName: user.displayName, listings: store.mine(user.id).filter((p) => p.status === 'live'), ...extra }
+      ? { link: inviteLink(user), stats: store.inviteStats(user.id), name: store.publicName(user.id), displayName: user.displayName, listings: store.mine(user.id).filter((p) => p.status === 'live'), codes: { ...(await inviteCodes(user)), newLink: extra.newCode ? `${origin}/i/${extra.newCode}` : undefined }, ...extra }
       : undefined
     return page(c, invitePage(ctxOf(c), { featureDays: config.featureDays, featureUsd: config.featureUsd, inviters: await inviters(10), me }), status)
   }
   app.get('/invite', (c) => inviteView(c))
+  app.get('/invites', (c) => c.redirect('/invite#codes'))
+  // A scarce invite code: three each, single use.
+  app.post('/invite/code', async (c) => {
+    const user = sessionUser(c)
+    if (!user) return toLogin(c)
+    if (crossSite(c)) return c.redirect('/invite')
+    const note = String(((await c.req.parseBody()) as Record<string, string>).note ?? '').slice(0, 80)
+    try {
+      const invite = await service.affiliates.createInvite(user.id, note)
+      return inviteView(c, { newCode: invite.code })
+    } catch (e) {
+      return inviteView(c, { error: (e as Error).message === 'no invites left' ? `You have used all ${INVITES_PER_PERSON} invite codes.` : (e as Error).message }, 400)
+    }
+  })
   app.post('/invite/name', async (c) => {
     const user = sessionUser(c)
     if (!user) return toLogin(c)
@@ -834,18 +945,69 @@ export function createApp(deps: Deps) {
     const r = await service.claim(p, user)
     return c.json({ claimed: r.ok, ...(r.method ? { method: r.method } : {}), looked: r.looked, record: claimRecord(p, user), badge: claimBadge(p, user), ...(r.ok ? {} : { markdown: claimMd(p, user) }) })
   })
-  app.get('/api/v1/me', (c) => {
+  mountProfileRoutes(app, {
+    store: profiles.store,
+    getUser: (_req: Request, c: Context) => {
+      const user = sessionUser(c) ?? apiUser(c)
+      return user ? { id: user.id, email: isPlaceholder(user.email) ? null : user.email } : null
+    },
+  })
+  app.get('/api/v1/me', async (c) => {
     const user = apiUser(c)
     if (!user) return c.json(NEEDS_ACCOUNT, 401)
-    return c.json({ email: isPlaceholder(user.email) ? null : user.email, coinpay: Boolean(store.identities(user.id).some((i) => i.provider === COINPAY)), products: store.mine(user.id).map((p) => ({ ...apiProduct(p), owner: p.ownerId === user.id })), invite: apiInvite(user), karma: apiKarma(user) })
+    return c.json({ email: isPlaceholder(user.email) ? null : user.email, coinpay: Boolean(store.identities(user.id).some((i) => i.provider === COINPAY)), products: store.mine(user.id).map((p) => ({ ...apiProduct(p), owner: p.ownerId === user.id })), invite: await apiInvite(user), featured_days: await service.featuredDays(user), karma: apiKarma(user) })
   })
-  const apiInvite = (user: User) => {
+  const apiInvite = async (user: User) => {
     const s = store.inviteStats(user.id)
-    return { link: inviteLink(user), code: s.code, invited: s.invited, launched: s.launched, credits: s.credits, karma_credits: s.karmaCredits, used: s.used, feature_days: config.featureDays }
+    const codes = await inviteCodes(user)
+    return {
+      link: inviteLink(user),
+      code: s.code,
+      invited: s.invited,
+      launched: s.launched,
+      credits: s.credits,
+      karma_credits: s.karmaCredits,
+      used: s.used,
+      feature_days: config.featureDays,
+      // Scarce single-use invite codes: the code itself is shown once, when made.
+      invite_codes: { quota: codes.quota, bonus_days: codes.bonusDays, invites: codes.invites.map((i) => ({ id: i.id, note: i.note, created_at: new Date(i.createdAt).toISOString(), expires_at: i.expiresAt ? new Date(i.expiresAt).toISOString() : null, used: Boolean(i.usedAt), used_at: i.usedAt ? new Date(i.usedAt).toISOString() : null })) },
+    }
   }
-  app.get('/api/v1/invites', (c) => {
+  app.get('/api/v1/invites', async (c) => {
+    const user = apiUser(c)
+    return user ? c.json(await apiInvite(user)) : c.json(NEEDS_ACCOUNT, 401)
+  })
+  app.post('/api/v1/invites', async (c) => {
+    const user = apiUser(c)
+    if (!user) return c.json(NEEDS_ACCOUNT, 401)
+    try {
+      const invite = await service.affiliates.createInvite(user.id, String((await body(c)).note ?? '').slice(0, 80))
+      return c.json({ link: `${origin}/i/${invite.code}`, code: invite.code, expires_at: invite.expiresAt ? new Date(invite.expiresAt).toISOString() : null, left: (await service.affiliates.quota(user.id)).left, bonus_days: INVITE_BONUS_DAYS }, 201)
+    } catch (e) {
+      return c.json({ error: (e as Error).message === 'no invites left' ? `You have used all ${INVITES_PER_PERSON} invite codes.` : (e as Error).message }, 400)
+    }
+  })
+  app.post('/api/v1/redeem', async (c) => {
     const user = apiUser(c)
-    return user ? c.json(apiInvite(user)) : c.json(NEEDS_ACCOUNT, 401)
+    if (!user) return c.json(NEEDS_ACCOUNT, 401)
+    if (!redeemLimit.allow(`redeem:${user.id}`) || !redeemLimit.allow(`redeem-ip:${ip(c)}`)) return c.json({ error: 'too many tries; wait a few minutes' }, 429)
+    try {
+      const r = await service.redeem(user, String((await body(c)).code ?? ''))
+      return c.json({ ok: true, message: r.message, featured_days: r.days })
+    } catch (e) {
+      return apiError(c, e)
+    }
+  })
+  app.post('/api/v1/products/:slug/feature-days', async (c) => {
+    const user = apiUser(c)
+    const p = owned(c)
+    if (!user || !p) return c.json(NEEDS_KEY, 401)
+    try {
+      const after = await service.spendFeaturedDays(p, user, Number((await body(c)).days ?? 0))
+      return c.json({ featured_until: new Date(after.featuredUntil!).toISOString(), featured_days: await service.featuredDays(user) })
+    } catch (e) {
+      return apiError(c, e)
+    }
   })
   app.post('/api/v1/products/:slug/credit', (c) => {
     const user = apiUser(c)

package/src/service.ts

@@ -10,6 +10,9 @@
  *   verify   the maker put our badge on their site: a followed link back
  *   feature  pay on CoinPay's hosted checkout (any coin or PayPal) to sit on top for a week
  *   vote, comment, review, share   what members do on a listing; each pays karma (karma.ts)
+ *   redeem   a credit code (@profullstack/redeem-credits) adds Featured days to a member's balance
+ *   invites  3 single-use invite codes each (@profullstack/affiliates); a new member who
+ *            joins through one gives both of them INVITE_BONUS_DAYS Featured days
  *
  * Products are described in the LogicSRC open specs: each one is an OpenSite
  * record (logicsrc.com/docs/opensite) and an OpenProfile.md with Kind
@@ -26,6 +29,23 @@ import { Karma, SHARE_NETWORKS } from './karma.js'
 import { cleanTags } from './tags.js'
 import { validEmail } from './auth.js'
 import { CoinPay, CoinPayError, readWebhook, verifyWebhook } from '@profullstack/coinpay-onboard'
+import { Credits, sqliteStore as creditStore } from '@profullstack/redeem-credits'
+import { Affiliates, sqliteStore as affiliateStore } from '@profullstack/affiliates'
+
+/** The unit a credit code grants: days a listing sits in the Featured slot. */
+export const FEATURED_DAYS = 'featured_days'
+/** Single-use invite codes each member can hand out. Scarce on purpose: an invite should mean something. */
+export const INVITES_PER_PERSON = 3
+/** Featured days both people get when an invite code is used by someone new. */
+export const INVITE_BONUS_DAYS = 2
+/** What a refused credit code means, in words. */
+const REDEEM_REASONS: Record<string, string> = {
+  invalid: 'That code is not valid.',
+  expired: 'That code has expired.',
+  used_up: 'That code has been used.',
+  already_redeemed: 'You already redeemed that code.',
+  revoked: 'That code was withdrawn.',
+}
 
 export class InputError extends Error {
   constructor(message: string, readonly field?: string) {
@@ -80,8 +100,57 @@ const list = (v: string[] | string | undefined) => (Array.isArray(v) ? v : Strin
 
 export class BuiltIndie {
   readonly karma: Karma
+  /** Redeemable credit codes: Featured days, in the app's own database (credit_* tables). */
+  readonly credits: Credits
+  /** Scarce invite codes (aff_* tables). The open per-member link stays the app's own invite program. */
+  readonly affiliates: Affiliates
   constructor(readonly store: Store, readonly media: Media, readonly config: Config) {
     this.karma = new Karma(store, config.karmaPerCredit ?? 500)
+    this.credits = new Credits(creditStore(store.db as never))
+    this.affiliates = new Affiliates(affiliateStore(store.db as never), { defaultQuota: INVITES_PER_PERSON })
+  }
+
+  /** Featured days this member holds (from credit codes and invite bonuses), not yet spent on a listing. */
+  featuredDays(user: Pick<User, 'id'>): Promise<number> {
+    return this.credits.balance(user.id, FEATURED_DAYS)
+  }
+
+  /** Redeem a credit code for the signed-in member. Returns what it added, in words; a refused code throws. */
+  async redeem(user: Pick<User, 'id'>, code: string): Promise<{ message: string; days: number }> {
+    if (!code.trim()) throw new InputError('Enter a code.', 'code')
+    const r = await this.credits.redeem(code, user.id)
+    if (!r.ok) throw new InputError(REDEEM_REASONS[r.reason] ?? 'That code did not work.', 'code')
+    const g = r.grant
+    const what = g.unit === FEATURED_DAYS ? `${g.amount} Featured day${g.amount === 1 ? '' : 's'}` : `${g.amount} ${g.unit}`
+    const message = g.every === 'month' ? `Added ${what} every month${g.months ? ` for ${g.months} months` : ''}.` : `Added ${what}.`
+    return { message: `${message} Use ${g.amount === 1 ? 'it' : 'them'} on any live listing you own.`, days: await this.featuredDays(user) }
+  }
+
+  /** Spend Featured days from the balance on a live listing: the same featured_until a paid week extends. */
+  async spendFeaturedDays(p: Product, user: User, days: number): Promise<Product> {
+    if (p.status !== 'live') throw new InputError('Only a live listing can be featured.')
+    if (!this.store.canEdit(p, user)) throw new InputError('You can only feature a listing you submitted or own.')
+    const want = Math.floor(Number(days))
+    if (!Number.isFinite(want) || want < 1) throw new InputError('Pick at least one day.', 'days')
+    const r = await this.credits.spend(user.id, FEATURED_DAYS, want, `featured ${p.slug}`)
+    if (!r.ok) throw new InputError(r.balance ? `You have ${r.balance} Featured day${r.balance === 1 ? '' : 's'} left.` : 'You have no Featured days. Redeem a code or use an invite.', 'days')
+    this.store.extendFeatured(p.id, want)
+    return this.store.product(p.id)!
+  }
+
+  /**
+   * Someone new signed up through a scarce invite code: the code is spent, both get
+   * INVITE_BONUS_DAYS Featured days, and the invite counts in the invite program
+   * (the same invites row an invite link makes, so a sign-up is never counted twice).
+   */
+  async acceptInvite(code: string, user: User): Promise<{ ok: boolean; reason?: string; inviterId?: string }> {
+    const r = await this.affiliates.redeemInvite(code, user.id)
+    if (!r.ok) return { ok: false, reason: r.reason }
+    const bonus = { unit: FEATURED_DAYS, amount: INVITE_BONUS_DAYS } as const
+    await this.credits.grant(user.id, bonus, `invited by ${r.inviterId}`)
+    await this.credits.grant(r.inviterId, bonus, `invited ${user.id}`)
+    this.store.recordInvite(user.id, this.store.inviteCode(r.inviterId))
+    return { ok: true, inviterId: r.inviterId }
   }
 
   /** A product page's public address. */

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.6.0'
+export const VERSION = '0.7.1'