@redeemid/emdash 0.0.21 → 0.0.23

package/src/access.ts

@@ -10,7 +10,7 @@
  * "entitled".
  */
 
-import type { LevelConfig, RedeemIDConfig, RuleConfig } from "./config.js";
+import { groupsOf, levelTags, type LevelConfig, type RedeemIDConfig, type RuleConfig, type TagGroup } from "./config.js";
 import { UNAVAILABLE, type EntryRule } from "./settings.js";
 import { siteConfig } from "./site-config.js";
 import { memberForUser, stores, type MemberRecord, type MeterRecord } from "./storage.js";
@@ -72,15 +72,78 @@ 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[] {
+export { groupsOf, levelTags, type TagGroup };
+
+function groupPasses(g: TagGroup, held: Set<string>): boolean {
+	const has = (t: string) => held.has(t.toLowerCase());
+	return g.match === "all" ? g.tags.every(has) : g.tags.some(has);
+}
+
+/** Levels the tags grant directly, through one of their own groups, in config order. */
+export function directLevels(tags: string[], levels: LevelConfig[] = []): string[] {
 	const held = new Set(tags.map((t) => t.toLowerCase()));
-	return levels
-		.filter((l) => {
-			if (l.tags.length === 0) return false;
-			const has = (t: string) => held.has(t.toLowerCase());
-			return l.match === "all" ? l.tags.every(has) : l.tags.some(has);
-		})
-		.map((l) => l.slug);
+	return levels.filter((l) => groupsOf(l).some((g) => groupPasses(g, held))).map((l) => l.slug);
+}
+
+/**
+ * Every level holding `slug` opens, itself first: the levels it includes, and
+ * theirs (Gold includes Silver includes Members). Unknown slugs are skipped and
+ * loops stop, so a bad config can't hang.
+ */
+export function closure(slug: string, levels: LevelConfig[] = []): string[] {
+	const bySlug = new Map(levels.map((l) => [l.slug, l]));
+	const seen: string[] = [];
+	const queue = [slug];
+	while (queue.length) {
+		const next = queue.shift()!;
+		if (seen.includes(next) || !bySlug.has(next)) continue;
+		seen.push(next);
+		queue.push(...(bySlug.get(next)!.includes ?? []));
+	}
+	return seen;
+}
+
+/** Does holding `holder` open what needs `needed`? */
+export function covers(holder: string, needed: string, levels: LevelConfig[] = []): boolean {
+	return holder === needed || closure(holder, levels).includes(needed);
+}
+
+/**
+ * The levels a member with these tags holds: the ones their tags grant, and
+ * every level those include. In config order.
+ */
+export function levelsFor(tags: string[], levels: LevelConfig[] = []): string[] {
+	const held = new Set(directLevels(tags, levels).flatMap((s) => closure(s, levels)));
+	return levels.filter((l) => held.has(l.slug)).map((l) => l.slug);
+}
+
+/**
+ * The held levels no other held level includes, for showing a member's
+ * levels: "Gold", not "Gold, Silver", when Gold includes Silver.
+ */
+export function topLevels(held: string[], levels: LevelConfig[] = []): string[] {
+	return held.filter((slug) => !held.some((o) => o !== slug && covers(o, slug, levels) && !covers(slug, o, levels)));
+}
+
+/**
+ * Where a member lands after signing in from the home page or a plain
+ * sign-in link: the `home` of their first top level (in level order) that has
+ * one, or null. Only same-site paths count.
+ */
+export function memberHome(tags: string[], levels: LevelConfig[] = []): string | null {
+	const top = topLevels(levelsFor(tags, levels), levels);
+	for (const level of levels) {
+		if (!top.includes(level.slug) || !level.home) continue;
+		const home = safeReturn(level.home.trim());
+		if (home !== "/") return home;
+	}
+	return null;
+}
+
+/** A level's badge colour when it is a hex colour, else null. */
+export function badgeColor(level: LevelConfig | undefined): string | null {
+	const c = level?.badge?.trim() ?? "";
+	return /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(c) ? c : null;
 }
 
 const slugOf = (t: TermRef) => (typeof t === "string" ? t : t.slug);
@@ -89,12 +152,16 @@ 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).
+ *
+ * With `levels`, inclusion counts too: in "Silver or Gold" Gold goes when it
+ * includes Silver, and "Silver + Gold" needs only Gold.
  */
