@saypsst/next 0.0.0-stage → 0.3.0

package/dist/config-LILlPYgW.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+/** Revalidation period of every psst route, in seconds. Route files must repeat it as a literal. */
+declare const PSST_REVALIDATE = 300;
+/** Default psst edge. */
+declare const DEFAULT_EDGE = "https://edge.saypsst.com";
+declare const configSchema: z.ZodObject<{
+    site: z.ZodString;
+    domain: z.ZodString;
+    siteName: z.ZodString;
+    prefix: z.ZodDefault<z.ZodString>;
+    rootPaths: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "/about": "/about";
+        "/llms.txt": "/llms.txt";
+    }>>>;
+    edge: z.ZodDefault<z.ZodString>;
+    serveFromEdge: z.ZodDefault<z.ZodBoolean>;
+    shell: z.ZodOptional<z.ZodObject<{
+        nav: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            href: z.ZodString;
+        }, z.core.$strict>>>;
+        footer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type PsstConfigInput = z.input<typeof configSchema>;
+/** Validated psst configuration. Create it with `definePsst()` in `psst.config.ts`. */
+interface PsstConfig {
+    readonly site: string;
+    readonly domain: string;
+    readonly siteName: string;
+    readonly prefix: string;
+    readonly rootPaths: readonly ("/about" | "/llms.txt")[];
+    /** Edge origin without a trailing slash. */
+    readonly edge: string;
+    /** Psst paths are rewritten to the edge by `withPsst()` instead of served by route files. */
+    readonly serveFromEdge: boolean;
+    readonly shell?: {
+        readonly nav?: readonly {
+            readonly label: string;
+            readonly href: string;
+        }[];
+        readonly footer?: string;
+    };
+}
+declare class PsstConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validate the site's psst configuration. Throws `PsstConfigError` on invalid input, so a bad config fails the
+ * build instead of serving broken pages.
+ */
+declare function definePsst(input: PsstConfigInput): PsstConfig;
+
+export { DEFAULT_EDGE as D, PSST_REVALIDATE as P, type PsstConfig as a, PsstConfigError as b, type PsstConfigInput as c, definePsst as d };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { D as DEFAULT_EDGE, P as PSST_REVALIDATE, a as PsstConfig, b as PsstConfigError, c as PsstConfigInput, d as definePsst } from './config-LILlPYgW.js';
+import 'zod';
+
+/** Kept equal to package.json `version` (checked by test/version.test.ts). */
+declare const PSST_NEXT_VERSION = "0.3.0";
+
+export { PSST_NEXT_VERSION };

package/dist/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_EDGE, PSST_REVALIDATE, PsstConfigError, definePsst } from './chunk-2NMIB353.js';
+export { PSST_NEXT_VERSION } from './chunk-X3GT7AOS.js';

package/dist/llms.d.ts

@@ -0,0 +1,8 @@
+import { a as PsstConfig } from './config-LILlPYgW.js';
+export { P as PSST_REVALIDATE } from './config-LILlPYgW.js';
+import 'zod';
+
+/** `GET` for `app/llms.txt/route.ts`, only when the dashboard claimed `/llms.txt` (`rootPaths`). */
+declare function psstLlms(config: PsstConfig): () => Promise<Response>;
+
+export { psstLlms };

package/dist/llms.js

@@ -0,0 +1,16 @@
+import { edgeFileRoute } from './chunk-QE3BBW25.js';
+import './chunk-ELYUDQHH.js';
+import { PsstConfigError } from './chunk-2NMIB353.js';
+export { PSST_REVALIDATE } from './chunk-2NMIB353.js';
+import './chunk-ZELUPPQB.js';
+import './chunk-X3GT7AOS.js';
+
+// src/llms.ts
+function psstLlms(config) {
+  if (!config.rootPaths.includes("/llms.txt")) {
+    throw new PsstConfigError("/llms.txt is not in rootPaths; PSST only serves root paths the dashboard claimed");
+  }
+  return edgeFileRoute(config, { path: "/llms.txt", type: "text/plain", maxBytes: 512 * 1024 });
+}
+
+export { psstLlms };

