@redeemid/emdash 0.0.5 → 0.0.7

package/README.md

@@ -2,16 +2,18 @@
 
 Shopify customer accounts, member levels and paywalls for [EmDash](https://github.com/emdash-cms/emdash) sites. Shopify runs the store and the customer account; EmDash runs the content.
 
-**Status: 0.0.5, early.** Runs on Node and Cloudflare Workers. Sign-in, the member mirror, webhooks, levels, rules, teasers, badges, the page gate, the Shopify cart and checkout are covered by an end-to-end test against a fake store.
+**Status: 0.0.7, early.** Runs on Node and Cloudflare Workers. Sign-in, the member mirror, webhooks, levels, rules, the meter and drip, teasers, badges, the page gate, the Shopify cart and checkout are covered by an end-to-end test against a fake store.
 
 ## What it does
 
 - **Sign in with the store's customer account.** Members click "Sign in" on your site, sign in on the store's account page and come back signed in. They become EmDash Subscribers. That role only means "signed in"; it never grants content.
 - **Mirrors the customer.** Email, name, tags and enabled/disabled status, kept current by signed Shopify webhooks.
 - **Levels from tags.** You map Shopify customer tags to levels. Set tags in Shopify Flow or any app; RedeemID only reads them.
-- **Rules like RedeemID's on WordPress.** Lock a collection, entries with a term (and its child terms), or set a site default; a term can also open its entries to everyone. When several term rules cover an entry, readers must pass all of them.
+- **Rules.** Lock a collection, entries with a term (and its child terms), or set a site default; a term can also open its entries to everyone. When several term rules cover an entry, readers must pass all of them.
+- **Meter and drip.** Signed-in readers may open a few locked entries free each month or week. A rule can also drip: members read its entries once they've held their level for so many days.
 - **Teasers and badges.** Locked entries can show their first paragraphs, up to a word count. `<AccessBadge>` names the level an entry needs and shows a lock to readers it keeps out.
 - **Plans, cart and checkout.** `<Plan>` shows a Shopify product's price and adds it to the visitor's Shopify cart; `<Cart>` shows the count and opens Shopify checkout.
+- **Member account card.** `<MemberCard>` shows members their levels with when each started, the levels they held before, the meter, and Refresh membership, which reads their tags from the store again.
 - **Account.** Members get an Account link to their Shopify customer account (orders, profile, addresses) and Sign out, which also ends the Shopify session.
 - **Paywall break block.** Editors write one body and drop a "Paywall break" block where members-only content starts, picking which levels may read on, or leaving it to the entry's rule. `<Content>` renders the body and leaves the rest off the page for everyone else.
 - **Members only block.** For a members part in the middle of a body: "Members only" (pick the levels) and "Members only: end". Everyone else sees the wall in its place and reads on after it.
@@ -49,6 +51,8 @@ const config = {
 	join: { href: "/join/", label: "Become a member" },
 	// Optional: locked posts with no paywall break show the paragraphs within their first 40 words.
 	teaser: { posts: 40 },
+	// Optional: signed-in readers may open 3 locked posts a month.
+	meter: { limit: 3, period: "month", collections: ["posts"] },
 };
 
 export default defineConfig({
@@ -95,8 +99,17 @@ Each rule names a collection and the levels, any of which may read. An empty `le
 | `{ collection: "posts", taxonomy: "tag", term: "free-to-read", levels: [], open: true }` | Opens entries with that term to everyone, whatever else covers them |
 | `{ collection: "*", levels: [] }` | The site default, for collections with no rule of their own |
 
+| `{ collection: "posts", taxonomy: "category", term: "archive", levels: ["member"], drip: 30 }` | Drip: members read these entries 30 days after their level started |
+| `{ collection: "posts", taxonomy: "category", term: "exclusive", levels: ["pro"], meter: false }` | The meter never opens these entries |
+
 Term rules beat the collection's rule, which beats the site default. When several term rules cover one entry (a story in Investigations, Gold, and Culture, Silver), readers must pass every one of them, so only Gold + Silver members read it. Set `combine: "any"` to let one of them be enough.
 
+### Meter and drip
+
+The meter lets a signed-in reader who can't read an entry open it anyway, `limit` entries per `period` (`"month"`, the default, or `"week"`, in UTC). Each entry counts once per period, when its own page renders through `<Content>` with an `id`; lists, feeds, search and the content API never count. Visitors get the wall and a nudge to sign in. While it runs, `<Content>` says how many free reads are left; when it runs out, the wall says so. Rules with `meter: false` are never metered, and the meter never opens an entry a member is waiting on by drip.
+
+Drip holds a rule's entries back from members who pass it until they've held their level for `drip` days. A level starts when the customer first had its tag (for a `match: "all"` level, the last of its tags); with several levels the earliest counts, and with none known, the first sign-in. RedeemID notes when each tag first arrives from sign-in and webhooks, and forgets a tag when Shopify removes it. The wall shows the date the entry opens.
+
 ## Use it in templates
 
 EmDash has no content filter hook, so templates decide what to render. Render the entry body with `<Content>` instead of `<PortableText>`:
@@ -105,12 +118,12 @@ EmDash has no content filter hook, so templates decide what to render. Render th
 ---
 import Content from "@redeemid/emdash/components/Content.astro";
 ---
-<Content value={post.data.content} collection="posts" terms={post.data.terms}>
+<Content value={post.data.content} collection="posts" terms={post.data.terms} id={post.id}>
 	<a slot="locked" href="/join/">Become a member</a>
 </Content>
 ```
 
-Everything before the first Paywall break block is shown to everyone. What follows reaches the page only for readers the break allows: the levels picked on it ("Signed in" for any member), or when none are picked the entry's rule. With none picked and no rule covering the entry, the break changes nothing, as on WordPress. A body with no break follows the entry's rule as a whole; readers it keeps out see the collection's `teaser` (the paragraphs within that many words, never half a paragraph), if one is set. Plain `<PortableText>` ignores the break and shows everything, so use `<Content>` for any body that may hold one.
+Everything before the first Paywall break block is shown to everyone. What follows reaches the page only for readers the break allows: the levels picked on it ("Signed in" for any member), or when none are picked the entry's rule. With none picked and no rule covering the entry, the break changes nothing. A body with no break follows the entry's rule as a whole; readers it keeps out see the collection's `teaser` (the paragraphs within that many words, never half a paragraph), if one is set. Plain `<PortableText>` ignores the break and shows everything, so use `<Content>` for any body that may hold one.
 
 A "Members only" block starts a part for the levels picked on it (none picked: the entry's rule, or any signed-in member) that runs to the next "Members only: end" block. Readers who can't read it see the wall there, and the body goes on after the end block.
 
@@ -127,7 +140,7 @@ import AccessBadge from "@redeemid/emdash/components/AccessBadge.astro";
 <AccessBadge collection="posts" terms={post.data.terms} content={post.data.content} />
 ```
 
-In your own code (`@redeemid/emdash/access`), `entryRequirement(config, collection, terms)` gives what an entry needs (a list of clauses, each passed by any of its levels, or `null` when open), and `canRead(Astro, entry)` gives the verdict for the visitor.
+In your own code (`@redeemid/emdash/access`), `entryRequirement(config, collection, terms)` gives what an entry needs (a list of clauses, each passed by any of its levels, or `null` when open), `canRead(Astro, entry)` gives the verdict for the visitor, and `readEntry(Astro, { collection, terms, id })` gives it with drip and the meter applied (and counts a metered read).
 
 Put `<Notices />` near the top of your layout. It shows the message for a `?redeemid_notice=` code (see [docs/shopify-setup.md](docs/shopify-setup.md)) and nothing otherwise; pass `messages={{ cart_empty: "…" }}` to reword one.
 
@@ -142,13 +155,15 @@ import Cart from "@redeemid/emdash/components/Cart.astro";
 <Cart />
 ```
 
-Sell a plan. `<Plan>` shows a Shopify product's title and price with a button that adds it to the visitor's Shopify cart and opens checkout (signed-in members check out with their email). Shopify Flow or an app tags the customer after the order, and access follows that tag:
+For an account page, `<MemberCard />` shows the member's levels (with when each started), levels they held before, how much of the meter they've used, and links to their store account, Refresh membership and Sign out. Visitors get a sign-in link. Refresh membership (`refreshUrl(returnTo)` in `@redeemid/emdash/access`) sends the member to the store with no sign-in form; a member still signed in there comes straight back with their tags read again and the `refreshed` notice, and anyone else goes through the usual sign-in. Use it after a purchase, when Shopify's tag webhook hasn't arrived yet.
+
+Sell a plan. `<Plan>` shows a Shopify product's title and price with a button that adds it to the visitor's Shopify cart and opens checkout (signed-in members check out with their email). Shopify Flow or an app tags the customer after the order, and access follows that tag. With `levels`, members who already hold one of them see "You're on this plan." (`heldLabel`) in place of the button; the Plan block has the same choice:
 
 ```astro
 ---
 import Plan from "@redeemid/emdash/components/Plan.astro";
 ---
-<Plan handle="gold-membership" label="Join Gold">
+<Plan handle="gold-membership" label="Join Gold" levels={["gold"]}>
 	<p>Shown if the product can't be loaded.</p>
 </Plan>
 ```
@@ -160,6 +175,7 @@ import { canRead } from "@redeemid/emdash/access";
 
 const verdict = await canRead(Astro, { collection: "posts", terms: post.data.terms });
 // verdict.allowed, verdict.reason: open | allowed | sign_in | upgrade | disabled
+// readEntry() adds drip (verdict.opensAt) and metered (verdict.meterLeft)
 ```
 
 Pages rendered for a signed-in member are sent with `Cache-Control: private, no-store`; pages for visitors stay cacheable.

package/docs/shopify-setup.md

@@ -53,4 +53,4 @@ The Workers free plan is enough: RedeemID is a native plugin and doesn't need sa
 3. Click **Sign in**, sign in with that customer's email, and you come back to the post, unlocked.
 4. Add or remove the tag in Shopify; the post opens or locks again once the webhook arrives.
 
-If sign-in sends you back with `?redeemid_notice=…`, the code says why: `not_configured` (secrets or `shop` missing), `sign_in_unavailable` (store discovery failed), `sign_in_expired`, `staff_account`, `site_not_ready`, `email_required`, `token_failed`, `bad_id_token`, `identity_failed`. A Buy button can return `plan_unavailable` (no such product, or sold out) or `checkout_failed`. The Cart link returns `cart_empty` when there's nothing in the cart, and Account returns `account_unavailable` when store discovery fails.
+If sign-in sends you back with `?redeemid_notice=…`, the code says why: `not_configured` (secrets or `shop` missing), `sign_in_unavailable` (store discovery failed), `sign_in_expired`, `staff_account`, `site_not_ready`, `email_required`, `token_failed`, `bad_id_token`, `identity_failed`. A Buy button can return `plan_unavailable` (no such product, or sold out) or `checkout_failed`. The Cart link returns `cart_empty` when there's nothing in the cart, and Account returns `account_unavailable` when store discovery fails. Refresh membership returns `refreshed` once it has read the member's tags again.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@redeemid/emdash",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "Shopify customer accounts, member levels and paywalls for EmDash sites. Shopify runs commerce; EmDash runs content.",
 	"type": "module",
 	"license": "MIT",

package/src/access.ts

@@ -32,7 +32,7 @@ export interface Viewer {
 	levels: string[];
 }
 
-export type Reason = "open" | "allowed" | "sign_in" | "upgrade" | "disabled" | "unconfigured";
+export type Reason = "open" | "allowed" | "sign_in" | "upgrade" | "disabled" | "unconfigured" | "drip" | "metered";
 
 /**
  * What an entry needs, in conjunctive form: every clause must pass, and a
@@ -42,7 +42,7 @@ export type Reason = "open" | "allowed" | "sign_in" | "upgrade" | "disabled" | "
 export type Requirement = string[][] | null;
 
 /**
- * The built-in level every signed-in member holds, as on WordPress. A clause
+ * The built-in level every signed-in member holds. A clause
  * with it passes for any signed-in member, like an empty clause.
  */
 export const SIGNED_IN = "signed-in";
@@ -53,6 +53,12 @@ export interface Verdict {
 	/** What the entry needs (see Requirement). `[]` when it is open. */
 	required: string[][];
 	viewer: Viewer;
+	/** For "drip": when the entry opens for this member. */
+	opensAt?: Date;
+	/** For "metered", and for a locked "upgrade" when a meter runs: free entries left this period. */
+	meterLeft?: number;
+	/** The meter's size and period, when one ran. */
+	meter?: { limit: number; period: "month" | "week" };
 }
 
 /** A term as EmDash hydrates it onto an entry, or just its slug. */
@@ -102,26 +108,14 @@ function combined(rules: RuleConfig[], mode: "all" | "any"): string[][] {
 	return reduce(rules.map((r) => r.levels));
 }
 
-/**
- * What an entry needs (see Requirement), from the site's rules.
- *
- * Each term the entry carries is walked up its taxonomy (with `tree`) to the
- * nearest term that has a rule, so a child term takes its parent's rule unless
- * it has its own. Any matching `open` rule opens the entry.
- */
-export function requirement(
-	rules: RuleConfig[] = [],
-	collection: string,
-	terms: Terms = {},
-	options: { combine?: "all" | "any"; tree?: TermTree } = {},
-): Requirement {
-	const mode = options.combine ?? "all";
+/** The rules that decide an entry: matching term rules, else the collection's, else the site default. */
+function deciding(rules: RuleConfig[], collection: string, terms: Terms, tree?: TermTree): RuleConfig[] | "open" {
 	const forCollection = rules.filter((r) => r.collection === collection);
 	const matched: RuleConfig[] = [];
 	for (const [taxonomy, list] of Object.entries(terms)) {
 		const taxRules = forCollection.filter((r) => r.taxonomy === taxonomy && r.term);
 		if (taxRules.length === 0) continue;
-		const parents = options.tree?.[taxonomy] ?? {};
+		const parents = tree?.[taxonomy] ?? {};
 		for (const ref of list ?? []) {
 			let slug: string | null = slugOf(ref);
 			const seen = new Set<string>();
@@ -136,13 +130,142 @@ export function requirement(
 			}
 		}
 	}
-	if (matched.some((r) => r.open)) return null;
-	if (matched.length > 0) return combined(matched, mode);
+	if (matched.some((r) => r.open)) return "open";
+	if (matched.length > 0) return matched;
 	const whole = forCollection.filter((r) => !r.taxonomy && !r.term && !r.open);
-	if (whole.length > 0) return combined(whole, mode);
-	const site = rules.filter((r) => r.collection === "*" && !r.taxonomy && !r.term && !r.open);
-	if (site.length > 0) return combined(site, mode);
-	return null;
+	if (whole.length > 0) return whole;
+	return rules.filter((r) => r.collection === "*" && !r.taxonomy && !r.term && !r.open);
+}
+
+/**
+ * What an entry needs (see Requirement), from the site's rules.
+ *
+ * Each term the entry carries is walked up its taxonomy (with `tree`) to the
+ * nearest term that has a rule, so a child term takes its parent's rule unless
+ * it has its own. Any matching `open` rule opens the entry.
+ */
+export function requirement(
+	rules: RuleConfig[] = [],
+	collection: string,
+	terms: Terms = {},
+	options: { combine?: "all" | "any"; tree?: TermTree } = {},
+): Requirement {
+	const found = deciding(rules, collection, terms, options.tree);
+	if (found === "open" || found.length === 0) return null;
+	return combined(found, options.combine ?? "all");
+}
+
+/** Days of membership the entry's deciding rules ask for (the largest drip), or 0. */
+export function dripDays(rules: RuleConfig[] = [], collection: string, terms: Terms = {}, tree?: TermTree): number {
+	const found = deciding(rules, collection, terms, tree);
+	if (found === "open") return 0;
+	return Math.max(0, ...found.map((r) => (typeof r.drip === "number" && r.drip > 0 ? r.drip : 0)));
+}
+
+/** May the meter open the entry? Not when a deciding rule says `meter: false`. */
+export function meterable(rules: RuleConfig[] = [], collection: string, terms: Terms = {}, tree?: TermTree): boolean {
+	const found = deciding(rules, collection, terms, tree);
+	return found === "open" || !found.some((r) => r.meter === false);
+}
+
+/**
+ * When a member's membership started, for drip: the earliest start among the
+ * levels they hold now (a level starts when its last needed tag arrived),
+ * else when they first signed in. Null when neither is known.
+ */
+export function memberSince(member: MemberRecord, levels: LevelConfig[] = []): string | null {
+	const since = member.tagsSince ?? {};
+	const starts: string[] = [];
+	for (const slug of levelsFor(member.tags, levels)) {
+		const level = levels.find((l) => l.slug === slug);
+		const dates = (level?.tags ?? []).map((t) => since[t.toLowerCase()]).filter((d): d is string => Boolean(d)).sort();
+		if (dates.length === 0) continue;
+		const pick = level?.match === "all" ? dates[dates.length - 1] : dates[0];
+		if (pick) starts.push(pick);
+	}
+	starts.sort();
+	return starts[0] ?? member.linkedAt ?? null;
+}
+
+export interface HeldLevel {
+	slug: string;
+	name: string;
+	/** When the level started (see memberSince), ISO, or null when unknown. */
+	since: string | null;
+}
+
+export interface PastLevel {
+	slug: string;
+	name: string;
+	from: string | null;
+	to: string;
+}
+
+/**
+ * The member's levels now (with when each started) and the levels they held
+ * before (from the tags Shopify has since removed), newest first.
+ */
+export function membership(member: MemberRecord, levels: LevelConfig[] = []): { current: HeldLevel[]; past: PastLevel[] } {
+	const held = levelsFor(member.tags, levels);
+	const current = held.map((slug) => {
+		const level = levels.find((l) => l.slug === slug)!;
+		return { slug, name: level.name, since: memberSince({ ...member, linkedAt: null }, [level]) };
+	});
+	const pastTags = member.pastTags ?? [];
+	const past: PastLevel[] = [];
+	for (const level of levels) {
+		if (held.includes(level.slug)) continue;
+		const wanted = new Set(level.tags.map((t) => t.toLowerCase()));
+		const spans = pastTags.filter((p) => wanted.has(p.tag));
+		if (spans.length === 0) continue;
+		const froms = spans.map((p) => p.from).filter((d): d is string => Boolean(d)).sort();
+		const to = spans.map((p) => p.to).sort().at(-1)!;
+		past.push({ slug: level.slug, name: level.name, from: froms[0] ?? null, to });
+	}
+	past.sort((a, b) => (a.to < b.to ? 1 : a.to > b.to ? -1 : 0));
+	return { current, past };
+}
+
+/** How much of this period's meter the signed-in reader has used, or null when no meter runs. */
+export async function meterUsage(astro: AstroLike): Promise<{ used: number; limit: number; period: "month" | "week" } | null> {
+	const locals = astro.locals as Locals;
+	const meter = siteConfig(locals.emdash?.config)?.meter;
+	const user = locals.user;
+	const db = locals.emdash?.db;
+	if (!meter || !(meter.limit > 0) || !user?.id || !db) return null;
+	const period = meter.period ?? "month";
+	try {
+		const record = await stores(db).meter.get(`${user.id}:${periodKey(new Date(), period)}`);
+		return { used: Math.min(record?.items.length ?? 0, meter.limit), limit: meter.limit, period };
+	} catch {
+		return null;
+	}
+}
+
+/** When drip opens an entry for this member: `since` plus `days`. */
+export function dripOpensAt(since: string | null, days: number): Date | null {
+	if (!since || days <= 0) return null;
+	const t = Date.parse(since);
+	return Number.isNaN(t) ? null : new Date(t + days * 86_400_000);
+}
+
+/** The meter period an instant falls in: "2026-11", or ISO week "2026-W45". UTC. */
+export function periodKey(at: Date, period: "month" | "week" = "month"): string {
+	if (period === "month") return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
+	const d = new Date(Date.UTC(at.getUTCFullYear(), at.getUTCMonth(), at.getUTCDate()));
+	const day = d.getUTCDay() || 7;
+	d.setUTCDate(d.getUTCDate() + 4 - day);
+	const yearStart = Date.UTC(d.getUTCFullYear(), 0, 1);
+	const week = Math.ceil(((d.getTime() - yearStart) / 86_400_000 + 1) / 7);
+	return `${d.getUTCFullYear()}-W${String(week).padStart(2, "0")}`;
+}
+
+/** Count `id` against a meter: an item already counted stays free; a new one needs room. Pure. */
+export function consume(items: string[], id: string, limit: number): { allowed: boolean; items: string[]; left: number } {
+	if (items.includes(id)) return { allowed: true, items, left: Math.max(0, limit - items.length) };
+	if (items.length >= limit) return { allowed: false, items, left: 0 };
+	const next = [...items, id];
+	return { allowed: true, items: next, left: limit - next.length };
 }
 
 /** Does someone holding `held` pass `required`? Signed-in membership is checked by the caller. */
@@ -287,6 +410,68 @@ export function accountUrl(returnTo = "/"): string {
 	return `/_emdash/api/auth/redeemid/account?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }
 
+/** Re-read the member's tags from the store without a sign-in form when their store session is still open. */
+export function refreshUrl(returnTo = "/"): string {
+	return `/_emdash/api/auth/redeemid/login?refresh=1&return=${encodeURIComponent(safeReturn(returnTo))}`;
+}
+
 export function signOutUrl(returnTo = "/"): string {
 	return `/_emdash/api/auth/redeemid/logout?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }
+
+/**
+ * The entry's verdict with drip and the meter applied, for the entry's own
+ * page. Drip narrows a granted verdict; the meter opens a locked one for a
+ * signed-in reader while the period has room, and never opens a drip entry.
+ */
+export async function readEntry(
+	astro: AstroLike,
+	entry: { collection: string; terms?: Terms; id?: string },
+	override?: { required: string[][] },
+): Promise<Verdict> {
+	const verdict = await canRead(astro, entry, override);
+	const locals = astro.locals as Locals;
+	const config = siteConfig(locals.emdash?.config);
+	if (!config) return verdict;
+
+	if (verdict.allowed && verdict.reason === "allowed" && verdict.viewer.member) {
+		const tree = await termTree(config.rules, entry.collection, entry.terms);
+		const days = dripDays(config.rules, entry.collection, entry.terms, tree);
+		const opensAt = dripOpensAt(memberSince(verdict.viewer.member, config.levels), days);
+		if (days > 0 && (!opensAt || opensAt.getTime() > Date.now())) {
+			return { ...verdict, allowed: false, reason: "drip", opensAt: opensAt ?? undefined };
+		}
+		return verdict;
+	}
+
+	const meter = config.meter;
+	const user = locals.user;
+	const db = locals.emdash?.db;
+	if (
+		verdict.reason !== "upgrade" ||
+		!meter ||
+		!(meter.limit > 0) ||
+		!entry.id ||
+		!user?.id ||
+		!db ||
+		(meter.collections && !meter.collections.includes(entry.collection))
+	) {
+		return verdict;
+	}
+	if (!meterable(config.rules, entry.collection, entry.terms, await termTree(config.rules, entry.collection, entry.terms))) {
+		return verdict;
+	}
+	const period = meter.period ?? "month";
+	const key = `${user.id}:${periodKey(new Date(), period)}`;
+	try {
+		const s = stores(db);
+		const record = (await s.meter.get(key)) ?? { userId: user.id, period: periodKey(new Date(), period), items: [] };
+		const used = consume(record.items, `${entry.collection}:${entry.id}`, meter.limit);
+		const info = { limit: meter.limit, period };
+		if (!used.allowed) return { ...verdict, meterLeft: 0, meter: info };
+		if (used.items !== record.items) await s.meter.put(key, { ...record, items: used.items });
+		return { ...verdict, allowed: true, reason: "metered", meterLeft: used.left, meter: info };
+	} catch {
+		return verdict;
+	}
+}

package/src/blocks/PlanBlock.astro

@@ -3,11 +3,11 @@
 import Plan from "../components/Plan.astro";
 
 interface Props {
-	node: { handle?: string; title?: string; label?: string };
+	node: { handle?: string; title?: string; label?: string; levels?: string[] };
 }
 
 const { node } = Astro.props;
 const handle = (node.handle ?? "").trim();
 ---
 
-{handle && <Plan handle={handle} title={node.title?.trim() || undefined} label={node.label?.trim() || "Join"} />}
+{handle && <Plan handle={handle} title={node.title?.trim() || undefined} label={node.label?.trim() || "Join"} levels={Array.isArray(node.levels) ? node.levels : []} />}

package/src/blocks-names.ts

@@ -29,7 +29,7 @@ export function splitAtPaywall<T>(value: T[] | null | undefined): {
 type TextNode = { _type?: unknown; children?: Array<{ text?: unknown }> };
 
 /**
- * The text blocks within the first `words` words of a body, as on WordPress:
+ * The text blocks within the first `words` words of a body:
  * a block is never cut in half, so a block that would pass the count ends the
  * teaser. Images and custom blocks are left out. 0 gives nothing.
  */

package/src/components/AccessBadge.astro

@@ -1,7 +1,7 @@
 ---
 /**
  * The level an entry needs, read from its rules (and from a paywall break
- * with levels), like the Access Badge block on WordPress:
+ * with levels):
  *
  *   <AccessBadge collection="posts" terms={post.data.terms} content={post.data.content} />
  *

package/src/components/Content.astro

@@ -2,12 +2,12 @@
 /**
  * An entry's body, with RedeemID's blocks applied.
  *
- *   <Content value={post.data.content} collection="posts" terms={post.data.terms} />
+ *   <Content value={post.data.content} collection="posts" terms={post.data.terms} id={post.id} />
  *
  * - "Paywall break": everything before the first one is shown to everyone.
  *   What follows reaches the page only for readers who may read it: the
  *   levels picked on the break, or when none are picked the entry's rule
- *   (with no rule, the break changes nothing, as on WordPress).
+ *   (with no rule, the break changes nothing).
  * - "Members only" … "Members only: end": the part between is for the levels
  *   picked on the start block, or the entry's rule, or any signed-in member.
  *   Readers who can't read it see the wall in its place, and the body goes on.
@@ -15,10 +15,15 @@
  *   the collection's teaser (config `teaser`, in words), if any.
  *
  * Readers kept out get the wall (LockedPanel), with the "locked" slot on top.
+ *
+ * Pass `id` on the entry's own page so drip and the meter apply: a rule's
+ * `drip` keeps it shut until the member has held their level that many days,
+ * and config `meter` lets signed-in readers open a few locked entries each
+ * period (each entry counts once). Leave `id` off in lists.
  */
 import { PortableText } from "emdash/ui";
 
-import { canRead, entryRequirement, type Terms, type Verdict } from "../access.js";
+import { canRead, entryRequirement, readEntry, type Terms, type Verdict } from "../access.js";
 import { sections, splitAtPaywall, teaser } from "../blocks-names.js";
 import { siteConfig } from "../site-config.js";
 import LockedPanel from "./LockedPanel.astro";
@@ -27,9 +32,11 @@ interface Props {
 	value?: unknown[] | null;
 	collection?: string;
 	terms?: Terms;
+	/** The entry's id, on its own page: turns on drip and the meter. */
+	id?: string;
 }
 
-const { value, collection = "", terms } = Astro.props;
+const { value, collection = "", terms, id } = Astro.props;
 const split = splitAtPaywall(value);
 const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
 const entryRule = await entryRequirement(config, collection, terms);
@@ -39,7 +46,9 @@ const required = split.paywall ? (split.levels.length ? [split.levels] : entryRu
 const verdict: Verdict | { allowed: true; reason: "open" } =
 	split.paywall && required === null
 		? { allowed: true, reason: "open" }
-		: await canRead(Astro, { collection, terms }, required ? { required } : undefined);
+		: id
+			? await readEntry(Astro, { collection, terms, id }, required ? { required } : undefined)
+			: await canRead(Astro, { collection, terms }, required ? { required } : undefined);
 const words = config?.teaser?.[collection] ?? 0;
 const shown = split.paywall ? split.open : verdict.allowed ? split.open : teaser(split.open, words);
 const rest = verdict.allowed ? split.locked : [];
@@ -59,8 +68,17 @@ async function parts(blocks: unknown[]) {
 }
 const before = await parts(shown);
 const after = await parts(rest);
+const metered = verdict.reason === "metered" ? (verdict as Verdict) : null;
+const per = metered?.meter?.period === "week" ? "this week" : "this month";
 ---
 
+{metered && (
+	<p class="redeemid-meter" role="status" data-redeemid-left={metered.meterLeft}>
+		{metered.meterLeft === 0
+			? `This is your last free read ${per}.`
+			: `You have ${metered.meterLeft} free ${metered.meterLeft === 1 ? "read" : "reads"} left ${per}.`}
+	</p>
+)}
 {before.map((p) =>
 	!p.verdict || p.verdict.allowed ? (
 		p.blocks.length > 0 && <PortableText value={p.blocks} />
@@ -77,7 +95,14 @@ const after = await parts(rest);
 		),
 	)
 ) : (
-	<LockedPanel reason={verdict.reason} required={verdict.required} held={verdict.viewer.levels}>
+	<LockedPanel
+		reason={verdict.reason}
+		required={verdict.required}
+		held={verdict.viewer.levels}
+		opensAt={verdict.opensAt}
+		meterLeft={verdict.meterLeft}
+		meterPeriod={verdict.meter?.period}
+	>
 		<slot name="locked" />
 	</LockedPanel>
 )}

package/src/components/LockedPanel.astro

@@ -17,9 +17,17 @@ interface Props {
 	required?: string[][];
 	/** Levels the reader holds (Verdict.viewer.levels). */
 	held?: string[];
+	/** For "drip": when it opens (Verdict.opensAt). */
+	opensAt?: Date;
+	/** Free reads left when a meter ran (Verdict.meterLeft); 0 shows the meter-used text. */
+	meterLeft?: number;
+	meterPeriod?: "month" | "week";
 }
 
-const { reason, required = [], held = [] } = Astro.props;
+const { reason, required = [], held = [], opensAt, meterLeft, meterPeriod } = Astro.props;
+const opens = opensAt
+	? new Intl.DateTimeFormat("en-US", { dateStyle: "long", timeZone: "UTC" }).format(opensAt)
+	: null;
 const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
 const missing = required.find((clause) => clause.length > 0 && !passes(held, [clause]));
 const level = missing ? config?.levels?.find((l) => l.slug === missing[0]) : undefined;
@@ -37,6 +45,14 @@ const here = Astro.url.pathname + Astro.url.search;
 			{joinHref && <> Not a member yet? <a href={joinHref}>{joinLabel}</a>.</>}
 		</p>
 	)}
+	{reason === "upgrade" && meterLeft === 0 && (
+		<p class="redeemid-locked__meter">You've used your free reads {meterPeriod === "week" ? "this week" : "this month"}.</p>
+	)}
+	{reason === "drip" && (
+		<p>
+			{opens ? <>This opens for you on <time datetime={opensAt?.toISOString()}>{opens}</time>.</> : "This opens for you after you've been a member a little longer."}
+		</p>
+	)}
 	{reason === "upgrade" && (
 		<p>
 			{level ? `This is for ${level.name} members.` : "Your membership doesn't include this yet."}

package/src/components/MemberCard.astro

@@ -0,0 +1,95 @@
+---
+/**
+ * The member's own account card, for an account page: their levels with
+ * when each started, levels they held before, the meter, and links to the
+ * store account, Refresh membership and Sign out. Visitors get a sign-in link.
+ *
+ *   <MemberCard />
+ *
+ * Everything shown comes from the mirrored Shopify customer; Refresh
+ * membership reads it from the store again.
+ */
+import { accountUrl, membership, meterUsage, refreshUrl, signInUrl, signOutUrl, viewer } from "../access.js";
+import { siteConfig } from "../site-config.js";
+
+interface Props {
+	/** Heading text; the member's first name is added after it. */
+	title?: string;
+}
+
+const { title = "Your membership" } = Astro.props;
+const v = await viewer(Astro);
+const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
+const here = Astro.url.pathname + Astro.url.search;
+const m = v.member;
+const disabled = m?.status === "disabled";
+const { current, past } = m && !disabled ? membership(m, config?.levels) : { current: [], past: [] };
+const meter = v.signedIn ? await meterUsage(Astro) : null;
+const date = (iso: string | null) => {
+	if (!iso) return null;
+	const t = Date.parse(iso);
+	return Number.isNaN(t) ? null : new Intl.DateTimeFormat("en-US", { dateStyle: "long", timeZone: "UTC" }).format(new Date(t));
+};
+const name = [m?.firstName, m?.lastName].filter(Boolean).join(" ");
+const join = config?.join;
+---
+
+<section class="redeemid-member" data-redeemid-signed-in={v.signedIn ? "true" : "false"}>
+	{v.signedIn ? (
+		<>
+			<h2 class="redeemid-member__title">{title}</h2>
+			{(name || m?.email) && (
+				<p class="redeemid-member__who">
+					{name && <strong>{name}</strong>}
+					{m?.email && <span>{m.email}</span>}
+				</p>
+			)}
+			{disabled ? (
+				<p class="redeemid-member__disabled">Your account is turned off. Contact the store for help.</p>
+			) : current.length > 0 ? (
+				<ul class="redeemid-member__levels">
+					{current.map((l) => (
+						<li data-redeemid-level={l.slug}>
+							<strong>{l.name}</strong>
+							{date(l.since) && <> since <time datetime={l.since ?? undefined}>{date(l.since)}</time></>}
+						</li>
+					))}
+				</ul>
+			) : (
+				<p class="redeemid-member__none">
+					You don't have a membership yet.{join && <> <a href={join.href}>{join.label ?? "Become a member"}</a></>}
+				</p>
+			)}
+			{past.length > 0 && (
+				<>
+					<h3 class="redeemid-member__subtitle">Before</h3>
+					<ul class="redeemid-member__past">
+						{past.map((l) => (
+							<li data-redeemid-level={l.slug}>
+								{l.name}
+								{date(l.from) ? `, ${date(l.from)} to ${date(l.to)}` : `, until ${date(l.to)}`}
+							</li>
+						))}
+					</ul>
+				</>
+			)}
+			{meter && current.length === 0 && !disabled && (
+				<p class="redeemid-member__meter" data-redeemid-used={meter.used}>
+					Free reads {meter.period === "week" ? "this week" : "this month"}: {meter.used} of {meter.limit} used.
+				</p>
+			)}
+			<p class="redeemid-member__actions">
+				<a href={accountUrl(here)}>Orders and details</a>
+				<a href={refreshUrl(here)}>Refresh membership</a>
+			</p>
+			<form method="post" action={signOutUrl("/")}>
+				<button type="submit">Sign out</button>
+			</form>
+			<p class="redeemid-member__note">Just bought a plan? It can take a minute to show here. Refresh membership checks again.</p>
+		</>
+	) : (
+		<p>
+			<a href={signInUrl(here)}>{config?.label ?? "Sign in"}</a> to see your membership.
+		</p>
+	)}
+</section>

package/src/components/Notices.astro

@@ -21,6 +21,7 @@ const DEFAULTS: Record<string, string> = {
 	plan_unavailable: "That plan isn't available right now.",
 	checkout_failed: "Checkout didn't open. Try again.",
 	cart_empty: "Your cart is empty.",
+	refreshed: "Your membership is up to date.",
 	account_unavailable: "Your account page isn't available right now. Try again in a few minutes.",
 };
 

package/src/components/Plan.astro

@@ -4,8 +4,12 @@
  * checkout. Prices come from the Storefront API; the default slot shows if
  * the product can't be loaded.
  *
- *   <Plan handle="gold-membership" />
+ *   <Plan handle="gold-membership" levels={["gold"]} />
+ *
+ * With `levels`, members who hold one of them see "You're on this plan"
+ * in place of the button.
  */
+import { viewer } from "../access.js";
 import { siteConfig } from "../site-config.js";
 import { plan as loadPlan, type Plan } from "../storefront.js";
 
@@ -15,9 +19,12 @@ interface Props {
 	label?: string;
 	/** Heading override; defaults to the Shopify product title. */
 	title?: string;
+	/** The levels this plan gives. Members holding one see `heldLabel`, not the button. */
+	levels?: string[];
+	heldLabel?: string;
 }
 
-const { handle, label = "Join", title } = Astro.props;
+const { handle, label = "Join", title, levels = [], heldLabel = "You're on this plan." } = Astro.props;
 const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
 let p: Plan | null = null;
 if (config) {
@@ -31,14 +38,17 @@ const price = p?.price
 	? new Intl.NumberFormat("en-US", { style: "currency", currency: p.price.currencyCode }).format(Number(p.price.amount))
 	: null;
 const here = Astro.url.pathname + Astro.url.search;
+const held = levels.length > 0 && (await viewer(Astro)).levels.some((l) => levels.includes(l));
 ---
 
 {p ? (
-	<div class="redeemid-plan" data-redeemid-plan={p.handle}>
+	<div class:list={["redeemid-plan", { "is-held": held }]} data-redeemid-plan={p.handle}>
 		<h2 class="redeemid-plan__title">{title ?? p.title}</h2>
 		{price && <p class="redeemid-plan__price">{price}</p>}
 		{p.description && <p class="redeemid-plan__description">{p.description}</p>}
-		{p.availableForSale ? (
+		{held ? (
+			<p class="redeemid-plan__held">{heldLabel}</p>
+		) : p.availableForSale ? (
 			<form method="post" action="/_emdash/api/auth/redeemid/buy">
 				<input type="hidden" name="plan" value={p.handle} />
 				<input type="hidden" name="return" value={here} />

package/src/config.ts

@@ -22,7 +22,7 @@ export interface LevelConfig {
 }
 
 /**
- * Who may read entries, like RedeemID's content rules on WordPress:
+ * Who may read entries:
  *
  * - A rule with `taxonomy` and `term` covers entries that carry that term, or
  *   a child of it in a hierarchical taxonomy (a child's own rule wins over its
@@ -45,9 +45,30 @@ export interface RuleConfig {
 	levels: string[];
 	/**
 	 * A term rule that opens its entries to everyone, whatever else covers them
-	 * ("Opens" on WordPress). `levels` is ignored.
+	 * `levels` is ignored.
 	 */
 	open?: boolean;
+	/**
+	 * Drip: readers who pass the rule may read its entries only once they have
+	 * been members this many days (from when they first held a level they
+	 * hold now, or else when they first signed in).
+	 */
+	drip?: number;
+	/** `false`: the meter never opens this rule's entries. */
+	meter?: false;
+}
+
+/**
+ * The meter: signed-in readers without access may open a few locked entries
+ * free each month (or week). Guests get the wall; an entry counts once per
+ * period, when its own page renders through <Content> with an `id`.
+ */
+export interface MeterConfig {
+	/** Free entries per period. */
+	limit: number;
+	period?: "month" | "week";
+	/** Collections the meter covers. All of them when left out. */
+	collections?: string[];
 }
 
 export interface RedeemIDConfig {
@@ -61,6 +82,7 @@ export interface RedeemIDConfig {
 	label?: string;
 	levels?: LevelConfig[];
 	rules?: RuleConfig[];
+	meter?: MeterConfig;
 	/** The wall's join link: where readers become members, e.g. { href: "/join/", label: "Become a member" }. */
 	join?: { href: string; label?: string };
 	/**

package/src/plugin.ts

@@ -13,7 +13,7 @@
  * - "Paywall break" (`redeemid-paywall`): everything after it in the body is
  *   for members. Pick the levels that may read on ("Signed in" for any
  *   member); none picked means the entry's rule, and nothing is locked when
- *   no rule covers the entry, as on WordPress.
+ *   no rule covers the entry.
  * - "Members only" (`redeemid-members`) and "Members only: end"
  *   (`redeemid-members-end`): the part between is for the levels picked on
  *   the start block; everyone else sees the wall there and reads on after.
@@ -89,6 +89,12 @@ function blocks(config: RedeemIDConfig) {
 				{ type: "text_input" as const, action_id: "handle", label: "Shopify product handle", placeholder: "gold-membership" },
 				{ type: "text_input" as const, action_id: "title", label: "Title (optional, Shopify's title otherwise)" },
 				{ type: "text_input" as const, action_id: "label", label: "Button label", placeholder: "Join" },
+				{
+					type: "checkbox" as const,
+					action_id: "levels",
+					label: "Levels this plan gives (members on them see \"You're on this plan\")",
+					options: (config.levels ?? []).map((l) => ({ label: l.name, value: l.slug })),
+				},
 			],
 		},
 	];
@@ -281,6 +287,7 @@ async function statusPage(config: RedeemIDConfig, request: Request) {
 						columns: [
 							{ key: "where", label: "Covers" },
 							{ key: "levels", label: "Who can read" },
+							{ key: "extra", label: "Drip and meter" },
 						],
 						rows: rules.map((r) => ({
 							where:
@@ -290,9 +297,16 @@ async function statusPage(config: RedeemIDConfig, request: Request) {
 										? "Site default (collections with no rule)"
 										: `All ${r.collection}`,
 							levels: r.open ? "Everyone (opens the entry)" : r.levels.length ? describe([r.levels], levels) : "Any signed-in member",
+							extra: [r.drip ? `Opens ${r.drip} days into membership` : "", r.meter === false ? "Never metered" : ""].filter(Boolean).join("; "),
 						})),
 					}
 				: { type: "context", text: "No rules. Entries are open unless their body has a paywall break." },
+			{
+				type: "context",
+				text: config.meter?.limit
+					? `Meter: signed-in readers may open ${config.meter.limit} locked ${config.meter.limit === 1 ? "entry" : "entries"} a ${config.meter.period ?? "month"}${config.meter.collections?.length ? ` (${config.meter.collections.join(", ")})` : ""}.`
+					: "Meter: off.",
+			},
 		],
 	};
 }

package/src/routes/callback.ts

@@ -17,7 +17,7 @@ import type { Kysely } from "kysely";
 
 import { env, ENV, PROVIDER_ID, readConfig, storeDomain } from "../config.js";
 import { discover, exchangeCode, identity, ShopifyError, verifyIdToken } from "../shopify.js";
-import { emptyMember, stores } from "../storage.js";
+import { emptyMember, stampTags, stores } from "../storage.js";
 import { callbackUrl, fail, FLOW_TTL_MS, SESSION_FLOW, SESSION_ID_TOKEN, type Flow } from "./shared.js";
 
 export const prerender = false;
@@ -33,7 +33,11 @@ export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
 	const clientId = env(ENV.clientId);
 	if (!config || !storeDomain(config) || !clientId || !emdash?.db || !session) return fail(redirect, returnTo, "not_configured");
 
-	if (url.searchParams.get("error")) return fail(redirect, returnTo, "sign_in_cancelled");
+	if (url.searchParams.get("error")) {
+		// Refresh found no open store session: sign in as usual.
+		if (flow?.refresh) return redirect(`/_emdash/api/auth/redeemid/login?return=${encodeURIComponent(returnTo)}`);
+		return fail(redirect, returnTo, "sign_in_cancelled");
+	}
 
 	const state = url.searchParams.get("state");
 	const code = url.searchParams.get("code");
@@ -83,21 +87,29 @@ export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
 
 		const s = stores(emdash.db);
 		const member = (await s.members.get(who.customerId)) ?? emptyMember(who.customerId);
-		await s.members.put(who.customerId, {
-			...member,
-			userId: user.id,
-			email,
-			firstName: who.firstName,
-			lastName: who.lastName,
-			tags: who.tags,
-			syncedAt: new Date().toISOString(),
-			source: "sign-in",
-		});
+		const now = new Date().toISOString();
+		await s.members.put(
+			who.customerId,
+			stampTags(
+				{
+					...member,
+					userId: user.id,
+					email,
+					firstName: who.firstName,
+					lastName: who.lastName,
+					tags: who.tags,
+					syncedAt: now,
+					source: "sign-in",
+					linkedAt: member.linkedAt ?? now,
+				},
+				now,
+			),
+		);
 
 		session.regenerate?.();
 		session.set("user", { id: user.id });
 		session.set(SESSION_ID_TOKEN, tokens.idToken);
-		return redirect(returnTo);
+		return flow.refresh ? fail(redirect, returnTo, "refreshed") : redirect(returnTo);
 	} catch (e) {
 		const code = e instanceof ShopifyError ? e.code : e instanceof OAuthError ? "signup_not_allowed" : "sign_in_failed";
 		console.error("[redeemid] sign-in failed:", (e as Error).message);

package/src/routes/login.ts

@@ -2,6 +2,9 @@
  * GET /_emdash/api/auth/redeemid/login?return=/path
  *
  * Starts Shopify customer account sign-in (authorization code + PKCE).
+ * With `refresh=1` it asks the store not to show a form (`prompt=none`):
+ * a member whose store session is still open comes straight back with their
+ * tags read again; anyone else is sent through the usual sign-in.
  */
 
 import type { APIRoute } from "astro";
@@ -16,6 +19,7 @@ export const prerender = false;
 export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
 	const url = new URL(request.url);
 	const returnTo = safeReturn(url.searchParams.get("return"));
+	const refresh = url.searchParams.get("refresh") === "1";
 	const emdash = (locals as { emdash?: { config?: unknown } }).emdash;
 	const config = readConfig(emdash?.config);
 	const clientId = env(ENV.clientId);
@@ -30,6 +34,7 @@ export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
 			verifier: randomToken(48),
 			returnTo,
 			at: Date.now(),
+			...(refresh ? { refresh: true } : {}),
 		};
 		session.set(SESSION_FLOW, flow);
 		return redirect(
@@ -40,6 +45,7 @@ export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
 				nonce: flow.nonce,
 				challenge: await challengeFor(flow.verifier),
 				locale: request.headers.get("accept-language")?.split(",")[0]?.trim(),
+				...(refresh ? { prompt: "none" as const } : {}),
 			}),
 		);
 	} catch (e) {

package/src/routes/shared.ts

@@ -11,6 +11,8 @@ export interface Flow {
 	verifier: string;
 	returnTo: string;
 	at: number;
+	/** Started by Refresh membership (prompt=none). */
+	refresh?: boolean;
 }
 
 export const CALLBACK_PATH = "/_emdash/api/auth/redeemid/callback";

package/src/shopify.ts

@@ -97,7 +97,16 @@ export function base64url(bytes: Uint8Array): string {
 
 export function authorizeUrl(
 	d: Discovery,
-	args: { clientId: string; redirectUri: string; state: string; nonce: string; challenge: string; locale?: string },
+	args: {
+		clientId: string;
+		redirectUri: string;
+		state: string;
+		nonce: string;
+		challenge: string;
+		locale?: string;
+		/** "none": no sign-in form; the store answers with an error when the customer isn't signed in there. */
+		prompt?: "none";
+	},
 ): string {
 	const url = new URL(d.authorizationEndpoint);
 	url.searchParams.set("scope", SCOPES);
@@ -109,6 +118,7 @@ export function authorizeUrl(
 	url.searchParams.set("code_challenge", args.challenge);
 	url.searchParams.set("code_challenge_method", "S256");
 	if (args.locale) url.searchParams.set("ui_locales", args.locale);
+	if (args.prompt) url.searchParams.set("prompt", args.prompt);
 	return url.toString();
 }
 

package/src/storage.ts

@@ -31,6 +31,45 @@ export interface MemberRecord {
 	syncedAt: string;
 	/** What wrote it last: sign-in or a webhook topic. */
 	source: string;
+	/** When each tag (lowercased) was first seen on the customer, ISO. Kept for drip; a removed tag is forgotten. */
+	tagsSince?: Record<string, string>;
+	/** When the customer first signed in here, ISO. */
+	linkedAt?: string | null;
+	/** Tags Shopify has removed, with when each was held (newest last, at most 50). */
+	pastTags?: PastTag[];
+}
+
+/** A tag the customer held from `from` (when known) until `to`. */
+export interface PastTag {
+	tag: string;
+	from: string | null;
+	to: string;
+}
+
+const PAST_TAGS_KEPT = 50;
+
+/** A signed-in reader's meter for one period: the locked items they opened free. */
+export interface MeterRecord {
+	userId: string;
+	/** "2026-11" for a month, "2026-W45" for a week. */
+	period: string;
+	items: string[];
+}
+
+/**
+ * Update `tagsSince` to the record's current tags: new tags start now;
+ * removed tags move to `pastTags` with the dates they were held.
+ */
+export function stampTags(m: MemberRecord, now = new Date().toISOString()): MemberRecord {
+	const before = m.tagsSince ?? {};
+	const since: Record<string, string> = {};
+	for (const t of m.tags.map((t) => t.toLowerCase())) since[t] = before[t] ?? now;
+	const removed = Object.keys(before).filter((t) => !(t in since));
+	if (removed.length) {
+		m.pastTags = [...(m.pastTags ?? []), ...removed.map((tag) => ({ tag, from: before[tag] ?? null, to: now }))].slice(-PAST_TAGS_KEPT);
+	}
+	m.tagsSince = since;
+	return m;
 }
 
 export interface DeliveryRecord {
@@ -41,11 +80,13 @@ export interface DeliveryRecord {
 export const STORAGE_CONFIG = {
 	members: { indexes: ["email", "userId"] },
 	deliveries: { indexes: ["receivedAt"] },
+	meter: { indexes: ["userId"] },
 };
 
 export interface Stores {
 	members: StorageCollection<MemberRecord>;
 	deliveries: StorageCollection<DeliveryRecord>;
+	meter: StorageCollection<MeterRecord>;
 }
 
 export function stores(db: unknown): Stores {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.0.5";
+export const VERSION = "0.0.7";

package/src/webhooks.ts

@@ -6,7 +6,7 @@
  * only; a profile payload without `tags` never means "tags removed".
  */
 
-import { cleanTags, emptyMember, numericId, type MemberRecord, type Stores } from "./storage.js";
+import { cleanTags, emptyMember, numericId, stampTags, type MemberRecord, type Stores } from "./storage.js";
 
 export type Kind = "profile" | "delete" | "status" | "tags" | "merge" | "compliance" | "ignored";
 
@@ -114,7 +114,7 @@ export async function apply(s: Stores, topic: string, payload: Record<string, un
 			if (!survivor.userId) survivor.userId = old.userId;
 			survivor.syncedAt = new Date().toISOString();
 			survivor.source = topic;
-			await s.members.put(kept, survivor);
+			await s.members.put(kept, stampTags(survivor));
 		}
 		await s.members.delete(gone);
 		return "processed";
@@ -156,6 +156,6 @@ export async function apply(s: Stores, topic: string, payload: Record<string, un
 
 	current.syncedAt = new Date().toISOString();
 	current.source = topic;
-	await s.members.put(id, current);
+	await s.members.put(id, stampTags(current));
 	return "processed";
 }