@redeemid/emdash 0.0.2 → 0.0.4

package/README.md

@@ -2,16 +2,20 @@
 
 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.2, early.** Runs on Node and Cloudflare Workers. Sign-in, the member mirror, webhooks, levels, rules, the page gate and plan checkout are covered by an end-to-end test against a fake store.
+**Status: 0.0.4, 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.
 
 ## 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 per collection or term.** Lock a collection, or only entries in a category or tag.
-- **Plans and checkout.** `<Plan>` shows a Shopify product's price and starts checkout through the Storefront API.
-- **A page gate.** `<Gate>` shows the entry to readers who may read it and a teaser plus "Sign in" to everyone else.
+- **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.
+- **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.
+- **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.
+- **Plan block.** Editors add a Shopify product to any page with the "Plan" block: title, price and a buy button.
+- **In the admin.** RedeemID shows under Plugins with a Members page (Shopify customers, tags, levels), a Status page (secrets, store discovery, the URLs to give Shopify, levels and rules) and a dashboard widget.
 - **Keeps members out of EmDash's own APIs**, so the gate is the only way to read locked content.
 
 ## Install
@@ -23,28 +27,31 @@ pnpm add @redeemid/emdash
 ```
 
 ```js title="astro.config.mjs"
-import { redeemid, redeemidGuard } from "@redeemid/emdash";
+import { redeemid, redeemidGuard, redeemidPlugin } from "@redeemid/emdash";
 import emdash from "emdash/astro";
 
+const config = {
+	shop: "my-store.myshopify.com",
+	levels: [
+		{ slug: "member", name: "Member", tags: ["member"] },
+		{ slug: "pro", name: "Pro", tags: ["pro"] },
+		// match: "all" needs every tag, e.g. both memberships:
+		{ slug: "both", name: "Member + Pro", tags: ["member", "pro"], match: "all" },
+	],
+	rules: [
+		{ collection: "posts", taxonomy: "category", term: "members", levels: ["member", "pro"] },
+		{ collection: "posts", taxonomy: "category", term: "pro", levels: ["pro"] },
+	],
+	// Optional: locked posts with no paywall break show the paragraphs within their first 40 words.
+	teaser: { posts: 40 },
+};
+
 export default defineConfig({
 	integrations: [
 		emdash({
 			// database, storage, …
-			authProviders: [
-				redeemid({
-					shop: "my-store.myshopify.com",
-					levels: [
-						{ slug: "member", name: "Member", tags: ["member"] },
-						{ slug: "pro", name: "Pro", tags: ["pro"] },
-						// match: "all" needs every tag, e.g. both memberships:
-						{ slug: "both", name: "Member + Pro", tags: ["member", "pro"], match: "all" },
-					],
-					rules: [
-						{ collection: "posts", taxonomy: "category", term: "members", levels: ["member", "pro"] },
-						{ collection: "posts", taxonomy: "category", term: "pro", levels: ["pro"] },
-					],
-				}),
-			],
+			authProviders: [redeemid(config)], // sign-in, webhooks, cart and checkout routes
+			plugins: [redeemidPlugin(config)], // admin pages and the editor blocks
 		}),
 		redeemidGuard(),
 	],
@@ -72,30 +79,59 @@ In Shopify, give the Customer Account API client these settings:
 
 Point webhooks (`customers/create`, `customers/update`, `customers/delete`, `customers/disable`, `customers/enable`, `customers/merge`, `customer.tags_added`, `customer.tags_removed`, `customers/redact`) at `https://your-site.example/_emdash/api/auth/redeemid/webhook`.
 
+### Rules
+
+Each rule names a collection and the levels, any of which may read. An empty `levels` list, or the built-in `signed-in` level, means any signed-in member.
+
+| Rule | Covers |
+| --- | --- |
+| `{ collection: "reports", levels: ["gold"] }` | Every entry in the collection |
+| `{ collection: "posts", taxonomy: "category", term: "investigations", levels: ["gold"] }` | Entries with that term, or with a child of it in a hierarchical taxonomy. A child's own rule wins over its parent's. |
+| `{ 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 |
+
+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.
+
 ## Use it in templates
 
-EmDash has no content filter hook, so templates decide what to render. Wrap the entry body:
+EmDash has no content filter hook, so templates decide what to render. Render the entry body with `<Content>` instead of `<PortableText>`:
+
+```astro
+---
+import Content from "@redeemid/emdash/components/Content.astro";
+---
+<Content value={post.data.content} collection="posts" terms={post.data.terms}>
+	<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.
+
+To lock a part of a template that isn't the body, wrap it in `<Gate>` (`<Gate levels={["pro"]}>…</Gate>`).
+
+Show what an entry needs with `<AccessBadge>`, on cards and on the entry. It reads the entry's rules (and a paywall break's levels when you pass `content`), shows "Free" for open entries (`free=""` hides it), and adds `is-locked` and a lock for readers it keeps out. `data-redeemid-level` holds the level slugs, for colours:
 
 ```astro
 ---
-import Gate from "@redeemid/emdash/components/Gate.astro";
+import AccessBadge from "@redeemid/emdash/components/AccessBadge.astro";
 ---
-<Gate collection="posts" terms={post.data.terms}>
-	<PortableText value={post.data.content} />
-	<p slot="locked">{post.data.excerpt}</p>
-</Gate>
+<AccessBadge collection="posts" terms={post.data.terms} content={post.data.content} />
 ```
 
-Add the account box to your header:
+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.
+
+Add the account box and cart to your header. Visitors see Sign in; members see their name, levels, Account and Sign out. The cart shows how many items are in the visitor's Shopify cart and goes to its checkout:
 
 ```astro
 ---
 import Account from "@redeemid/emdash/components/Account.astro";
+import Cart from "@redeemid/emdash/components/Cart.astro";
 ---
 <Account />
+<Cart />
 ```
 
-Sell a plan. `<Plan>` shows a Shopify product's title and price with a button that starts 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:
+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:
 
 ```astro
 ---

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`.
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@redeemid/emdash",
-	"version": "0.0.2",
+	"version": "0.0.4",
 	"description": "Shopify customer accounts, member levels and paywalls for EmDash sites. Shopify runs commerce; EmDash runs content.",
 	"type": "module",
 	"license": "MIT",
@@ -15,6 +15,8 @@
 		"./access": "./src/access.ts",
 		"./guard.ts": "./src/guard.ts",
 		"./storefront": "./src/storefront.ts",
+		"./plugin": "./src/plugin.ts",
+		"./blocks": "./src/blocks/index.ts",
 		"./components/*": "./src/components/*",
 		"./routes/*": "./src/routes/*"
 	},