-function reduce(clauses: string[][]): string[][] {
+function reduce(clauses: string[][], levels?: LevelConfig[]): string[][] {
 	const seen = new Set<string>();
 	const out: string[][] = [];
 	for (const c of clauses) {
-		const sorted = c.includes(SIGNED_IN) ? [] : [...new Set(c)].sort();
+		let sorted = c.includes(SIGNED_IN) ? [] : [...new Set(c)].sort();
+		if (levels?.length) sorted = sorted.filter((l) => !sorted.some((o) => o !== l && covers(l, o, levels) && !covers(o, l, levels)));
 		const key = sorted.join("|");
 		if (seen.has(key)) continue;
 		seen.add(key);
@@ -102,7 +169,14 @@ function reduce(clauses: string[][]): string[][] {
 	}
 	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))));
+	// `o` implies `c` when every level in `o` opens some level in `c`.
+	const implies = (o: string[], c: string[]) => o.every((l) => c.some((x) => (levels?.length ? covers(l, x, levels) : l === x)));
+	return levelled.filter((c) => !levelled.some((o) => o !== c && implies(o, c) && !(implies(c, o) && levelled.indexOf(c) < levelled.indexOf(o))));
+}
+
+/** A requirement simplified with the levels' includes (see reduce). */
+export function simplify(required: Requirement, levels: LevelConfig[] = []): Requirement {
+	return required === null ? null : reduce(required, levels);
 }
 
 function combined(rules: RuleConfig[], mode: "all" | "any"): string[][] {
@@ -229,29 +303,52 @@ export function meterable(rules: RuleConfig[] = [], collection: string, terms: T
 }
 
 /**
- * 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.
+ * When each held level started, by slug (ISO, or null when unknown). A group
+ * starts when its first tag arrived ("any") or its last one ("all"); a level
+ * starts with its earliest passing group, and a level held only because
+ * another includes it starts with the earliest of those.
  */
-export function memberSince(member: MemberRecord, levels: LevelConfig[] = []): string | null {
+export function levelStarts(member: MemberRecord, levels: LevelConfig[] = []): Map<string, string | null> {
 	const since = member.tagsSince ?? {};
-	const starts: string[] = [];
+	const heldTags = new Set(member.tags.map((t) => t.toLowerCase()));
+	const direct = new Map<string, string | null>();
+	for (const level of levels) {
+		const starts: string[] = [];
+		let passing = false;
+		for (const g of groupsOf(level)) {
+			if (!groupPasses(g, heldTags)) continue;
+			passing = true;
+			const dates = g.tags.filter((t) => heldTags.has(t.toLowerCase())).map((t) => since[t.toLowerCase()]).filter((d): d is string => Boolean(d)).sort();
+			const pick = g.match === "all" ? dates.at(-1) : dates[0];
+			if (pick) starts.push(pick);
+		}
+		if (passing) direct.set(level.slug, starts.sort()[0] ?? null);
+	}
+	const out = new Map<string, string | null>();
 	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);
+		const dates = [...direct.entries()].filter(([d]) => closure(d, levels).includes(slug)).map(([, at]) => at).filter((d): d is string => Boolean(d)).sort();
+		out.set(slug, dates[0] ?? null);
 	}
-	starts.sort();
+	return out;
+}
+
+/**
+ * When a member's membership started, for drip: the earliest start among the
+ * levels they hold now (see levelStarts), else when they first signed in.
+ * Null when neither is known.
+ */
+export function memberSince(member: MemberRecord, levels: LevelConfig[] = []): string | null {
+	const starts = [...levelStarts(member, levels).values()].filter((d): d is string => Boolean(d)).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. */
+	/** When the level started (see levelStarts), ISO, or null when unknown. */
 	since: string | null;
+	/** Set when the member holds it only because a level they hold includes it: that level's slug. */
+	via?: string;
 }
 
 export interface PastLevel {
@@ -267,15 +364,18 @@ export interface PastLevel {
  */
 export function membership(member: MemberRecord, levels: LevelConfig[] = []): { current: HeldLevel[]; past: PastLevel[] } {
 	const held = levelsFor(member.tags, levels);
+	const direct = directLevels(member.tags, levels);
+	const starts = levelStarts(member, 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 via = direct.includes(slug) ? undefined : direct.find((d) => closure(d, levels).includes(slug));
+		return { slug, name: level.name, since: starts.get(slug) ?? null, ...(via ? { via } : {}) };
 	});
 	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 wanted = new Set(levelTags(level));
 		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();
@@ -340,7 +440,7 @@ export function passes(held: string[], required: string[][]): boolean {
 export function describe(required: Requirement, levels: LevelConfig[] = [], open = "Free", signedIn = "Signed in"): string {
 	if (required === null) return open;
 	const name = (slug: string) => (slug === UNAVAILABLE ? "Members" : (levels.find((l) => l.slug === slug)?.name ?? slug));
-	const parts = reduce(required).filter((c) => c.length > 0).map((c) => c.map(name).join(" or "));
+	const parts = reduce(required, levels).filter((c) => c.length > 0).map((c) => c.map(name).join(" or "));
 	return parts.length ? parts.join(" + ") : signedIn;
 }
 
@@ -392,7 +492,7 @@ export async function entryRequirement(
 	const own = entryRuleFor(config, collection, id);
 	if (own && (own.mode === "open" || own.mode === "levels") && !own.openUntil && !own.lockedUntil) return applyEntryRule(null, own);
 	const tree = await termTree(config.rules, collection, terms);
-	return applyEntryRule(requirement(config.rules, collection, terms, { combine: config.combine, tree }), own);
+	return simplify(applyEntryRule(requirement(config.rules, collection, terms, { combine: config.combine, tree }), own), config.levels);
 }
 
 const viewers = new WeakMap<object, Promise<Viewer>>();

package/src/agents.ts

@@ -10,7 +10,7 @@
  */
 
 import { adminConfigured } from "./admin-api.js";
-import { applyEntryRule, entryRuleFor, describe as describeRequirement, dripDays, levelsFor, membership, passes, requirement, termTree, type Requirement, type Terms } from "./access.js";
+import { applyEntryRule, entryRuleFor, groupsOf, simplify, describe as describeRequirement, dripDays, levelsFor, membership, passes, requirement, termTree, type Requirement, type Terms } from "./access.js";
 import { ENV, env, storeDomain, unknownEnvNames, type RedeemIDConfig } from "./config.js";
 import { featuresFor } from "./features.js";
 import { bodyClauses } from "./files.js";
@@ -69,10 +69,10 @@ export async function explainAccess(config: RedeemIDConfig, s: Stores, input: Ex
 	const disabled = member?.status === "disabled";
 	const held = disabled ? [] : levelsFor(tags, levels);
 	const tree = await termTree(config.rules, collection, terms);
-	const required: Requirement = applyEntryRule(requirement(config.rules, collection, terms, { combine: config.combine, tree }), own);
+	const required: Requirement = simplify(applyEntryRule(requirement(config.rules, collection, terms, { combine: config.combine, tree }), own), levels);
 	const owned = !disabled && holdsItem(item, tags);
 	const canReadRule = owned || required === null || (signedIn && !disabled && passes(held, required));
-	const name = (slug: string) => levels.find((l) => l.slug === slug)?.name ?? slug;
+	const name = (slug: string) => (slug === "signed-in" ? "Signed in" : (levels.find((l) => l.slug === slug)?.name ?? slug));
 	const partResults = parts.map((clause) => ({
 		needs: clause.map(name),
 		canRead: owned || (signedIn && !disabled && (clause.includes("signed-in") || clause.some((l) => held.includes(l)))),
@@ -101,7 +101,7 @@ export async function explainAccess(config: RedeemIDConfig, s: Stores, input: Ex
 }
 
 export function listLevels(config: RedeemIDConfig): Array<Record<string, unknown>> {
-	return (config.levels ?? []).map((l) => ({ slug: l.slug, name: l.name, tags: l.tags, match: l.match ?? "any", wall: l.wall ?? null, joinUrl: l.joinUrl ?? null }));
+	return (config.levels ?? []).map((l) => ({ slug: l.slug, name: l.name, groups: groupsOf(l).map((g) => ({ tags: g.tags, match: g.match ?? "any" })), includes: l.includes ?? [], wall: l.wall ?? null, joinUrl: l.joinUrl ?? null }));
 }
 
 export function getRules(config: RedeemIDConfig): Record<string, unknown> {

package/src/api-version.ts

@@ -3,4 +3,4 @@
  * when something is added, the major part when something stable changes or
  * goes. Separate from the package version.
  */
-export const API_VERSION = "1.1.0";
+export const API_VERSION = "1.3.0";

package/src/blocks-names.ts

@@ -62,7 +62,8 @@ type TextNode = { _type?: unknown; children?: Array<{ text?: unknown }> };
 /**
  * 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.
+ * teaser. Images and custom blocks are left out. A "Members only" part ends
+ * it too: its text is never teaser. 0 gives nothing.
  */
 export function teaser<T>(value: T[] | null | undefined, words: number): T[] {
 	if (!Array.isArray(value) || !(words > 0)) return [];
@@ -70,6 +71,7 @@ export function teaser<T>(value: T[] | null | undefined, words: number): T[] {
 	let count = 0;
 	for (const b of value) {
 		const node = b as TextNode;
+		if (node?._type === MEMBERS_BLOCK) break;
 		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;

package/src/components/AccessBadge.astro

@@ -9,7 +9,7 @@
  * 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, viewer, type Terms } from "../access.js";
+import { badgeColor, canRead, describe, entryRequirement, simplify, viewer, type Terms } from "../access.js";
 import { holdsItem, soldItem, splitAtPaywall } from "../blocks-names.js";
 import { siteConfig } from "../site-config.js";
 import { text } from "../text.js";
@@ -37,12 +37,15 @@ const owner = item ? (await viewer(Astro)).member : null;
 const owned = Boolean(owner && owner.status !== "disabled" && holdsItem(item, owner.tags));
 const locked = required !== null && !owned && !(await canRead(Astro, { collection, terms, id }, { required })).allowed;
 const slugs = required?.flat().join(" ") || (required ? "signed-in" : "free");
+// The colour of the level the badge names first, when that level has one.
+const color = badgeColor(config?.levels?.find((l) => l.slug === simplify(required, config?.levels)?.find((c) => c.length)?.[0]));
 ---
 
 {label && (
 	<span
 		class:list={["redeemid-badge", { "is-locked": locked }, className]}
 		data-redeemid-level={slugs}
+		style={color ? `--redeemid-level-color: ${color}` : undefined}
 	>
 		{locked && <span class="redeemid-badge__lock" aria-hidden="true">🔒&#xFE0E; </span>}
 		{label}

package/src/components/Account.astro

@@ -3,20 +3,31 @@
  * Sign in link for visitors; name, levels, Account and Sign out for members.
  */
 import { siteConfig } from "../site-config.js";
-import { accountUrl, signInUrl, signOutUrl, viewer } from "../access.js";
+import { accountUrl, badgeColor, signInUrl, signOutUrl, topLevels, viewer } from "../access.js";
 import { text } from "../text.js";
 
 const v = await viewer(Astro);
 const config = await siteConfig(Astro.locals);
 const here = Astro.url.pathname + Astro.url.search;
-const names = (config?.levels ?? []).filter((l) => v.levels.includes(l.slug)).map((l) => l.name);
+// "Gold", not "Gold, Silver", when Gold includes Silver.
+const top = topLevels(v.levels, config?.levels);
+const held = (config?.levels ?? []).filter((l) => top.includes(l.slug));
 ---
 
 <div class="redeemid-account" data-redeemid-signed-in={v.signedIn ? "true" : "false"}>
 	{v.signedIn ? (
 		<>
 			<span class="redeemid-account__who">{v.member?.firstName ?? v.member?.email ?? text(config, "Signed in")}</span>
-			{names.length > 0 && <span class="redeemid-account__levels">{names.join(", ")}</span>}
+			{held.length > 0 && (
+				<span class="redeemid-account__levels">
+					{held.map((l, i) => (
+						<>
+							{i > 0 && ", "}
+							<span data-redeemid-level={l.slug} style={badgeColor(l) ? `--redeemid-level-color: ${badgeColor(l)}` : undefined}>{l.name}</span>
+						</>
+					))}
+				</span>
+			)}
 			<a class="redeemid-account__link" href={accountUrl(here)}>{text(config, "Account")}</a>
 			<form method="post" action={signOutUrl(here)}>
 				<button type="submit">{text(config, "Sign out")}</button>

package/src/components/LockedPanel.astro

@@ -10,7 +10,7 @@
  */
 import { membership, passes, refreshUrl, signInUrl, viewer, type Reason } from "../access.js";
 import type { SoldItem } from "../blocks-names.js";
-import { plan as loadPlan } from "../storefront.js";
+import { money, plan as loadPlan, storeContext } from "../storefront.js";
 import { siteConfig } from "../site-config.js";
 import { text, textParts } from "../text.js";
 
@@ -48,10 +48,9 @@ const week = meterPeriod === "week";
 let single: { handle: string; price: string } | null = null;
 if (item?.product && config && (reason === "sign_in" || reason === "upgrade" || reason === "drip")) {
 	try {
-		const p = await loadPlan(config, item.product);
-		if (p?.availableForSale && p.price) {
-			single = { handle: p.handle, price: new Intl.NumberFormat("en-US", { style: "currency", currency: p.price.currencyCode }).format(Number(p.price.amount)) };
-		}
+		const p = await loadPlan(config, item.product, undefined, storeContext(config, Astro.request));
+		const price = p?.availableForSale ? money(p.price) : null;
+		if (p && price) single = { handle: p.handle, price };
 	} catch {
 		single = null;
 	}

package/src/components/MemberCard.astro

@@ -11,7 +11,7 @@
  * 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 { accountUrl, badgeColor, membership, meterUsage, refreshUrl, signInUrl, signOutUrl, viewer } from "../access.js";
 import { featuresFor } from "../features.js";
 import { siteConfig } from "../site-config.js";
 import { text, textParts } from "../text.js";
@@ -29,6 +29,7 @@ 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 color = (slug: string) => badgeColor(config?.levels?.find((l) => l.slug === slug));
 const held = m ? featuresFor(m, config?.features, config?.levels) : [];
 const features = (config?.features ?? []).filter((f) => held.includes(f.slug));
 const date = (iso: string | null) => {
@@ -59,8 +60,8 @@ const join = config?.join;
 				<p class="redeemid-member__disabled">{text(config, "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}>
+					{current.filter((l) => !l.via).map((l) => (
+						<li data-redeemid-level={l.slug} style={color(l.slug) ? `--redeemid-level-color: ${color(l.slug)}` : undefined}>
 							<strong>{l.name}</strong>
 							{(dates.since ? day(dates.since) : date(l.since)) && <> {textParts(config, "since {date}", { date: <time datetime={dates.since ?? l.since ?? undefined}>{dates.since ? day(dates.since) : date(l.since)}</time> })}</>}
 						</li>

package/src/components/Plan.astro

@@ -6,13 +6,18 @@
  *
  *   <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, and a member who held one before (Shopify removed
- * its tag) sees "Renew" instead of "Join".
+ * `levels` are the levels the plan gives; left out, they are the levels
+ * whose `products` list the handle. Then the card fits the member:
+ *
+ * - held: they hold one of them through its own tags: "You're on this plan."
+ * - included: a level they hold includes it: "Included in your Gold membership."
+ * - upgrade: the plan's level includes one they hold: the button says "Upgrade".
+ * - renew: they held one before (Shopify removed its tag): "Renew".
+ * - join: anyone else.
  */
-import { membership, viewer } from "../access.js";
+import { closure, directLevels, membership, topLevels, viewer } from "../access.js";
 import { siteConfig } from "../site-config.js";
-import { plan as loadPlan, type Plan } from "../storefront.js";
+import { money, plan as loadPlan, storeContext, type Plan } from "../storefront.js";
 import { text } from "../text.js";
 
 interface Props {
@@ -21,45 +26,59 @@ 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. */
+	/** The levels this plan gives. Defaults to the levels whose `products` list `handle`. */
 	levels?: string[];
 	heldLabel?: string;
 	/** Button text for a member whose plan lapsed. */
 	renewLabel?: string;
+	/** Button text for a member this plan would move up. */
+	upgradeLabel?: string;
 }
 
 const config = await siteConfig(Astro.locals);
-const { handle, label = text(config, "Join"), title, levels = [], heldLabel = text(config, "You're on this plan."), renewLabel = text(config, "Renew") } = Astro.props;
+const { handle, label = text(config, "Join"), title, heldLabel = text(config, "You're on this plan."), renewLabel = text(config, "Renew"), upgradeLabel = text(config, "Upgrade") } = Astro.props;
+const all = config?.levels ?? [];
+const levels = Astro.props.levels?.length ? Astro.props.levels : all.filter((l) => l.products?.some((h) => h.toLowerCase() === handle.toLowerCase())).map((l) => l.slug);
 let p: Plan | null = null;
 if (config) {
 	try {
-		p = await loadPlan(config, handle);
+		// The visitor's market, so the price is the one checkout charges.
+		p = await loadPlan(config, handle, undefined, storeContext(config, Astro.request));
 	} catch {
 		p = null;
 	}
 }
-const price = p?.price
-	? new Intl.NumberFormat("en-US", { style: "currency", currency: p.price.currencyCode }).format(Number(p.price.amount))
-	: null;
+const price = money(p?.price);
 const here = Astro.url.pathname + Astro.url.search;
 const v = levels.length > 0 ? await viewer(Astro) : null;
-const held = Boolean(v?.levels.some((l) => levels.includes(l)));
+const live = v?.member && v.member.status !== "disabled" ? v.member : null;
+const direct = live ? directLevels(live.tags, all) : [];
+const top = topLevels(v?.levels ?? [], all);
+const held = levels.some((l) => direct.includes(l));
+// Held only through a bigger level: name that one.
+const via = held ? undefined : top.find((t) => levels.some((l) => t !== l && closure(t, all).includes(l)));
+const viaName = via ? (all.find((l) => l.slug === via)?.name ?? via) : null;
+// The plan's level includes one the member holds: it moves them up.
+const upgrade = !held && !via && top.length > 0 && levels.some((l) => top.some((t) => t !== l && closure(l, all).includes(t)));
 // Lapsed: held one of these levels before. Offered their plan back, not "Join" as if new.
-const lapsed = Boolean(!held && v?.member && v.member.status !== "disabled" && membership(v.member, config?.levels).past.some((p) => levels.includes(p.slug)));
+const lapsed = Boolean(!held && !via && live && membership(live, all).past.some((p) => levels.includes(p.slug)));
+const state = held ? "held" : via ? "included" : upgrade ? "upgrade" : lapsed ? "renew" : "join";
 ---
 
 {p ? (
-	<div class:list={["redeemid-plan", { "is-held": held, "is-lapsed": lapsed }]} data-redeemid-plan={p.handle} data-redeemid-state={held ? "held" : lapsed ? "renew" : "join"}>
+	<div class:list={["redeemid-plan", { "is-held": held || Boolean(via), "is-lapsed": lapsed }]} data-redeemid-plan={p.handle} data-redeemid-state={state}>
 		<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>}
 		{held ? (
 			<p class="redeemid-plan__held">{heldLabel}</p>
+		) : viaName ? (
+			<p class="redeemid-plan__held">{text(config, "Included in your {level} membership.", { level: viaName })}</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} />
-				<button type="submit">{lapsed ? renewLabel : label}</button>
+				<button type="submit">{upgrade ? upgradeLabel : lapsed ? renewLabel : label}</button>
 			</form>
 		) : (
 			<p class="redeemid-plan__unavailable">{text(config, "Not available right now.")}</p>

package/src/config.ts

@@ -15,14 +15,65 @@ export interface LevelConfig {
 	slug: string;
 	/** Name shown to members. */
 	name: string;
-	/** Shopify customer tags that grant this level. Matched case-insensitively. */
-	tags: string[];
-	/** "any" (default): one of the tags is enough. "all": every tag is needed. */
+	/**
+	 * Shopify customer tags that grant this level. Matched case-insensitively.
+	 * This is the level's first tag group; `groups` adds more.
+	 */
+	tags?: string[];
+	/** For `tags`: "any" (default): one of the tags is enough. "all": every tag is needed. */
 	match?: "any" | "all";
+	/**
+	 * More tag groups, any one of which also grants the level: a level that is
+	 * "gold", or "silver" and "annual", is `tags: ["gold"]` with
+	 * `groups: [{ tags: ["silver", "annual"], match: "all" }]`.
+	 */
+	groups?: TagGroup[];
+	/**
+	 * Slugs of levels this one also opens: Gold with `includes: ["silver"]`
+	 * reads everything for Silver. Inclusion carries on (Gold includes Silver
+	 * includes Members), so rules name only the lowest level that may read.
+	 */
+	includes?: string[];
 	/** What the wall says to readers this level would let in, e.g. "Gold members read every investigation." */
 	wall?: string;
 	/** Where the wall's join link goes for this level. Falls back to `join.href`. */
 	joinUrl?: string;
+	/**
+	 * Handles of the Shopify products whose purchase leads to this level
+	 * (Flow or an app tags the buyer). Display only: plan cards use it to say
+	 * "You're on this plan", "Included in your Gold membership" or "Upgrade".
+	 * It grants nothing.
+	 */
+	products?: string[];
+	/**
+	 * Members' home: a same-site path members of this level land on after
+	 * signing in from the home page or a plain sign-in link, e.g. "/members/gold/".
+	 * Signing in from an entry returns them to it.
+	 */
+	home?: string;
+	/** Badge colour, a hex such as "#c9a227", set as `--redeemid-level-color` on badges and level names. Badges always show the name too. */
+	badge?: string;
+}
+
+/** One way to hold a level: any one of `tags`, or every one with `match: "all"`. */
+export interface TagGroup {
+	tags: string[];
+	match?: "any" | "all";
+}
+
+/** A level's tag groups: `tags`/`match` first, then `groups`. Empty groups are dropped. */
+export function groupsOf(level: LevelConfig): TagGroup[] {
+	const out: TagGroup[] = [];
+	if (level.tags?.length) out.push({ tags: level.tags, ...(level.match === "all" ? { match: "all" as const } : {}) });
+	for (const g of level.groups ?? []) {
+		if (g && Array.isArray(g.tags) && g.tags.length) out.push({ tags: g.tags, ...(g.match === "all" ? { match: "all" as const } : {}) });
+	}
+	return out;
+}
+
+/** Every tag any of the level's groups names, lower case. */
+export function levelTags(level: LevelConfig): string[] {
+	return [...new Set(groupsOf(level).flatMap((g) => g.tags.map((t) => t.toLowerCase())))];
 }
 
 /**

package/src/contract.ts

@@ -16,13 +16,14 @@ export { API_VERSION } from "./api-version.js";
 /** Stable exports, by import path. */
 export const MODULES = {
 	"@redeemid/emdash": ["redeemid", "redeemidGuard", "redeemidPlugin"],
-	"@redeemid/emdash/access": ["siteConfig", "viewer", "canRead", "readEntry", "entryRequirement", "meterUsage", "membership", "levelsFor", "signInUrl", "signOutUrl", "accountUrl", "cartUrl", "refreshUrl", "safeReturn"],
+	"@redeemid/emdash/access": ["siteConfig", "viewer", "canRead", "readEntry", "entryRequirement", "meterUsage", "membership", "levelsFor", "topLevels", "closure", "simplify", "signInUrl", "signOutUrl", "accountUrl", "cartUrl", "refreshUrl", "safeReturn"],
 	"@redeemid/emdash/features": ["hasFeature", "viewerFeatures", "featuresFor"],
 	"@redeemid/emdash/preferences": ["readPreferences", "savePreferences", "preferenceFields"],
 	"@redeemid/emdash/storefront": ["plan", "product", "collection", "money", "realOptions", "variantFor", "storeContext", "cartDetails", "addToCart", "updateLines", "removeLines", "setDiscountCodes"],
 	"@redeemid/emdash/catalog": ["searchProducts", "collectionPage", "suggest", "recommendations", "browseFromUrl", "browseHref", "parseFilters", "priceFilter", "SORTS"],
 	"@redeemid/emdash/events": ["signBody"],
 	"@redeemid/emdash/text": ["STRINGS", "text", "textParts"],
+	"@redeemid/emdash/search": ["readableResults"],
 } as const;
 
 /** Public JSON routes under /_emdash/api/auth/redeemid/. */

package/src/events.ts

@@ -7,7 +7,7 @@
  * Headers: X-RedeemID-Event (the name), X-RedeemID-Delivery (a fresh id) and
  * X-RedeemID-Signature: sha256=<hex HMAC of the raw body>. Events:
  * member.signed_in, member.levels_changed, meter.used, meter.exhausted,
- * preferences.saved.
+ * preferences.saved, member.erased.
  * Sending never blocks or breaks the page: events go out after the response
  * (waitUntil on Workers), are tried three times, and one that fails every
  * try is kept under App events → Failed events, where staff can send it