package/dist/page.d.ts

@@ -0,0 +1,41 @@
+import { Metadata } from 'next';
+import { ReactNode, ComponentType } from 'react';
+import { a as PsstConfig } from './config-LILlPYgW.js';
+export { P as PSST_REVALIDATE } from './config-LILlPYgW.js';
+import 'zod';
+
+/** Props your `Shell` receives: the psst `<main>` element. Render your header and footer around it. */
+interface PsstShellProps {
+    children: ReactNode;
+}
+interface PsstPageOptions {
+    /** Your site's header/footer wrapper. Without it, psst renders a minimal header (brand + `shell.nav`) and footer. */
+    Shell?: ComponentType<PsstShellProps>;
+    /** Serve one fixed root path (`/about`) instead of `{prefix}/[...slug]`. Must be in `rootPaths`. */
+    path?: "/about";
+}
+/** Params of the catch-all route `{prefix}/[...slug]`. A fixed-path page gets none. */
+interface PsstPageProps {
+    params: Promise<{
+        slug?: string[];
+    }>;
+}
+interface PsstPageModule {
+    default: (props: PsstPageProps) => Promise<ReactNode>;
+    generateMetadata: (props: PsstPageProps) => Promise<Metadata>;
+    generateStaticParams: () => Promise<{
+        slug: string[];
+    }[]>;
+}
+/** The served document failed the content contract or its hash. Thrown so ISR keeps the last good render. */
+declare class PsstIntegrityError extends Error {
+    constructor(message: string);
+}
+/**
+ * Build the page module for `app/(psst){prefix}/[...slug]/page.tsx` (or a fixed root path such as `/about`).
+ * The route file must also export the literals `revalidate = 300` and `dynamicParams = true`: Next reads route
+ * segment config statically, so it cannot come from a package.
+ */
+declare function psstPage(config: PsstConfig, options?: PsstPageOptions): PsstPageModule;
+
+export { PsstIntegrityError, type PsstPageModule, type PsstPageOptions, type PsstPageProps, type PsstShellProps, psstPage };

package/dist/page.js

