@supersuit/artifacts 0.61.0 → 0.63.0

package/CHANGELOG.md

@@ -3,6 +3,48 @@
 `@supersuit/artifacts`. One entry per version, newest first. Each entry says what changed, how a
 host can tell whether it is affected (DETECTOR), what a host does about it (REMEDY), and the tests.
 
+## 0.63.0 (2026-11-08)
+
+**Ask for access.** A signed-in visitor turned away at a private page's door (a `links: per-reader`
+page without their link, or an `access:` page that was not shared with their account) can now ask
+the publisher for it, with an optional note of up to 500 characters (`ASK_NOTE_MAX`).
+
+- New route `POST /api/reader/ask` (`ASK`), a plain form post from the door. It records an `asked`
+  flag (the note as `detail`) and sends an `asked` reader event (`note` on `ReaderEvent`), once per
+  visitor per page. The owner, an admin, anyone the page already opens to, and a page that is not
+  private record nothing. It always lands back on the page.
+- After asking, the door says the request was passed on instead of showing the form again.
+- `READ_ALERT_KINDS` gains `asked` (`readAlertsDue({ askedAttempt: true })`, once per reader per page).
+- `summarize()` returns `asked`: who asked, their latest note and when. `FLAG_KINDS` gains `asked`.
+- The form shows only on a host with a reader store (`readers`), since a request needs somewhere to go.
+- DETECTOR: a signed-in visitor at a private page's door has no way to ask for it.
+- REMEDY: update, and mount `app/api/reader/ask/route.ts` (`POST` = `ASK`), as the hub template
+  now does. A host whose read-alert text switches on the alert kind adds a line for `asked`.
+- TESTS: `src/routes/ask-access.test.tsx` (the form on both doors, none signed out or without a
+  reader store, the asked state, the route's recording, note cap and refusals, the alert and the
+  summary), `src/artifacts/read-alerts.test.ts`, `test/hub-template.test.mjs` (the route ships).
+
+## 0.62.0 (2026-11-08)
+
+**The no-link door on a per-reader page says what it is and what to do.** A visitor opening a
+`links: per-reader` page without their link met one line, "This page opens from the link it was sent
+with.", which read as an error and offered nothing to a signed-in reader who was not sent it.
+
+- The door now says the page was shared with specific people, that each has their own link, and to
+  open it from the message it came in or ask the sender for theirs (`NO_LINK` is now the headline,
+  "This page was shared with specific people.").
+- Signed out (with `signInOrigin`): "Think you should have access? Sign in." as a button.
+- Signed in but not sent it: names the account, offers "Use a different account" (the same switch a
+  gated page uses), and records the attempt as a `refused` flag with a `refused` reader event, like a
+  gated page's refusal, so the publisher's read alerts can see it. The door says "This attempt was
+  recorded" only when the record was written. An unfurl fetcher records nothing.
+- A revoked or expired link adds "ask the person who sent it for a new link."
+- Nothing of the page (title, summary, body) is shown before the gate, as before.
+- DETECTOR: a per-reader page's bare address shows only "This page opens from the link it was sent with."
+- REMEDY: update. Nothing to configure. A host that matched the old `NO_LINK` text should read the constant.
+- TESTS: `src/routes/per-reader.test.tsx` (the door's words, the signed-in account and switch link,
+  the refusal recorded and claimed only when a reader store wrote it, the revoked-link line).
+
 ## 0.61.0 (2026-11-08)
 
 **Send outcomes: one success indicator for any send** (issue #12, item 1, and outcomes). A page declares a `goal` (`read` by default, `respond`, `ack`, or `{ click: <cta id> }`); a link titled `cta:<id>` is a CTA whose press the page records through `POST /seen` (`event: click`, under the beat, refused for an id the page does not carry); and every reader's line in `GET /views` and `summarizeViews` gains `lastOpenAt`, `sessions`, `opens`, `clicks`, `goal`, `outcome` (`not-opened`, `opened`, `read`, `returned`, `acted`), `succeeded` and `daysSinceSent`, all under the before-send rule. Thresholds are exported (`OUTCOME_READ_SECONDS` 30, `OUTCOME_RETURN_GAP_MS` one hour) and a host overrides them with `outcomeThresholds` on the routes, `summarizeViews`'s fourth argument, or `?readSeconds=` on `/views`. `ack` is new: the only acknowledgement before was the confidential page's agreement, keyed to a signed-in email, which a per-reader page cannot carry, so `ack` is a press of the CTA named `ack`. `GET /api/artifacts/<id>` answers `goal`. Existing fields are unchanged; a page with no goal reads as `read`; a view stored before clicks reads as none.

package/README.md

@@ -93,6 +93,7 @@ The rest, each exporting the named handler(s) from `artifacts`:
 | `app/api/reader/enter/route.ts` | `GET` = `ENTER` |
 | `app/api/reader/leave/route.ts` | `GET` = `LEAVE` |
 | `app/api/reader/ack/route.ts` | `POST` = `ACK` |
+| `app/api/reader/ask/route.ts` | `POST` = `ASK` (a visitor turned away asks for access; 0.63.0) |
 | `app/api/reader/track/route.ts` | `POST` = `TRACK` |
 | `app/api/artifacts/[id]/resolve/route.ts` | `POST` = `RESOLVE` (see [resolving a thread](#resolving-a-thread)) |
 | `app/api/comments/route.ts` | `GET` = `COMMENTS_FEED` (see [the comments feed](#the-comments-feed)) |

package/lib/artifacts/confidential.d.ts

@@ -34,10 +34,11 @@ export declare function SignInDoor({ brand, href, note }: {
     href?: string;
     note?: string;
 }): import("react").JSX.Element;
-export declare function NotAllowedDoor({ brand, reader, signOutUrl }: {
+export declare function NotAllowedDoor({ brand, reader, signOutUrl, ask }: {
     brand: BrandPack;
     reader: Reader;
     signOutUrl: string;
+    ask?: React.ReactNode;
 }): import("react").JSX.Element;
 /** The agreement a reader makes before a confidential page opens. The exact string is stored
  *  with their acknowledgement, so the record says what they agreed to, not what it says today. */

package/lib/artifacts/confidential.js

@@ -30,8 +30,8 @@ export function SignInDoor({ brand, href, note = DEFAULT_SIGN_IN_NOTE }) {
     }
     return (_jsxs("div", { "data-nospeak": true, className: "mx-auto max-w-sm px-6 pb-24 text-center", children: [_jsx("p", { className: "text-sm opacity-70", children: note }), _jsx("a", { href: href, className: "mt-5 inline-block rounded-lg px-5 py-2 text-sm font-medium", style: { background: brand.accent, color: brand.ground }, children: "Sign in to read" })] }));
 }
-export function NotAllowedDoor({ brand, reader, signOutUrl }) {
-    return (_jsxs("div", { "data-nospeak": true, className: "mx-auto max-w-sm px-6 pb-24 text-center text-sm", children: [_jsxs("p", { className: "opacity-80", children: ["You are signed in as ", reader.email, ", and this page has not been shared with that address. If it was sent to a different address of yours, switch to that account."] }), _jsx("p", { className: "mt-3 opacity-60", children: "This attempt was recorded." }), _jsx("a", { href: signOutUrl, className: "mt-5 inline-block underline", style: { color: brand.accent }, children: "Use a different account" })] }));
+export function NotAllowedDoor({ brand, reader, signOutUrl, ask }) {
+    return (_jsxs("div", { "data-nospeak": true, className: "mx-auto max-w-sm px-6 pb-24 text-center text-sm", children: [_jsxs("p", { className: "opacity-80", children: ["You are signed in as ", reader.email, ", and this page has not been shared with that address. If it was sent to a different address of yours, switch to that account."] }), _jsx("p", { className: "mt-3 opacity-60", children: "This attempt was recorded." }), ask, _jsx("a", { href: signOutUrl, className: "mt-5 inline-block underline", style: { color: brand.accent }, children: "Use a different account" })] }));
 }
 /** The agreement a reader makes before a confidential page opens. The exact string is stored
  *  with their acknowledgement, so the record says what they agreed to, not what it says today. */

package/lib/artifacts/read-alerts.d.ts

@@ -1,5 +1,5 @@
 import type { ReaderSummary } from './readers-store.js';
-export declare const READ_ALERT_KINDS: readonly ["first-open", "refused", "finished", "came-back", "quiet"];
+export declare const READ_ALERT_KINDS: readonly ["first-open", "refused", "asked", "finished", "came-back", "quiet"];
 export type ReadAlertKind = (typeof READ_ALERT_KINDS)[number];
 /** A normal adult reading pace, used to turn a page's word count into its reading time. */
 export declare const WORDS_PER_MINUTE = 230;
@@ -33,6 +33,8 @@ export type ReadAlertInput = {
     } | null;
     /** True when this evaluation is for a refusal at the door that just happened. */
     refusedAttempt?: boolean;
+    /** True when this evaluation is for a request for access that just happened. */
+    askedAttempt?: boolean;
     /** The page's reading time in seconds (`readSecondsFor`). Zero or absent: reaching the end is enough. */
     readSeconds?: number;
     now: string | Date;
@@ -59,10 +61,13 @@ export declare function readAlertsDue(input: ReadAlertInput): ReadAlert[];
  *
  *  - `visit`: a reading heartbeat was recorded (`summary` is their record so far).
  *  - `refused`: a signed-in person was turned away at the door (`reader` is the account tried).
+ *  - `asked`: a signed-in person turned away asked for access (`note` is what they wrote, or null).
  *  - `sweep`: a listed reader, visited by `sweepReaders()` (a daily job) whether or not anything
  *    changed, so a host can notice what did NOT happen (quiet). */
 export type ReaderEvent = {
-    kind: 'visit' | 'refused' | 'sweep';
+    kind: 'visit' | 'refused' | 'asked' | 'sweep';
+    /** `asked` only: the visitor's note to the publisher, trimmed, at most ASK_NOTE_MAX characters. */
+    note?: string | null;
     artifactId: string;
     title: string;
     /** The page's address, e.g. https://artifacts.example.com/abc23456. */

package/lib/artifacts/read-alerts.js

@@ -1,4 +1,4 @@
-export const READ_ALERT_KINDS = ['first-open', 'refused', 'finished', 'came-back', 'quiet'];
+export const READ_ALERT_KINDS = ['first-open', 'refused', 'asked', 'finished', 'came-back', 'quiet'];
 /** A normal adult reading pace, used to turn a page's word count into its reading time. */
 export const WORDS_PER_MINUTE = 230;
 /** How far down counts as reaching the end, in percent of the page. */
@@ -47,6 +47,11 @@ export function readAlertsDue(input) {
     const base = { email, sessions: s?.sessions ?? 0, activeSeconds: s?.activeSeconds ?? 0, maxScroll: s?.maxScroll ?? 0 };
     const fresh = (at) => !!at && now - new Date(at).getTime() <= FRESH_HOURS * HOUR_MS;
     const out = [];
+    if (input.askedAttempt) {
+        if (!sent.has('asked'))
+            out.push({ kind: 'asked', ...base });
+        return out;
+    }
     if (input.refusedAttempt) {
         if (!sent.has('refused'))
             out.push({ kind: 'refused', ...base });

package/lib/artifacts/readers-store.d.ts

@@ -1,6 +1,7 @@
 import { type Firestore } from 'firebase-admin/firestore';
 import type { AllowEntry, Reader } from './reader.js';
-export declare const FLAG_KINDS: readonly ["save", "print", "copy", "image", "devtools", "refused"];
+/** `refused`: turned away at the door. `asked`: asked the publisher for access, `detail` the note. */
+export declare const FLAG_KINDS: readonly ["save", "print", "copy", "image", "devtools", "refused", "asked"];
 export type FlagKind = (typeof FLAG_KINDS)[number];
 export type SessionDoc = {
     artifactId: string;
@@ -95,4 +96,10 @@ export declare function summarize(sessionDocs: SessionDoc[], flagDocs: FlagDoc[]
         attempts: number;
         lastAt: string;
     }[];
+    asked: {
+        email: string;
+        name: string | null;
+        note: string | null;
+        at: string;
+    }[];
 };

package/lib/artifacts/readers-store.js

@@ -12,7 +12,8 @@
 // `base` is the artifacts collection path (`tenants/<id>/artifacts`), so each tenant's record
 // sits next to its own pages.
 import { FieldValue } from 'firebase-admin/firestore';
-export const FLAG_KINDS = ['save', 'print', 'copy', 'image', 'devtools', 'refused'];
+/** `refused`: turned away at the door. `asked`: asked the publisher for access, `detail` the note. */
+export const FLAG_KINDS = ['save', 'print', 'copy', 'image', 'devtools', 'refused', 'asked'];
 /** An email as a map key: lowercased, and with the dots Firestore reads as a path escaped. */
 const keyOf = (email) => email.trim().toLowerCase().replace(/\./g, ',');
 export function createReadersStore(db, base) {
@@ -130,7 +131,13 @@ export function summarize(sessionDocs, flagDocs) {
         by.set(s.email, r);
     }
     const refused = new Map();
+    // Who asked the publisher for access, the latest request each, newest first.
+    const asked = new Map();
     for (const f of flagDocs.slice().sort((a, b) => a.at.localeCompare(b.at))) {
+        if (f.kind === 'asked') {
+            asked.set(f.email, { email: f.email, name: f.name, note: f.detail ?? null, at: f.at });
+            continue;
+        }
         if (f.kind === 'refused') {
             const r = refused.get(f.email) ?? { email: f.email, name: f.name, attempts: 0, lastAt: f.at };
             r.attempts += 1;
@@ -143,5 +150,6 @@ export function summarize(sessionDocs, flagDocs) {
     return {
         readers: [...by.values()].sort((a, b) => b.lastSeen.localeCompare(a.lastSeen)),
         refused: [...refused.values()].sort((a, b) => b.lastAt.localeCompare(a.lastAt)),
+        asked: [...asked.values()].sort((a, b) => b.at.localeCompare(a.at)),
     };
 }

package/lib/routes/artifacts.d.ts

@@ -333,6 +333,7 @@ export declare function createArtifactRoutes(config: ArtifactRoutesConfig): {
     LEAVE: (request: NextRequest) => Promise<NextResponse<unknown>>;
     TRACK: (request: NextRequest) => Promise<NextResponse<unknown>>;
     ACK: (request: NextRequest) => Promise<NextResponse<unknown>>;
+    ASK: (request: NextRequest) => Promise<NextResponse<unknown>>;
     ACCESS: (request: NextRequest, { params }: Params) => Promise<NextResponse<{
         error: string;
     }> | NextResponse<{
@@ -358,6 +359,12 @@ export declare function createArtifactRoutes(config: ArtifactRoutesConfig): {
             attempts: number;
             lastAt: string;
         }[];
+        asked: {
+            email: string;
+            name: string | null;
+            note: string | null;
+            at: string;
+        }[];
         id: string;
         title: string;
         access: Access | null;

package/lib/routes/artifacts.js

@@ -22,7 +22,8 @@ import { CommentLayer } from '../reader/comment-layer.js';
 import { ReaderWatch } from '../reader/reader-watch.js';
 import { UpdatedTime } from '../reader/updated-time.js';
 import { FeedbackWindow } from '../reader/feedback-window.js';
-import { perReaderGate, signInToAct, withPrivateUrls, NO_LINK, UNAVAILABLE } from './per-reader.js';
+import { perReaderGate, signInToAct, withPrivateUrls, UNAVAILABLE } from './per-reader.js';
+import { PerReaderDoor, AskForAccess, ASK_NOTE_MAX } from './per-reader-door.js';
 import { ridCookieName, mintRenderToken, usableSecret, isUnfurlAgent, RID_COOKIE_MAX_AGE } from '../artifacts/recipients.js';
 import { PageMenu } from '../reader/page-menu.js';
 import { COMMENTS_MODES } from '../artifacts/comments.js';
@@ -354,9 +355,16 @@ export function createArtifactRoutes(config) {
             const secret = usableSecret(config.recipientSecret?.());
             const g = await perReaderGate({ id, param, cookie: await readCookie(ridCookieName(id)).catch(() => undefined), secret, recipients: config.recipients });
             if (g.state === 'shut') {
-                return (_jsxs(BrandGround, { pack: pack, mode: a.theme, children: [_jsx("p", { "data-per-reader-shut": true, className: "mx-auto max-w-xl px-6 pt-32 text-center text-lg opacity-80", children: g.why === 'no-link' ? NO_LINK : UNAVAILABLE }), g.why === 'no-link' && !me && signInOrigin
-                            ? _jsxs("p", { "data-per-reader-sign-in": true, className: "mx-auto max-w-xl px-6 pt-4 text-center text-base opacity-70", children: ["Published this page or help run this site? ", _jsx("a", { className: "underline", href: signInUrl(signInOrigin, pageUrl(id)), children: "Sign in" })] })
-                            : null] }));
+                // A signed-in visitor at the no-link door is a refusal like a gated page's: it goes on the
+                // page's record (and to the publisher's read alerts), and the door says so only when it did.
+                let recorded = false;
+                const asked = g.why === 'no-link' && me && config.readers ? await hasAsked(id, me.email) : false;
+                if (g.why === 'no-link' && me && config.readers && !bot && !asked) {
+                    recorded = await config.readers.flag({ artifactId: id, reader: me, kind: 'refused' }).then(() => true, () => false);
+                    if (recorded)
+                        await emitReaderEvent({ kind: 'refused', reader: { email: me.email, name: me.name }, summary: null, entry: null }, a);
+                }
+                return (_jsx(BrandGround, { pack: pack, mode: a.theme, children: _jsx(PerReaderDoor, { brand: brand, why: g.why, reader: me, recorded: recorded, pageId: id, canAsk: !!config.readers, asked: asked, signInHref: signInOrigin ? signInUrl(signInOrigin, pageUrl(id)) : null, switchHref: switchUrl(id) }) }));
             }
             // A fetcher is not the reader: it sets no cookie, carries no render token and sees no note.
             const remember = g.fromLink && !bot
@@ -427,7 +435,7 @@ export function createArtifactRoutes(config) {
                     void flagged;
             }
             return (_jsxs(BrandGround, { pack: pack, mode: a.theme, children: [_jsx(Menu, { a: a, reader: reader, shutOut: d.why === 'not-allowed', settings: await settingsFor(a, reader) }), header, d.why === 'not-allowed'
-                        ? _jsx(NotAllowedDoor, { brand: brand, reader: d.reader, signOutUrl: switchUrl(id) })
+                        ? _jsx(NotAllowedDoor, { brand: brand, reader: d.reader, signOutUrl: switchUrl(id), ask: _jsx(AskForAccess, { brand: brand, pageId: id, canAsk: true, asked: await hasAsked(id, d.reader.email) }) })
                         : _jsx(SignInDoor, { brand: brand, href: signInOrigin ? signInUrl(signInOrigin, here) : undefined, note: config.signInNote })] }));
         }
         const r = reader;
@@ -576,6 +584,51 @@ export function createArtifactRoutes(config) {
         res.headers.append('set-cookie', cookieLine('', 0));
         return res;
     }
+    /** Whether this visitor already asked for access to this page. A failed read reads as not asked. */
+    async function hasAsked(id, email) {
+        if (!config.readers)
+            return false;
+        try {
+            return (await config.readers.flags(id)).some((f) => f.kind === 'asked' && same(f.email, email));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** POST /api/reader/ask: a signed-in visitor turned away at a private page's door asks the
+     *  publisher for access, with an optional note. A plain form post from AskForAccess. Recorded as
+     *  an `asked` flag and told to the host as an `asked` reader event (its read alerts), once per
+     *  visitor per page. Anyone the page already opens to, or a page that is not private, records
+     *  nothing. Always lands back on the page, whose door then says the request was passed on. */
+    async function ASK(request) {
+        const form = await request.formData().catch(() => null);
+        const id = String(form?.get('id') ?? '');
+        if (!ARTIFACT_ID.test(id))
+            return NextResponse.json({ error: 'no page' }, { status: 400 });
+        const back = NextResponse.redirect(`${siteUrl}${pagePath(id)}`, 303);
+        back.headers.set('cache-control', 'no-store');
+        if (!config.readers)
+            return back;
+        const reader = verifyGrant(readerSecret(), request.cookies.get(GRANT_COOKIE)?.value);
+        if (!reader || isAdmin(reader))
+            return back;
+        const a = await store.get(id);
+        if (!a)
+            return back;
+        if (a.access) {
+            if (decide(a.access, reader, await config.readers.allowList(id), false).open)
+                return back;
+        }
+        else if (a.links !== 'per-reader')
+            return back;
+        if (await hasAsked(id, reader.email))
+            return back;
+        const note = String(form?.get('note') ?? '').trim().slice(0, ASK_NOTE_MAX) || null;
+        const ok = await config.readers.flag({ artifactId: id, reader, kind: 'asked', ...(note ? { detail: note } : {}), country: request.headers.get('x-vercel-ip-country') ?? undefined }).then(() => true, () => false);
+        if (ok)
+            await emitReaderEvent({ kind: 'asked', note, reader: { email: reader.email, name: reader.name }, summary: null, entry: null }, a);
+        return back;
+    }
     /** POST /api/reader/ack: the reader agrees to keep the page confidential. A plain form post
      *  from AckDoor; records the exact wording and lands them on the page. Only a reader the page
      *  is open to can agree, and only with the box ticked. */
@@ -1127,5 +1180,5 @@ export function createArtifactRoutes(config) {
             + `<p data-per-reader-shut style="max-width:36rem;padding:0 1.5rem;text-align:center;font-size:1.125rem;opacity:.8">${UNAVAILABLE}</p></body></html>`;
         return new Response(html, { status: 410, headers: { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'x-robots-tag': 'noindex, nofollow' } });
     }
-    return guardRouteTable({ Page, generateMetadata, VersionPage, generateVersionMetadata, VERSIONS, POST, GET, DELETE, LIST, shutPageResponse, PUT_ASSET, UPLOAD, SHARE_IMAGE, ENTER, LEAVE, TRACK, ACK, ACCESS, SETTINGS, READS, sweepReaders, TRANSCRIBE: voiceRoutes.TRANSCRIBE, ...stateRoutes, ...personalRoutes, ...recipientsRoutes, dynamic: 'force-dynamic', maxDuration: 30 });
+    return guardRouteTable({ Page, generateMetadata, VersionPage, generateVersionMetadata, VERSIONS, POST, GET, DELETE, LIST, shutPageResponse, PUT_ASSET, UPLOAD, SHARE_IMAGE, ENTER, LEAVE, TRACK, ACK, ASK, ACCESS, SETTINGS, READS, sweepReaders, TRANSCRIBE: voiceRoutes.TRANSCRIBE, ...stateRoutes, ...personalRoutes, ...recipientsRoutes, dynamic: 'force-dynamic', maxDuration: 30 });
 }

package/lib/routes/per-reader-door.d.ts

@@ -0,0 +1,29 @@
+import type { BrandPack } from '../brand/pack.js';
+import type { Reader } from '../artifacts/reader.js';
+/** The longest note a visitor can send with a request for access. */
+export declare const ASK_NOTE_MAX = 500;
+/** What a signed-in visitor turned away can do about it: ask the publisher, once, with a note.
+ *  `asked` is their request already on the record; `canAsk` false means there is nowhere to keep one. */
+export declare function AskForAccess({ brand, pageId, canAsk, asked }: {
+    brand: BrandPack;
+    pageId: string;
+    canAsk: boolean;
+    asked: boolean;
+}): import("react").JSX.Element | null;
+export declare function PerReaderDoor({ brand, why, reader, signInHref, switchHref, recorded, pageId, canAsk, asked }: {
+    brand: BrandPack;
+    why: 'no-link' | 'revoked' | 'expired' | 'closed';
+    /** The signed-in visitor, when there is one (never the owner or an admin: they get through). */
+    reader: Reader | null;
+    /** Where "Sign in" goes; null when this host cannot sign readers in. */
+    signInHref: string | null;
+    /** Signs out and sends them to choose another account. */
+    switchHref: string;
+    /** The refused attempt was written to the page's record, so the publisher can see it. */
+    recorded: boolean;
+    pageId: string;
+    /** The host keeps a reader record, so a request for access has somewhere to go. */
+    canAsk?: boolean;
+    /** This visitor already asked. */
+    asked?: boolean;
+}): import("react").JSX.Element;

package/lib/routes/per-reader-door.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { NO_LINK, UNAVAILABLE } from './per-reader.js';
+/** The longest note a visitor can send with a request for access. */
+export const ASK_NOTE_MAX = 500;
+/** What a signed-in visitor turned away can do about it: ask the publisher, once, with a note.
+ *  `asked` is their request already on the record; `canAsk` false means there is nowhere to keep one. */
+export function AskForAccess({ brand, pageId, canAsk, asked }) {
+    if (asked)
+        return _jsx("p", { "data-per-reader-asked": true, className: "mt-4 opacity-80", children: "You asked for access. The person who published it has your request, and can send you a link or add this account." });
+    if (!canAsk)
+        return null;
+    return (_jsxs("form", { method: "post", action: "/api/reader/ask", "data-per-reader-ask": true, className: "mx-auto mt-5 max-w-sm text-left", children: [_jsx("input", { type: "hidden", name: "id", value: pageId }), _jsx("label", { className: "block text-sm opacity-80", htmlFor: "ask-note", children: "Add a note for the person who published it (optional)" }), _jsx("textarea", { id: "ask-note", name: "note", maxLength: ASK_NOTE_MAX, rows: 3, className: "mt-2 w-full rounded-lg border bg-transparent px-3 py-2 text-sm", style: { borderColor: brand.accent } }), _jsx("button", { type: "submit", className: "mt-3 w-full rounded-lg px-5 py-2 text-sm font-medium", style: { background: brand.accent, color: brand.ground }, children: "Ask for access" })] }));
+}
+export function PerReaderDoor({ brand, why, reader, signInHref, switchHref, recorded, pageId, canAsk = false, asked = false }) {
+    const wrap = 'mx-auto max-w-md px-6 pt-32 pb-24 text-center';
+    if (why !== 'no-link') {
+        return (_jsxs("div", { "data-nospeak": true, className: wrap, children: [_jsx("p", { "data-per-reader-shut": true, className: "text-lg opacity-80", children: UNAVAILABLE }), _jsx("p", { className: "mt-4 text-sm opacity-70", children: "The link you used was closed. If you still need this page, ask the person who sent it for a new link." })] }));
+    }
+    return (_jsxs("div", { "data-nospeak": true, className: wrap, children: [_jsx("p", { "data-per-reader-shut": true, className: "text-2xl", style: { fontFamily: brand.type.display, color: brand.ink }, children: NO_LINK }), _jsx("p", { className: "mt-4 text-base opacity-80", children: "Everyone it was sent to has their own link. Open it from the message it came in, or ask the person who sent it for yours." }), reader ? (_jsxs("div", { "data-per-reader-not-shared": true, className: "mt-8 text-sm", children: [_jsxs("p", { className: "opacity-80", children: ["You are signed in as ", reader.email, ", and this page was not shared with that account."] }), recorded ? _jsx("p", { className: "mt-2 opacity-60", children: "This attempt was recorded, so the person who published it can see you tried." }) : null, _jsx(AskForAccess, { brand: brand, pageId: pageId, canAsk: canAsk, asked: asked }), _jsx("a", { href: switchHref, className: "mt-4 inline-block underline", style: { color: brand.accent }, children: "Use a different account" })] })) : signInHref ? (_jsxs("div", { "data-per-reader-sign-in": true, className: "mt-8 text-sm", children: [_jsx("p", { className: "opacity-80", children: "Think you should have access? Sign in. The person who published it, and anyone who helps run this site, can open it once signed in." }), _jsx("a", { href: signInHref, className: "mt-4 inline-block rounded-lg px-5 py-2 text-sm font-medium", style: { background: brand.accent, color: brand.ground }, children: "Sign in" })] })) : null] }));
+}

package/lib/routes/per-reader.d.ts

@@ -27,7 +27,9 @@ export declare function signInToAct(page: {
     forwarded?: boolean;
 }): boolean;
 export declare const UNAVAILABLE = "This page is no longer available.";
-export declare const NO_LINK = "This page opens from the link it was sent with.";
+/** The no-link door's headline. Until 0.62.0 it was the whole door ("This page opens from the
+ *  link it was sent with."), which told a visitor neither what kind of page this was nor what to do. */
+export declare const NO_LINK = "This page was shared with specific people.";
 export declare function perReaderGate(o: {
     id: string;
     param: string | undefined;

package/lib/routes/per-reader.js

@@ -10,7 +10,9 @@ export function signInToAct(page, link) {
     return link.group && page.commentName !== 'required' && (!!link.forwarded || (!!page.forward && page.forward !== 'off'));
 }
 export const UNAVAILABLE = 'This page is no longer available.';
-export const NO_LINK = 'This page opens from the link it was sent with.';
+/** The no-link door's headline. Until 0.62.0 it was the whole door ("This page opens from the
+ *  link it was sent with."), which told a visitor neither what kind of page this was nor what to do. */
+export const NO_LINK = 'This page was shared with specific people.';
 export async function perReaderGate(o) {
     // An unset or empty secret verifies nothing: fail closed before any signature is compared.
     if (!o.secret || !o.recipients)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersuit/artifacts",
-  "version": "0.61.0",
+  "version": "0.63.0",
   "description": "Publish markdown as branded, read-aloud pages from a Next.js app: the artifacts store, the route factory, the read-along reader, brand packs, password and confidential pages, and share cards.",
   "license": "MIT",
   "type": "module",

package/template/hub/app/api/reader/ask/route.ts

@@ -0,0 +1,6 @@
+import type { NextRequest } from 'next/server'
+import { hubRoutes } from '@/lib/routes'
+
+export function POST(request: NextRequest) {
+  return hubRoutes().ASK(request)
+}

package/template/hub/package.json

@@ -12,7 +12,7 @@
     "@fontsource/dm-sans": "^5.3.0",
     "@fontsource/dm-serif-display": "^5.3.0",
     "@google-cloud/storage": "^7.22.0",
-    "@supersuit/artifacts": "0.61.0",
+    "@supersuit/artifacts": "0.63.0",
     "firebase": "^12.19.0",
     "firebase-admin": "^13.7.0",
     "next": "^16.0.1",