package/src/access.ts

@@ -34,15 +34,33 @@ export interface Viewer {
 
 export type Reason = "open" | "allowed" | "sign_in" | "upgrade" | "disabled" | "unconfigured";
 
+/**
+ * What an entry needs, in conjunctive form: every clause must pass, and a
+ * clause passes when the reader holds any of its levels. An empty clause means
+ * any signed-in member. `null` means the entry is open to everyone.
+ */
+export type Requirement = string[][] | null;
+
+/**
+ * The built-in level every signed-in member holds, as on WordPress. A clause
+ * with it passes for any signed-in member, like an empty clause.
+ */
+export const SIGNED_IN = "signed-in";
+
 export interface Verdict {
 	allowed: boolean;
 	reason: Reason;
-	/** Levels any of which would unlock the entry. Empty = any signed-in member. */
-	required: string[];
+	/** What the entry needs (see Requirement). `[]` when it is open. */
+	required: string[][];
 	viewer: Viewer;
 }
 
-export type Terms = Record<string, Array<{ slug: string } | string> | undefined>;
+/** A term as EmDash hydrates it onto an entry, or just its slug. */
+export type TermRef = { slug: string; id?: string; parentId?: string | null } | string;
+export type Terms = Record<string, TermRef[] | undefined>;
+
+/** Parent slug by term slug, per taxonomy, for walking up a hierarchy. */
+export type TermTree = Record<string, Record<string, string | null>>;
 
 export function levelsFor(tags: string[], levels: LevelConfig[] = []): string[] {
 	const held = new Set(tags.map((t) => t.toLowerCase()));
@@ -55,25 +73,157 @@ export function levelsFor(tags: string[], levels: LevelConfig[] = []): string[]
 		.map((l) => l.slug);
 }
 
+const slugOf = (t: TermRef) => (typeof t === "string" ? t : t.slug);
+
+/**
+ * The clauses, simplified: duplicates go, a clause that contains another
+ * clause goes (needing Pro already passes "Member or Pro"), and an empty
+ * clause goes when a level clause is there (any level implies signed in).
+ */
+function reduce(clauses: string[][]): string[][] {
+	const seen = new Set<string>();
+	const out: string[][] = [];
+	for (const c of clauses) {
+		const sorted = c.includes(SIGNED_IN) ? [] : [...new Set(c)].sort();
+		const key = sorted.join("|");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(sorted);
+	}
+	const levelled = out.filter((c) => c.length > 0);
+	if (levelled.length === 0) return out;
+	return levelled.filter((c) => !levelled.some((o) => o !== c && o.length < c.length && o.every((l) => c.includes(l))));
+}
+
+function combined(rules: RuleConfig[], mode: "all" | "any"): string[][] {
+	if (mode === "any") {
+		return rules.some((r) => r.levels.length === 0) ? [[]] : [[...new Set(rules.flatMap((r) => r.levels))]];
+	}
+	return reduce(rules.map((r) => r.levels));
+}
+
 /**
- * Required levels for an entry, or null when no rule covers it.
- * Term rules beat collection rules; several matching term rules combine.
+ * 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 requiredLevels(rules: RuleConfig[] = [], collection: string, terms: Terms = {}): string[] | null {
+export function requirement(
+	rules: RuleConfig[] = [],
+	collection: string,
+	terms: Terms = {},
+	options: { combine?: "all" | "any"; tree?: TermTree } = {},
+): Requirement {
+	const mode = options.combine ?? "all";
 	const forCollection = rules.filter((r) => r.collection === collection);
-	const termRules = forCollection.filter((r) => {
-		if (!r.taxonomy || !r.term) return false;
-		const list = terms[r.taxonomy] ?? [];
-		return list.some((t) => (typeof t === "string" ? t : t.slug) === r.term);
+	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] ?? {};
+		for (const ref of list ?? []) {
+			let slug: string | null = slugOf(ref);
+			const seen = new Set<string>();
+			while (slug && !seen.has(slug)) {
+				seen.add(slug);
+				const own = taxRules.filter((r) => r.term === slug);
+				if (own.length > 0) {
+					matched.push(...own);
+					break;
+				}
+				slug = parents[slug] ?? null;
+			}
+		}
+	}
+	if (matched.some((r) => r.open)) return null;
+	if (matched.length > 0) return combined(matched, mode);
+	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;
+}
+
+/** Does someone holding `held` pass `required`? Signed-in membership is checked by the caller. */
+export function passes(held: string[], required: string[][]): boolean {
+	return required.every((clause) => clause.length === 0 || clause.includes(SIGNED_IN) || clause.some((l) => held.includes(l)));
+}
+
+/**
+ * The requirement in words, for badges and admin pages: "Gold + Silver",
+ * "Silver or Gold", "Signed in". `null` gives `open`.
+ */
+export function describe(required: Requirement, levels: LevelConfig[] = [], open = "Free"): string {
+	if (required === null) return open;
+	const name = (slug: string) => levels.find((l) => l.slug === slug)?.name ?? slug;
+	const parts = reduce(required).filter((c) => c.length > 0).map((c) => c.map(name).join(" or "));
+	return parts.length ? parts.join(" + ") : "Signed in";
+}
+
+/**
+ * Parent slugs for the taxonomies whose rules could cover an entry through a
+ * parent term. Reads EmDash's term lists (cached by EmDash) only when a term
+ * on the entry has no rule of its own.
+ */
+export async function termTree(rules: RuleConfig[] = [], collection: string, terms: Terms = {}): Promise<TermTree> {
+	const tree: TermTree = {};
+	const forCollection = rules.filter((r) => r.collection === collection && r.taxonomy && r.term);
+	const wanted = Object.entries(terms).filter(([taxonomy, list]) => {
+		const own = new Set(forCollection.filter((r) => r.taxonomy === taxonomy).map((r) => r.term));
+		return own.size > 0 && (list ?? []).some((t) => !own.has(slugOf(t)));
 	});
-	const chosen = termRules.length > 0 ? termRules : forCollection.filter((r) => !r.taxonomy && !r.term);
-	if (chosen.length === 0) return null;
-	// Any rule that admits every member wins.
-	if (chosen.some((r) => r.levels.length === 0)) return [];
-	return [...new Set(chosen.flatMap((r) => r.levels))];
+	if (wanted.length === 0) return tree;
+	try {
+		const { getTaxonomyTerms } = await import("emdash");
+		for (const [taxonomy] of wanted) {
+			type Node = { id: string; slug: string; parentId?: string | null; children?: Node[] };
+			const flat: Node[] = [];
+			const walk = (list: Node[]) => list.forEach((n) => (flat.push(n), walk(n.children ?? [])));
+			walk((await getTaxonomyTerms(taxonomy)) as Node[]);
+			const byId = new Map(flat.map((n) => [n.id, n.slug]));
+			const byGroup = new Map(flat.map((n) => [(n as { translationGroup?: string | null }).translationGroup ?? n.id, n.slug]));
+			tree[taxonomy] = Object.fromEntries(
+				flat.map((n) => [n.slug, n.parentId ? (byId.get(n.parentId) ?? byGroup.get(n.parentId) ?? null) : null]),
+			);
+		}
+	} catch {
+		// No term lists (outside an EmDash request): only direct term rules apply.
+	}
+	return tree;
+}
+
+/** The entry's requirement with the site's config, walking term parents. */
+export async function entryRequirement(
+	config: RedeemIDConfig | null,
+	collection: string,
+	terms: Terms = {},
+): Promise<Requirement> {
+	if (!config) return null;
+	const tree = await termTree(config.rules, collection, terms);
+	return requirement(config.rules, collection, terms, { combine: config.combine, tree });
 }
 
+const viewers = new WeakMap<object, Promise<Viewer>>();
+
+/** The visitor, read once per request (badges on a list page all ask). */
 export async function viewer(astro: AstroLike): Promise<Viewer> {
+	const key = astro.locals as object;
+	if (key && typeof key === "object") {
+		const known = viewers.get(key);
+		if (known) {
+			const v = await known;
+			if (v.signedIn) astro.response?.headers.set("Cache-Control", "private, no-store");
+			return v;
+		}
+		const fresh = readViewer(astro);
+		viewers.set(key, fresh);
+		return fresh;
+	}
+	return readViewer(astro);
+}
+
+async function readViewer(astro: AstroLike): Promise<Viewer> {
 	const locals = astro.locals as Locals;
 	const user = locals.user;
 	if (!user?.id || user.disabled) return { signedIn: false, member: null, levels: [] };
@@ -90,14 +240,22 @@ export async function viewer(astro: AstroLike): Promise<Viewer> {
 	return { signedIn: true, member, levels };
 }
 
+/**
+ * May this visitor read the entry? `override` replaces the entry's rule, for a
+ * part of a page locked to its own levels (a paywall break with levels).
+ */
 export async function canRead(
 	astro: AstroLike,
 	entry: { collection: string; terms?: Terms },
-	override?: { levels: string[] },
+	override?: { levels: string[] } | { required: string[][] },
 ): Promise<Verdict> {
 	const locals = astro.locals as Locals;
 	const config: RedeemIDConfig | null = siteConfig(locals.emdash?.config);
-	const required = override ? override.levels : requiredLevels(config?.rules, entry.collection, entry.terms);
+	const required: Requirement = override
+		? "required" in override
+			? override.required
+			: [override.levels]
+		: await entryRequirement(config, entry.collection, entry.terms);
 	const v = await viewer(astro);
 
 	if (required === null) return { allowed: true, reason: "open", required: [], viewer: v };
@@ -105,7 +263,7 @@ export async function canRead(
 	if (!v.signedIn) return { allowed: false, reason: "sign_in", required, viewer: v };
 	if (v.member?.status === "disabled") return { allowed: false, reason: "disabled", required, viewer: v };
 	if (!v.member) return { allowed: false, reason: "upgrade", required, viewer: v };
-	const ok = required.length === 0 || required.some((l) => v.levels.includes(l));
+	const ok = passes(v.levels, required);
 	return { allowed: ok, reason: ok ? "allowed" : "upgrade", required, viewer: v };
 }
 
@@ -119,6 +277,16 @@ export function signInUrl(returnTo: string): string {
 	return `/_emdash/api/auth/redeemid/login?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }
 
+/** Where the Cart link goes: the visitor's Shopify checkout. */
+export function cartUrl(returnTo = "/"): string {
+	return `/_emdash/api/auth/redeemid/cart?return=${encodeURIComponent(safeReturn(returnTo))}`;
+}
+
+/** Where the Account link goes: the member's Shopify customer account. */
+export function accountUrl(returnTo = "/"): string {
+	return `/_emdash/api/auth/redeemid/account?return=${encodeURIComponent(safeReturn(returnTo))}`;
+}
+
 export function signOutUrl(returnTo = "/"): string {
 	return `/_emdash/api/auth/redeemid/logout?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }

package/src/astro-modules.d.ts

@@ -0,0 +1,4 @@
+declare module "*.astro" {
+	const Component: (props: Record<string, unknown>) => unknown;
+	export default Component;
+}

package/src/blocks/PaywallBreak.astro

@@ -0,0 +1,6 @@
+---
+/**
+ * The paywall break itself renders nothing. <Content> splits the body here
+ * and leaves out what follows for readers who can't read it.
+ */
+---

package/src/blocks/PlanBlock.astro

@@ -0,0 +1,13 @@
+---
+/** The "Plan" block: a Shopify product with its price and a buy button. */
+import Plan from "../components/Plan.astro";
+
+interface Props {
+	node: { handle?: string; title?: string; label?: string };
+}
+
+const { node } = Astro.props;
+const handle = (node.handle ?? "").trim();
+---
+
+{handle && <Plan handle={handle} title={node.title?.trim() || undefined} label={node.label?.trim() || "Join"} />}

package/src/blocks/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Site-side renderers for RedeemID's Portable Text blocks, picked up by
+ * EmDash from the plugin's `componentsEntry`.
+ */
+import PaywallBreak from "./PaywallBreak.astro";
+import PlanBlock from "./PlanBlock.astro";
+
+export const blockComponents = {
+	"redeemid-paywall": PaywallBreak,
+	"redeemid-plan": PlanBlock,
+};

package/src/blocks-names.ts

@@ -0,0 +1,46 @@
+/** Portable Text block types RedeemID adds to the editor. */
+export const PAYWALL_BLOCK = "redeemid-paywall";
+export const PLAN_BLOCK = "redeemid-plan";
+
+type Node = { _type?: unknown; levels?: unknown };
+
+/**
+ * Split a Portable Text body at its first paywall break: the open part, the
+ * members part, and the levels picked on the break (empty = none picked).
+ * With no break, everything is in `open` and `paywall` is false.
+ */
+export function splitAtPaywall<T>(value: T[] | null | undefined): {
+	open: T[];
+	locked: T[];
+	levels: string[];
+	paywall: boolean;
+} {
+	const blocks = Array.isArray(value) ? value : [];
+	const at = blocks.findIndex((b) => (b as Node)?._type === PAYWALL_BLOCK);
+	if (at === -1) return { open: blocks, locked: [], levels: [], paywall: false };
+	const raw = (blocks[at] as Node).levels;
+	const levels = Array.isArray(raw) ? raw.filter((l): l is string => typeof l === "string" && l !== "") : [];
+	return { open: blocks.slice(0, at), locked: blocks.slice(at + 1), levels, paywall: true };
+}
+
+type TextNode = { _type?: unknown; children?: Array<{ text?: unknown }> };
+
+/**
+ * The text blocks within the first `words` words of a body, as on WordPress:
+ * 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.
+ */
+export function teaser<T>(value: T[] | null | undefined, words: number): T[] {
+	if (!Array.isArray(value) || !(words > 0)) return [];
+	const out: T[] = [];
+	let count = 0;
+	for (const b of value) {
+		const node = b as TextNode;
+		if (node?._type !== "block") continue;
+		const text = (node.children ?? []).map((c) => (typeof c.text === "string" ? c.text : "")).join("");
+		count += text.split(/\s+/).filter(Boolean).length;
+		if (count > words) break;
+		out.push(b);
+	}
+	return out;
+}

package/src/cart.ts

@@ -0,0 +1,25 @@
+/**
+ * The visitor's Shopify cart, kept in the Astro session. Only the cart id
+ * and its item count live here; Shopify holds the lines and the checkout.
+ */
+
+export const SESSION_CART = "redeemid:cart";
+
+export interface CartRef {
+	id: string;
+	count: number;
+}
+
+type Session = { get(key: string): unknown; set(key: string, value: unknown): void; delete?(key: string): void } | undefined;
+
+export async function readCart(session: Session): Promise<CartRef | null> {
+	const v = (await session?.get(SESSION_CART)) as CartRef | undefined;
+	return v && typeof v.id === "string" ? v : null;
+}
+
+export function saveCart(session: Session, cart: CartRef | null): void {
+	if (!session) return;
+	if (cart) session.set(SESSION_CART, cart);
+	else if (session.delete) session.delete(SESSION_CART);
+	else session.set(SESSION_CART, undefined);
+}

package/src/components/AccessBadge.astro

@@ -0,0 +1,45 @@
+---
+/**
+ * The level an entry needs, read from its rules (and from a paywall break
+ * with levels), like the Access Badge block on WordPress:
+ *
+ *   <AccessBadge collection="posts" terms={post.data.terms} content={post.data.content} />
+ *
+ * Open entries show `free` ("Free"; pass free="" to show nothing). The badge
+ * carries `data-redeemid-level` (the level slugs) for styling, and
+ * `is-locked` with a lock for readers who can't read the members part.
+ */
+import { canRead, describe, entryRequirement, type Terms } from "../access.js";
+import { splitAtPaywall } from "../blocks-names.js";
+import { siteConfig } from "../site-config.js";
+
+interface Props {
+	collection: string;
+	terms?: Terms;
+	/** The entry's body, so a paywall break's levels count. */
+	content?: unknown[] | null;
+	free?: string;
+	class?: string;
+}
+
+const { collection, terms, content, free = "Free", class: className } = Astro.props;
+const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
+const split = splitAtPaywall(content);
+const required = split.paywall && split.levels.length
+	? [split.levels]
+	: await entryRequirement(config, collection, terms);
+const label = describe(required, config?.levels, free);
+const locked = required !== null && !(await canRead(Astro, { collection, terms }, { required })).allowed;
+const slugs = required?.flat().join(" ") || (required ? "signed-in" : "free");
+---
+
+{label && (
+	<span
+		class:list={["redeemid-badge", { "is-locked": locked }, className]}
+		data-redeemid-level={slugs}
+	>
+		{locked && <span class="redeemid-badge__lock" aria-hidden="true">🔒&#xFE0E; </span>}
+		{label}
+		{locked && <span style="position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap"> (locked)</span>}
+	</span>
+)}

package/src/components/Account.astro

@@ -1,9 +1,9 @@
 ---
 /**
- * Sign in link for visitors; name, levels and Sign out for members.
+ * Sign in link for visitors; name, levels, Account and Sign out for members.
  */
 import { siteConfig } from "../site-config.js";
-import { signInUrl, signOutUrl, viewer } from "../access.js";
+import { accountUrl, signInUrl, signOutUrl, viewer } from "../access.js";
 
 const v = await viewer(Astro);
 const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
@@ -16,6 +16,7 @@ const names = (config?.levels ?? []).filter((l) => v.levels.includes(l.slug)).ma
 		<>
 			<span class="redeemid-account__who">{v.member?.firstName ?? v.member?.email ?? "Signed in"}</span>
 			{names.length > 0 && <span class="redeemid-account__levels">{names.join(", ")}</span>}
+			<a class="redeemid-account__link" href={accountUrl(here)}>Account</a>
 			<form method="post" action={signOutUrl(here)}>
 				<button type="submit">Sign out</button>
 			</form>

package/src/components/Cart.astro

@@ -0,0 +1,21 @@
+---
+/**
+ * Cart link with the item count from the visitor's Shopify cart. It goes
+ * to that cart's Shopify checkout.
+ */
+import { cartUrl } from "../access.js";
+import { readCart } from "../cart.js";
+
+interface Props {
+	label?: string;
+}
+
+const { label = "Cart" } = Astro.props;
+const ref = await readCart(Astro.session);
+const count = ref?.count ?? 0;
+const here = Astro.url.pathname + Astro.url.search;
+---
+
+<a class="redeemid-cart" href={cartUrl(here)} data-redeemid-cart-count={count}>
+	{label}{count > 0 && <span class="redeemid-cart__count"> ({count})</span>}
+</a>