@@ -0,0 +1,190 @@
+import { isBuildPhase } from './chunk-ELYUDQHH.js';
+import { PsstConfigError } from './chunk-2NMIB353.js';
+export { PSST_REVALIDATE } from './chunk-2NMIB353.js';
+import { fetchManifest, PsstUnavailableError, fetchPage } from './chunk-ZELUPPQB.js';
+import { ContentError, parsePageDocument, hashDocument, shortHash, serializeJsonForScript, buildJsonLd, sitePathSchema, factValue } from './chunk-X3GT7AOS.js';
+import { notFound } from 'next/navigation';
+import { connection } from 'next/server';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+function linkProps(href) {
+  return href.startsWith("/") ? { href } : { href, rel: "noopener" };
+}
+function InlineContent({ items }) {
+  return items.map((i, n) => {
+    switch (i.type) {
+      case "text":
+        return i.text;
+      case "strong":
+        return /* @__PURE__ */ jsx("strong", { children: i.text }, n);
+      case "em":
+        return /* @__PURE__ */ jsx("em", { children: i.text }, n);
+      case "link":
+        return /* @__PURE__ */ jsx("a", { ...linkProps(i.href), children: i.text }, n);
+    }
+  });
+}
+function Table({ b, className }) {
+  return /* @__PURE__ */ jsxs("table", { className, children: [
+    /* @__PURE__ */ jsx("caption", { children: b.caption }),
+    /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: b.columns.map((c, n) => /* @__PURE__ */ jsx("th", { scope: "col", children: c }, n)) }) }),
+    /* @__PURE__ */ jsx("tbody", { children: b.rows.map((r, n) => {
+      const [first = "", ...rest] = r;
+      return /* @__PURE__ */ jsxs("tr", { children: [
+        /* @__PURE__ */ jsx("th", { scope: "row", children: first }),
+        rest.map((c, m) => /* @__PURE__ */ jsx("td", { children: c }, m))
+      ] }, n);
+    }) })
+  ] });
+}
+function BlockView({ b }) {
+  switch (b.type) {
+    case "heading":
+      return b.level === 2 ? /* @__PURE__ */ jsx("h2", { children: b.text }) : /* @__PURE__ */ jsx("h3", { children: b.text });
+    case "paragraph":
+      return /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx(InlineContent, { items: b.inline }) });
+    case "list": {
+      const items = b.items.map((i, n) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(InlineContent, { items: i }) }, n));
+      return b.ordered ? /* @__PURE__ */ jsx("ol", { children: items }) : /* @__PURE__ */ jsx("ul", { children: items });
+    }
+    case "table":
+      return /* @__PURE__ */ jsx(Table, { b, className: "psst-table" });
+    case "faq":
+      return /* @__PURE__ */ jsx("section", { className: "psst-faq", "aria-label": "Frequently asked questions", children: /* @__PURE__ */ jsx("dl", { children: b.items.flatMap((i, n) => [
+        /* @__PURE__ */ jsx("dt", { children: i.q }, `q${n}`),
+        /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx(InlineContent, { items: i.a }) }, `a${n}`)
+      ]) }) });
+    case "comparison":
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Table, { b, className: "psst-table psst-comparison" }),
+        b.notes.length > 0 ? /* @__PURE__ */ jsx("ul", { className: "psst-notes", children: b.notes.map((note, n) => /* @__PURE__ */ jsx("li", { children: note }, n)) }) : null
+      ] });
+    case "facts":
+      return /* @__PURE__ */ jsx("dl", { className: "psst-facts", children: b.items.flatMap((i, n) => [/* @__PURE__ */ jsx("dt", { children: i.label }, `l${n}`), /* @__PURE__ */ jsx("dd", { children: factValue(i) }, `v${n}`)]) });
+    case "cta":
+      return /* @__PURE__ */ jsx("p", { className: "psst-cta", children: /* @__PURE__ */ jsx("a", { className: "psst-button", ...linkProps(b.href), children: b.label }) });
+    case "image":
+      return /* @__PURE__ */ jsx("figure", { children: /* @__PURE__ */ jsx("img", { src: b.src, alt: b.alt, width: b.width, height: b.height, loading: "lazy", decoding: "async" }) });
+    case "citation":
+      return /* @__PURE__ */ jsxs("p", { className: "psst-citation", children: [
+        /* @__PURE__ */ jsx("cite", { children: /* @__PURE__ */ jsx("a", { href: b.url, rel: "noopener", children: b.title }) }),
+        ", accessed ",
+        /* @__PURE__ */ jsx("time", { dateTime: b.accessed, children: b.accessed })
+      ] });
+  }
+}
+function PsstMain({ doc, ctx }) {
+  const jsonLd = serializeJsonForScript(buildJsonLd(doc, ctx));
+  return /* @__PURE__ */ jsxs("main", { children: [
+    /* @__PURE__ */ jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: jsonLd } }),
+    /* @__PURE__ */ jsxs("article", { className: "psst-article", children: [
+      /* @__PURE__ */ jsx("h1", { children: doc.h1 }),
+      /* @__PURE__ */ jsx("p", { className: "psst-lede", children: doc.lede }),
+      /* @__PURE__ */ jsxs("p", { className: "psst-updated", children: [
+        "Updated ",
+        /* @__PURE__ */ jsx("time", { dateTime: doc.updatedAt, children: doc.updatedAt.slice(0, 10) })
+      ] }),
+      doc.blocks.map((b, n) => /* @__PURE__ */ jsx(BlockView, { b }, n)),
+      doc.sources.length > 0 ? /* @__PURE__ */ jsxs("section", { className: "psst-sources", children: [
+        /* @__PURE__ */ jsx("h2", { children: "Sources" }),
+        /* @__PURE__ */ jsx("ol", { children: doc.sources.map((s, n) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx("a", { href: s.url, rel: "noopener", children: s.title }) }, n)) })
+      ] }) : null
+    ] })
+  ] });
+}
+function DefaultShell({ siteName, nav = [], footer, children }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("header", { className: "psst-header", children: [
+      /* @__PURE__ */ jsx("a", { className: "psst-brand", href: "/", children: siteName }),
+      nav.length > 0 ? /* @__PURE__ */ jsx("nav", { "aria-label": "Primary", children: nav.map((l, n) => /* @__PURE__ */ jsx("a", { ...linkProps(l.href), children: l.label }, n)) }) : null
+    ] }),
+    children,
+    footer ? /* @__PURE__ */ jsx("footer", { className: "psst-footer", children: /* @__PURE__ */ jsx("p", { children: footer }) }) : null
+  ] });
+}
+var PsstIntegrityError = class extends Error {
+  constructor(message) {
+    super(`PSST: ${message}`);
+    this.name = "PsstIntegrityError";
+  }
+};
+async function resolvePath(config, fixed, props) {
+  if (fixed) return fixed;
+  const { slug } = await props.params;
+  if (!slug || slug.length === 0) notFound();
+  const path = `${config.prefix}/${slug.join("/")}`;
+  if (!sitePathSchema.safeParse(path).success) notFound();
+  return path;
+}
+async function fetchAtRender(config, path) {
+  try {
+    return await fetchPage(config, path);
+  } catch (err) {
+    if (err instanceof PsstUnavailableError && isBuildPhase()) {
+      console.warn(`${err.message}; ${path} will render at request time for this build`);
+      await connection();
+    }
+    throw err;
+  }
+}
+async function load(config, fixed, props) {
+  const path = await resolvePath(config, fixed, props);
+  const result = await fetchAtRender(config, path);
+  if (result.status !== "ok") notFound();
+  const parsed = parsePageDocument(result.page.document, { domain: config.domain });
+  if (!parsed.success) throw new PsstIntegrityError(`document for ${path} failed the content contract`);
+  const hash = hashDocument(parsed.data);
+  if (hash !== result.page.hash) throw new PsstIntegrityError(`document hash mismatch for ${path}`);
+  return { path, doc: parsed.data, version: shortHash(hash) };
+}
+function psstPage(config, options = {}) {
+  const fixed = options.path;
+  if (fixed && !config.rootPaths.includes(fixed)) {
+    throw new PsstConfigError(`${fixed} is not in rootPaths; PSST only serves root paths the dashboard claimed`);
+  }
+  const Shell = options.Shell;
+  async function Page(props) {
+    const { path, doc } = await load(config, fixed, props);
+    const main = /* @__PURE__ */ jsx(PsstMain, { doc, ctx: { siteName: config.siteName, domain: config.domain, canonicalPath: path } });
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${config.prefix}/_psst/style.css`, precedence: "psst" }),
+      Shell ? /* @__PURE__ */ jsx(Shell, { children: main }) : /* @__PURE__ */ jsx(DefaultShell, { siteName: config.siteName, nav: config.shell?.nav, footer: config.shell?.footer, children: main })
+    ] });
+  }
+  async function generateMetadata(props) {
+    const { path, doc, version } = await load(config, fixed, props);
+    const canonical = `https://${config.domain}${path}`;
+    return {
+      title: { absolute: doc.title },
+      description: doc.description,
+      alternates: { canonical },
+      robots: { index: true, follow: true },
+      openGraph: {
+        type: doc.kind === "about" ? "website" : "article",
+        title: doc.title,
+        description: doc.description,
+        url: canonical,
+        siteName: config.siteName
+      },
+      twitter: { card: "summary", title: doc.title, description: doc.description },
+      other: { "psst-version": version }
+    };
+  }
+  async function generateStaticParams() {
+    if (fixed) return [];
+    try {
+      const manifest = await fetchManifest(config);
+      const base = `${config.prefix}/`;
+      return manifest.pages.filter((p) => p.kind !== "llms_txt" && p.path.startsWith(base) && p.path.length > base.length).map((p) => ({ slug: p.path.slice(base.length).split("/") }));
+    } catch (err) {
+      if (err instanceof PsstUnavailableError || err instanceof ContentError) {
+        console.warn(`${err.message}; prerendering no PSST pages, they render on first request`);
+        return [];
+      }
+      throw err;
+    }
+  }
+  return { default: Page, generateMetadata, generateStaticParams };
+}
+
+export { PsstIntegrityError, psstPage };

