@saypsst/next 0.0.0-stage → 0.2.0

package/dist/chunk-WHB66OTA.js

@@ -0,0 +1,522 @@
+import { z } from 'zod';
+
+// ../content/src/blocks.ts
+
+// ../content/src/safe.ts
+var HTML_ESCAPES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => HTML_ESCAPES[c] ?? c);
+}
+var XML_FORBIDDEN = new RegExp("[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\uFFFE\\uFFFF]", "g");
+function escapeXml(value) {
+  return escapeHtml(value).replace(XML_FORBIDDEN, "");
+}
+var LS = new RegExp(String.fromCharCode(8232), "g");
+var PS = new RegExp(String.fromCharCode(8233), "g");
+function serializeJsonForScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(LS, "\\u2028").replace(PS, "\\u2029");
+}
+var FORBIDDEN_TEXT = new RegExp("[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u007F\\u202A-\\u202E\\u2066-\\u2069]");
+var PRINTABLE_ASCII = /^[!-~]+$/;
+var UNSAFE_URL_CHARS = /["'<>\\`{}|^]/;
+var MAX_URL_LENGTH = 2048;
+function parseHttpsUrl(value) {
+  if (value.length > MAX_URL_LENGTH) return null;
+  if (!PRINTABLE_ASCII.test(value) || UNSAFE_URL_CHARS.test(value)) return null;
+  if (!/^https:\/\/[^/?#]/i.test(value)) return null;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hostname === "") return null;
+  return url;
+}
+function isHttpsUrl(value) {
+  return parseHttpsUrl(value) !== null;
+}
+function isSameSiteRelative(value) {
+  if (value.length > MAX_URL_LENGTH) return false;
+  if (!PRINTABLE_ASCII.test(value) || UNSAFE_URL_CHARS.test(value)) return false;
+  if (!value.startsWith("/") || value.startsWith("//")) return false;
+  try {
+    return new URL(value, "https://base.invalid").host === "base.invalid";
+  } catch {
+    return false;
+  }
+}
+function isSafeHref(value) {
+  return isSameSiteRelative(value) || isHttpsUrl(value);
+}
+var BARE_HOST = /^(?=.{1,253}$)([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
+var PATH_PREFIX = /^\/[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)*$/;
+var SITE_PATH = /^\/[A-Za-z0-9._~\-/]*$/;
+
+// ../content/src/blocks.ts
+var CONTENT_SCHEMA_VERSION = 1;
+var EDGE_IMAGE_HOST = "edge.saypsst.com";
+function safeText(max, min = 1) {
+  return z.string().min(min).max(max).refine((s) => !FORBIDDEN_TEXT.test(s), "control or bidi-override characters are not allowed");
+}
+var safeHref = z.string().max(2048).refine(isSafeHref, "href must be https: or a same-site relative path");
+var httpsUrl = z.string().max(2048).refine(isHttpsUrl, "url must be https:");
+var inlineSchema = z.discriminatedUnion("type", [
+  z.strictObject({ type: z.literal("text"), text: safeText(2e3) }),
+  z.strictObject({ type: z.literal("strong"), text: safeText(500) }),
+  z.strictObject({ type: z.literal("em"), text: safeText(500) }),
+  z.strictObject({ type: z.literal("link"), text: safeText(300), href: safeHref })
+]);
+var inlines = z.array(inlineSchema).min(1).max(100);
+var cell = safeText(500, 0);
+var columns = z.array(safeText(120)).min(1).max(12);
+function tableLike(shape) {
+  return z.strictObject({
+    caption: safeText(300),
+    columns,
+    rows: z.array(z.array(cell).min(1).max(12)).min(1).max(100),
+    ...shape
+  });
+}
+function rowsMatchColumns(v) {
+  return v.rows.every((r) => r.length === v.columns.length);
+}
+var ROW_MSG = "every row must have exactly one cell per column";
+function imageSrc(allowedHosts) {
+  return z.string().max(2048).refine((src) => {
+    const url = parseHttpsUrl(src);
+    if (!url || url.port !== "") return false;
+    if (allowedHosts === "any") return true;
+    return allowedHosts.map((h) => h.toLowerCase()).includes(url.hostname.toLowerCase());
+  }, "image src must be https: on an allowlisted host");
+}
+function createPageDocumentSchema(options) {
+  const blockSchema = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("heading"), level: z.union([z.literal(2), z.literal(3)]), text: safeText(200) }),
+    z.strictObject({ type: z.literal("paragraph"), inline: inlines }),
+    z.strictObject({ type: z.literal("list"), ordered: z.boolean(), items: z.array(inlines).min(1).max(50) }),
+    tableLike({ type: z.literal("table") }).refine(rowsMatchColumns, ROW_MSG),
+    z.strictObject({
+      type: z.literal("faq"),
+      items: z.array(z.strictObject({ q: safeText(300), a: inlines })).min(1).max(30)
+    }),
+    tableLike({ type: z.literal("comparison"), notes: z.array(safeText(500)).max(20) }).refine(
+      rowsMatchColumns,
+      ROW_MSG
+    ),
+    // An official facts page's facts (ladder M3): each a labelled value with its unit and the https page stating it,
+    // rendered as a definition list. `currency` (ISO 4217) only on a price; JSON-LD names an `Offer` for it only when
+    // the visible value or unit states that currency.
+    z.strictObject({
+      type: z.literal("facts"),
+      items: z.array(
+        z.strictObject({
+          label: safeText(120),
+          value: safeText(200),
+          unit: safeText(40).optional(),
+          currency: z.string().regex(/^[A-Z]{3}$/, "currency must be an ISO 4217 code").optional(),
+          source: httpsUrl
+        })
+      ).min(1).max(30)
+    }),
+    z.strictObject({ type: z.literal("cta"), label: safeText(80), href: safeHref }),
+    z.strictObject({
+      type: z.literal("image"),
+      src: imageSrc(options.allowedImageHosts),
+      alt: safeText(300),
+      width: z.number().int().min(1).max(1e4),
+      height: z.number().int().min(1).max(1e4)
+    }),
+    z.strictObject({
+      type: z.literal("citation"),
+      title: safeText(300),
+      url: httpsUrl,
+      accessed: z.iso.date()
+    })
+  ]);
+  return z.strictObject({
+    v: z.literal(CONTENT_SCHEMA_VERSION),
+    kind: z.enum(["about", "llms_txt", "guide"]),
+    title: safeText(120),
+    description: safeText(320),
+    h1: safeText(160),
+    lede: safeText(600),
+    blocks: z.array(blockSchema).min(1).max(200),
+    sources: z.array(z.strictObject({ title: safeText(300), url: httpsUrl })).max(50),
+    updatedAt: z.iso.datetime()
+  });
+}
+createPageDocumentSchema({ allowedImageHosts: [EDGE_IMAGE_HOST] });
+var pageDocumentStructureSchema = createPageDocumentSchema({ allowedImageHosts: "any" });
+function parsePageDocument(input, site) {
+  return createPageDocumentSchema({ allowedImageHosts: [site.domain, EDGE_IMAGE_HOST] }).safeParse(input);
+}
+
+// ../content/src/hash.ts
+function canonicalJson(value) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return JSON.stringify(value);
+    case "number":
+      if (!Number.isFinite(value)) throw new TypeError("canonicalJson: non-finite number");
+      return JSON.stringify(value);
+    case "object": {
+      if (Array.isArray(value)) return `[${value.map((v) => v === void 0 ? "null" : canonicalJson(v)).join(",")}]`;
+      const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+      return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+    }
+    default:
+      throw new TypeError(`canonicalJson: unsupported type ${typeof value}`);
+  }
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256Hex(text) {
+  const data = new TextEncoder().encode(text);
+  const bitLen = data.length * 8;
+  const padded = new Uint8Array(data.length + 9 + 63 >> 6 << 6);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+  view.setUint32(padded.length - 4, bitLen >>> 0);
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  for (let off = 0; off < padded.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const w15 = w[i - 15] ?? 0;
+      const w2 = w[i - 2] ?? 0;
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[i] = (w[i - 16] ?? 0) + s0 + (w[i - 7] ?? 0) + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = [h[0] ?? 0, h[1] ?? 0, h[2] ?? 0, h[3] ?? 0, h[4] ?? 0, h[5] ?? 0, h[6] ?? 0, h[7] ?? 0];
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = hh + S1 + ch + (K[i] ?? 0) + (w[i] ?? 0) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    const next = [a, b, c, d, e, f, g, hh];
+    for (let i = 0; i < 8; i++) h[i] = (h[i] ?? 0) + (next[i] ?? 0) >>> 0;
+  }
+  return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}
+function hashDocument(doc) {
+  return sha256Hex(canonicalJson(doc));
+}
+function shortHash(hash) {
+  return hash.slice(0, 12);
+}
+
+// ../content/src/jsonld.ts
+function inlineText(inline) {
+  return inline.map((i) => i.text).join("");
+}
+function factValue(f) {
+  return f.unit ? `${f.value} ${f.unit}` : f.value;
+}
+var CURRENCY_MARKS = { USD: ["$", "US$"], EUR: ["\u20AC"], GBP: ["\xA3"], JPY: ["\xA5"], INR: ["\u20B9"], CAD: ["C$", "CA$"], AUD: ["A$", "AU$"], CHF: ["CHF"] };
+function priceOf(value) {
+  const nums = value.match(/\d(?:\d|[.,   ](?=\d))*/g) ?? [];
+  const raw = nums[0];
+  if (nums.length !== 1 || !raw) return null;
+  const d = /[.,](\d{1,2})$/.exec(raw);
+  const head = d ? raw.slice(0, d.index) : raw;
+  if (!/^\d+$/.test(head) && !/^[1-9]\d{0,2}([.,   ])\d{3}(?:\1\d{3})*$/.test(head)) return null;
+  const int = head.replace(/\D/g, "");
+  return d ? `${int}.${d[1]}` : int;
+}
+function offerOf(f, url) {
+  if (!f.currency) return null;
+  const shown = factValue(f);
+  const marks = [f.currency, ...CURRENCY_MARKS[f.currency] ?? []];
+  if (!marks.some((m) => m === "$" ? /(^|[^A-Za-z])\$/.test(shown) : shown.includes(m))) return null;
+  const price = priceOf(f.value);
+  if (!price) return null;
+  return { "@type": "Offer", name: f.label, price, priceCurrency: f.currency, url };
+}
+function buildJsonLd(doc, ctx) {
+  const origin = `https://${ctx.domain}`;
+  const url = `${origin}${ctx.canonicalPath}`;
+  const main = doc.kind === "about" ? { "@type": "AboutPage", "@id": `${url}#page`, url, name: doc.title, description: doc.description } : {
+    "@type": "Article",
+    "@id": `${url}#page`,
+    url,
+    headline: doc.h1,
+    description: doc.description,
+    dateModified: doc.updatedAt,
+    mainEntityOfPage: url,
+    author: { "@type": "Organization", name: ctx.siteName, url: origin },
+    publisher: { "@type": "Organization", name: ctx.siteName, url: origin }
+  };
+  if (doc.kind === "about") main["dateModified"] = doc.updatedAt;
+  const graph = [
+    main,
+    {
+      "@type": "BreadcrumbList",
+      itemListElement: [
+        { "@type": "ListItem", position: 1, name: ctx.siteName, item: `${origin}/` },
+        { "@type": "ListItem", position: 2, name: doc.title, item: url }
+      ]
+    }
+  ];
+  const faqs = doc.blocks.filter((b) => b.type === "faq").flatMap((b) => b.items);
+  if (faqs.length > 0) {
+    graph.push({
+      "@type": "FAQPage",
+      mainEntity: faqs.map((f) => ({
+        "@type": "Question",
+        name: f.q,
+        acceptedAnswer: { "@type": "Answer", text: inlineText(f.a) }
+      }))
+    });
+  }
+  for (const b of doc.blocks) {
+    if (b.type !== "facts") continue;
+    for (const f of b.items) {
+      const offer = offerOf(f, url);
+      if (offer) graph.push(offer);
+    }
+  }
+  return { "@context": "https://schema.org", "@graph": graph };
+}
+
+// ../content/src/render-html.ts
+var ContentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContentError";
+  }
+};
+function assertSite(site, pages) {
+  if (!BARE_HOST.test(site.domain)) throw new ContentError("invalid domain");
+  for (const p of pages) {
+    if (!SITE_PATH.test(p.path) || p.path.startsWith("//") || p.path.includes("..")) throw new ContentError("invalid page path");
+  }
+}
+function renderSitemap(site, pages) {
+  assertSite(site, pages);
+  const urls = pages.map((p) => {
+    const lastmod = p.updatedAt && /^\d{4}-\d{2}-\d{2}/.test(p.updatedAt) ? `<lastmod>${escapeXml(p.updatedAt)}</lastmod>` : "";
+    return `<url><loc>${escapeXml(`https://${site.domain}${p.path}`)}</loc>${lastmod}</url>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+}
+var publicIdSchema = z.string().regex(/^site_[a-z2-7]{16}$/);
+var sitePathSchema = z.string().max(512).regex(SITE_PATH).refine((p) => !p.startsWith("//") && !p.includes(".."), "invalid path");
+var siteModeSchema = z.enum(["next", "vercel_static", "proxy"]);
+var agentClassSchema = z.enum(["training", "search", "user_fetch", "other"]);
+var referrerClassSchema = z.enum(["chatgpt", "perplexity", "gemini", "copilot", "claude", "other", "none"]);
+var hitSourceSchema = z.enum(["edge", "proxy"]);
+var publishStateSchema = z.enum(["published", "verified"]);
+var hashSchema = z.string().regex(/^[0-9a-f]{64}$/);
+z.strictObject({ path: sitePathSchema });
+var pageResponseSchema = z.strictObject({
+  v: z.literal(CONTENT_SCHEMA_VERSION),
+  publicId: publicIdSchema,
+  path: sitePathSchema,
+  hash: hashSchema,
+  state: publishStateSchema,
+  publishedAt: z.iso.datetime(),
+  /** Structure-checked here; `renderPageHtml` enforces the image host allowlist. */
+  document: pageDocumentStructureSchema
+});
+var manifestResponseSchema = z.strictObject({
+  v: z.literal(CONTENT_SCHEMA_VERSION),
+  site: z.strictObject({
+    publicId: publicIdSchema,
+    domain: z.string().regex(BARE_HOST),
+    mode: siteModeSchema,
+    prefix: z.string().regex(PATH_PREFIX),
+    claimedRootPaths: z.array(z.enum(["/about", "/llms.txt"])).max(2),
+    /** Brand name for Open Graph and JSON-LD. Optional so older edges still parse. */
+    siteName: z.string().min(1).max(120).optional()
+  }),
+  pages: z.array(
+    z.strictObject({
+      path: sitePathSchema,
+      kind: z.enum(["about", "llms_txt", "guide"]),
+      title: z.string().min(1).max(120),
+      description: z.string().max(320),
+      hash: hashSchema,
+      state: publishStateSchema,
+      updatedAt: z.iso.datetime()
+    })
+  ).max(1e3),
+  /** Withdrawn paths: answer 410 and drop from the sitemap. */
+  withdrawn: z.array(sitePathSchema).max(1e3)
+});
+var hitRequestSchema = z.strictObject({
+  v: z.literal(CONTENT_SCHEMA_VERSION),
+  publicId: publicIdSchema,
+  path: sitePathSchema,
+  agent: z.string().min(1).max(64).nullable(),
+  agentClass: agentClassSchema,
+  referrerClass: referrerClassSchema,
+  source: hitSourceSchema
+});
+z.strictObject({
+  v: z.literal(CONTENT_SCHEMA_VERSION),
+  error: z.enum(["not_found", "gone", "unavailable", "bad_request", "rate_limited"]),
+  message: z.string().max(300),
+  retryAfterSeconds: z.number().int().min(1).max(3600).optional()
+});
+
+// ../content/src/bots.ts
+var AI_AGENT_RULES = [
+  { agent: "ChatGPT-User", agentClass: "user_fetch", pattern: /chatgpt-user/i },
+  { agent: "OAI-SearchBot", agentClass: "search", pattern: /oai-searchbot/i },
+  { agent: "GPTBot", agentClass: "training", pattern: /gptbot/i },
+  { agent: "Claude-SearchBot", agentClass: "search", pattern: /claude-searchbot/i },
+  { agent: "Claude-User", agentClass: "user_fetch", pattern: /claude-user/i },
+  { agent: "ClaudeBot", agentClass: "training", pattern: /claudebot/i },
+  { agent: "Perplexity-User", agentClass: "user_fetch", pattern: /perplexity-user/i },
+  { agent: "PerplexityBot", agentClass: "search", pattern: /perplexitybot/i },
+  { agent: "Google-CloudVertexBot", agentClass: "search", pattern: /google-cloudvertexbot/i },
+  { agent: "Applebot-Extended", agentClass: "training", pattern: /applebot-extended/i },
+  { agent: "Meta-ExternalAgent", agentClass: "training", pattern: /meta-externalagent/i },
+  { agent: "Bytespider", agentClass: "training", pattern: /bytespider/i },
+  { agent: "CCBot", agentClass: "training", pattern: /ccbot/i },
+  { agent: "Amazonbot", agentClass: "training", pattern: /amazonbot/i }
+];
+new Set(AI_AGENT_RULES.map((r) => r.agent));
+function classifyUserAgent(userAgent) {
+  if (typeof userAgent === "string" && userAgent.length > 0 && userAgent.length <= 2048) {
+    for (const rule of AI_AGENT_RULES) {
+      if (rule.pattern.test(userAgent)) return { agent: rule.agent, agentClass: rule.agentClass };
+    }
+  }
+  return { agent: null, agentClass: "other" };
+}
+var REFERRER_HOSTS = [
+  { host: "chatgpt.com", cls: "chatgpt" },
+  { host: "chat.openai.com", cls: "chatgpt" },
+  { host: "perplexity.ai", cls: "perplexity" },
+  { host: "gemini.google.com", cls: "gemini" },
+  { host: "bard.google.com", cls: "gemini" },
+  { host: "copilot.microsoft.com", cls: "copilot" },
+  { host: "copilot.cloud.microsoft", cls: "copilot" },
+  { host: "claude.ai", cls: "claude" }
+];
+function classifyReferrer(referrer) {
+  if (typeof referrer !== "string" || referrer.length === 0 || referrer.length > 2048) return "none";
+  let host;
+  try {
+    host = new URL(referrer).hostname.toLowerCase();
+  } catch {
+    return "none";
+  }
+  if (host === "") return "none";
+  for (const { host: h, cls } of REFERRER_HOSTS) {
+    if (host === h || host.endsWith(`.${h}`)) return cls;
+  }
+  return "other";
+}
+
+// src/content.ts
+var siteShape = manifestResponseSchema.shape.site.shape;
+var domainSchema = siteShape.domain;
+var prefixSchema = siteShape.prefix;
+
+// src/version.ts
+var PSST_NEXT_VERSION = "0.2.0";
+
+export { CONTENT_SCHEMA_VERSION, ContentError, PSST_NEXT_VERSION, buildJsonLd, classifyReferrer, classifyUserAgent, domainSchema, factValue, hashDocument, hitRequestSchema, isSafeHref, manifestResponseSchema, pageResponseSchema, parsePageDocument, prefixSchema, publicIdSchema, renderSitemap, serializeJsonForScript, shortHash, sitePathSchema };

package/dist/chunk-XCY5RUQM.js

@@ -0,0 +1,18 @@
+import { psstRoute, notFoundResponse, textResponse } from './chunk-CKSLG42W.js';
+import { fetchEdgeFile, PsstUnavailableError, readCapped } from './chunk-5X6OYLUN.js';
+
+// src/edge-file.ts
+function edgeFileRoute(config, spec) {
+  return psstRoute(async () => {
+    const res = await fetchEdgeFile(config, spec.path, spec.type);
+    if (res.status === 404 || res.status === 410) return notFoundResponse();
+    if (res.status !== 200) throw new PsstUnavailableError(`edge answered ${res.status} for ${spec.path}`);
+    const type = (res.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
+    if (type !== spec.type) throw new PsstUnavailableError(`edge answered ${type || "no type"} for ${spec.path}`);
+    const body = await readCapped(res, spec.maxBytes);
+    if (spec.accept && !spec.accept(body)) throw new PsstUnavailableError(`edge body for ${spec.path} failed its check`);
+    return textResponse(body, `${spec.type}; charset=utf-8`);
+  });
+}
+
+export { edgeFileRoute };

package/dist/config-CoVgm6Ny.d.ts

@@ -0,0 +1,52 @@
+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>;
+    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;
+    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-CoVgm6Ny.js';
+import 'zod';
+
+/** Kept equal to package.json `version` (checked by test/version.test.ts). */
+declare const PSST_NEXT_VERSION = "0.2.0";
+
+export { PSST_NEXT_VERSION };

package/dist/index.js

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

package/dist/llms.d.ts

@@ -0,0 +1,8 @@
+import { a as PsstConfig } from './config-CoVgm6Ny.js';
+export { P as PSST_REVALIDATE } from './config-CoVgm6Ny.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-XCY5RUQM.js';
+import './chunk-CKSLG42W.js';
+import { PsstConfigError } from './chunk-4FFLVIJG.js';
+export { PSST_REVALIDATE } from './chunk-4FFLVIJG.js';
+import './chunk-5X6OYLUN.js';
+import './chunk-WHB66OTA.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-CoVgm6Ny.js';
+export { P as PSST_REVALIDATE } from './config-CoVgm6Ny.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 };