package/dist/proxy.d.ts

@@ -0,0 +1,18 @@
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { a as PsstConfig } from './config-LILlPYgW.js';
+import 'zod';
+
+type ProxyResult = Response | null | undefined | void;
+/** The shape of a Next proxy (`proxy.ts`, Next 16) or middleware (`middleware.ts`, Next 15) function. */
+type PsstProxy = (request: NextRequest, event: NextFetchEvent) => ProxyResult | Promise<ProxyResult>;
+/**
+ * Wrap the site's proxy. On every request: classify AI crawlers (by User-Agent, a claim not a proof) and AI
+ * referrers, and post a hit without awaiting it (`event.waitUntil`); no IP, cookie, query or UA string is sent.
+ * Withdrawn psst paths answer 410. Everything else goes to `proxy` unchanged, and its result is returned as is.
+ *
+ * With `serveFromEdge`, psst paths are rewritten to the edge before anything else, with an allowlist of request headers:
+ * the edge answers them (410 included) and counts its own hits, so no hit is posted for them here.
+ */
+declare function withPsst(config: PsstConfig, proxy?: PsstProxy): PsstProxy;
+
+export { type PsstProxy, withPsst };

package/dist/proxy.js

@@ -0,0 +1,112 @@
+import { USER_AGENT, fetchManifest } from './chunk-ZELUPPQB.js';
+import { sitePathSchema, classifyUserAgent, classifyArrival, hitRequestSchema, CONTENT_SCHEMA_VERSION } from './chunk-X3GT7AOS.js';
+import { NextResponse } from 'next/server';
+
+// src/hits.ts
+var ASSET = /\.(?:js|mjs|css|map|png|jpe?g|gif|webp|avif|svg|ico|woff2?|ttf|otf|mp4|webm)$/i;
+function hitFor(config, request) {
+  if (request.method !== "GET" && request.method !== "HEAD") return null;
+  const h = request.headers;
+  if (h.get("x-psst-doctor") === "1") return null;
+  if (h.has("rsc") || h.has("next-router-prefetch") || h.get("purpose") === "prefetch" || h.get("sec-purpose")?.includes("prefetch")) {
+    return null;
+  }
+  const path = request.nextUrl.pathname;
+  if (path.startsWith("/_next/") || ASSET.test(path)) return null;
+  if (!sitePathSchema.safeParse(path).success) return null;
+  const bot = classifyUserAgent(h.get("user-agent"));
+  const referrerClass = classifyArrival(h.get("referer"), request.nextUrl.searchParams.get("utm_source"));
+  if (bot.agent === null && (referrerClass === "other" || referrerClass === "none")) return null;
+  const hit = hitRequestSchema.safeParse({
+    v: CONTENT_SCHEMA_VERSION,
+    publicId: config.site,
+    path,
+    agent: bot.agent,
+    agentClass: bot.agentClass,
+    referrerClass,
+    source: "proxy"
+  });
+  return hit.success ? hit.data : null;
+}
+
+// src/proxy.ts
+var HIT_TIMEOUT_MS = 300;
+var MANIFEST_TTL_MS = 3e5;
+var MANIFEST_TIMEOUT_MS = 2e3;
+async function postHit(config, hit) {
+  try {
+    await fetch(`${config.edge}/v1/hits`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "user-agent": USER_AGENT },
+      body: JSON.stringify(hit),
+      signal: AbortSignal.timeout(HIT_TIMEOUT_MS)
+    });
+  } catch {
+  }
+}
+function withdrawnTracker(config) {
+  const state = { paths: /* @__PURE__ */ new Set(), fetchedAt: 0, refreshing: null };
+  return {
+    get: () => state.paths,
+    refreshIfStale(now) {
+      if (state.refreshing || now - state.fetchedAt < MANIFEST_TTL_MS) return null;
+      state.refreshing = fetchManifest(config, MANIFEST_TIMEOUT_MS).then((m) => {
+        state.paths = new Set(m.withdrawn);
+        state.fetchedAt = Date.now();
+      }).catch(() => {
+        state.fetchedAt = Date.now();
+      }).finally(() => {
+        state.refreshing = null;
+      });
+      return state.refreshing;
+    }
+  };
+}
+function isPsstPath(config, path) {
+  return path.startsWith(`${config.prefix}/`) || config.rootPaths.includes(path);
+}
+function gone() {
+  return new Response("Gone\n", {
+    status: 410,
+    headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "public, max-age=0, s-maxage=300" }
+  });
+}
+var EDGE_REQUEST_HEADERS = ["user-agent", "accept", "x-psst-doctor", "rsc", "next-router-prefetch", "purpose", "sec-purpose"];
+function refererOrigin(value) {
+  if (value === null) return null;
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+function rewriteToEdge(config, request, path) {
+  const headers = new Headers();
+  for (const name of EDGE_REQUEST_HEADERS) {
+    const value = request.headers.get(name);
+    if (value !== null) headers.set(name, value);
+  }
+  const referer = refererOrigin(request.headers.get("referer"));
+  if (referer !== null) headers.set("referer", referer);
+  return NextResponse.rewrite(new URL(`${config.edge}/s/${config.site}${path}`), { request: { headers } });
+}
+function withPsst(config, proxy) {
+  const withdrawn = withdrawnTracker(config);
+  return (request, event) => {
+    const path = request.nextUrl.pathname;
+    if (config.serveFromEdge) {
+      const edgePath = path.replace(/\/+$/, "");
+      if (isPsstPath(config, edgePath)) return rewriteToEdge(config, request, edgePath);
+    }
+    const hit = hitFor(config, request);
+    if (hit) event.waitUntil(postHit(config, hit));
+    if (isPsstPath(config, path)) {
+      const refresh = withdrawn.refreshIfStale(Date.now());
+      if (refresh) event.waitUntil(refresh);
+      if (withdrawn.get().has(path)) return gone();
+    }
+    return proxy ? proxy(request, event) : void 0;
+  };
+}
+
+export { withPsst };

package/dist/sitemap.d.ts

@@ -0,0 +1,11 @@
+import { a as PsstConfig } from './config-LILlPYgW.js';
+export { P as PSST_REVALIDATE } from './config-LILlPYgW.js';
+import 'zod';
+
+/**
+ * `GET` for `app/(psst){prefix}/sitemap.xml/route.ts`: the published HTML pages psst owns (the manifest already
+ * leaves withdrawn paths out), rendered with `renderSitemap` from `@psst/content`.
+ */
+declare function psstSitemap(config: PsstConfig): () => Promise<Response>;
+
+export { psstSitemap };

package/dist/sitemap.js

@@ -0,0 +1,19 @@
+import { psstRoute, textResponse } from './chunk-ELYUDQHH.js';
+export { PSST_REVALIDATE } from './chunk-2NMIB353.js';
+import { fetchManifest, PsstUnavailableError } from './chunk-ZELUPPQB.js';
+import { renderSitemap } from './chunk-X3GT7AOS.js';
+
+// src/sitemap.ts
+function psstSitemap(config) {
+  return psstRoute(async () => {
+    const manifest = await fetchManifest(config);
+    if (manifest.site.domain !== config.domain) {
+      throw new PsstUnavailableError(`manifest domain ${manifest.site.domain} does not match psst.config domain ${config.domain}`);
+    }
+    const pages = manifest.pages.filter((p) => p.kind !== "llms_txt").map((p) => ({ path: p.path, title: p.title, updatedAt: p.updatedAt }));
+    const xml = renderSitemap({ siteName: config.siteName, domain: config.domain }, pages);
+    return textResponse(xml, "application/xml; charset=utf-8");
+  });
+}
+
+export { psstSitemap };

package/dist/style.d.ts

@@ -0,0 +1,8 @@
+import { a as PsstConfig } from './config-LILlPYgW.js';
+export { P as PSST_REVALIDATE } from './config-LILlPYgW.js';
+import 'zod';
+
+/** `GET` for `app/(psst){prefix}/_psst/style.css/route.ts`: the psst stylesheet, served same-origin. */
+declare function psstStyle(config: PsstConfig): () => Promise<Response>;
+
+export { psstStyle };

package/dist/style.js

@@ -0,0 +1,12 @@
+import { edgeFileRoute } from './chunk-QE3BBW25.js';
+import './chunk-ELYUDQHH.js';
+export { PSST_REVALIDATE } from './chunk-2NMIB353.js';
+import './chunk-ZELUPPQB.js';
+import './chunk-X3GT7AOS.js';
+
+// src/style.ts
+function psstStyle(config) {
+  return edgeFileRoute(config, { path: `${config.prefix}/_psst/style.css`, type: "text/css", maxBytes: 256 * 1024 });
+}
+
+export { psstStyle };

package/dist/verify.d.ts

@@ -0,0 +1,12 @@
+import { a as PsstConfig } from './config-LILlPYgW.js';
+export { P as PSST_REVALIDATE } from './config-LILlPYgW.js';
+import 'zod';
+
+/**
+ * `GET` for `app/(psst){prefix}/_psst/verify/route.ts`: the domain-proof text
+ * (`psst-site-verification: {publicId}.{proofNonce}`), copied from the edge so psst can check the site's own domain
+ * serves it.
+ */
+declare function psstVerify(config: PsstConfig): () => Promise<Response>;
+
+export { psstVerify };

package/dist/verify.js

@@ -0,0 +1,17 @@
+import { edgeFileRoute } from './chunk-QE3BBW25.js';
+import './chunk-ELYUDQHH.js';
+export { PSST_REVALIDATE } from './chunk-2NMIB353.js';
+import './chunk-ZELUPPQB.js';
+import './chunk-X3GT7AOS.js';
+
+// src/verify.ts
+function psstVerify(config) {
+  return edgeFileRoute(config, {
+    path: `${config.prefix}/_psst/verify`,
+    type: "text/plain",
+    maxBytes: 1024,
+    accept: (body) => body.includes(`${config.site}.`)
+  });
+}
+
+export { psstVerify };

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@saypsst/next",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Drop-in Next.js App Router route modules that serve PSST pages on your own domain.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./page": {
+      "types": "./dist/page.d.ts",
+      "default": "./dist/page.js"
+    },
+    "./llms": {
+      "types": "./dist/llms.d.ts",
+      "default": "./dist/llms.js"
+    },
+    "./sitemap": {
+      "types": "./dist/sitemap.d.ts",
+      "default": "./dist/sitemap.js"
+    },
+    "./verify": {
+      "types": "./dist/verify.d.ts",
+      "default": "./dist/verify.js"
+    },
+    "./style": {
+      "types": "./dist/style.d.ts",
+      "default": "./dist/style.js"
+    },
+    "./proxy": {
+      "types": "./dist/proxy.d.ts",
+      "default": "./dist/proxy.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test",
+    "test": "vitest run",
+    "build": "tsup && node scripts/check-dist.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "next": ">=15 <17",
+    "react": ">=19"
+  },
+  "dependencies": {
+    "zod": "4.6.7"
+  },
+  "devDependencies": {
+    "@psst/content": "workspace:*",
+    "@types/node": "20.19.43",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "eslint": "^9",
+    "next": "16.4.3",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "tsup": "8.5.1",
+    "typescript-eslint": "^8"
+  }
+}