@saypsst/next 0.0.0-stage → 0.3.0

package/dist/chunk-X3GT7AOS.js

@@ -0,0 +1,593 @@
+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",
+  "grok",
+  "mistral",
+  "deepseek",
+  "meta",
+  "you",
+  "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 },
+  { agent: "MistralAI-User", agentClass: "user_fetch", pattern: /mistralai-user/i },
+  { agent: "MistralAI-Index", agentClass: "search", pattern: /mistralai-index/i },
+  { agent: "DuckAssistBot", agentClass: "search", pattern: /duckassistbot/i },
+  { agent: "Google-Agent", agentClass: "user_fetch", pattern: /google-agent/i },
+  { agent: "Meta-ExternalFetcher", agentClass: "user_fetch", pattern: /meta-externalfetcher/i },
+  { agent: "meta-webindexer", agentClass: "search", pattern: /meta-webindexer/i },
+  { agent: "YouBot", agentClass: "search", pattern: /youbot/i },
+  { agent: "Amzn-SearchBot", agentClass: "search", pattern: /amzn-searchbot/i },
+  { agent: "Amzn-User", agentClass: "user_fetch", pattern: /amzn-user/i },
+  { agent: "Claude-Agent", agentClass: "user_fetch", pattern: /claude-agent/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" },
+  { host: "grok.com", cls: "grok" },
+  { host: "chat.mistral.ai", cls: "mistral" },
+  { host: "chat.deepseek.com", cls: "deepseek" },
+  { host: "meta.ai", cls: "meta" },
+  { host: "you.com", cls: "you" }
+];
+var REFERRER_PATHS = [
+  { host: "x.com", pathPrefix: "/i/grok", cls: "grok" },
+  { host: "twitter.com", pathPrefix: "/i/grok", cls: "grok" }
+];
+function classifyReferrer(referrer) {
+  if (typeof referrer !== "string" || referrer.length === 0 || referrer.length > 2048) return "none";
+  let url;
+  try {
+    url = new URL(referrer);
+  } catch {
+    return "none";
+  }
+  const host = url.hostname.toLowerCase();
+  if (host === "") return "none";
+  for (const { host: h, cls } of REFERRER_HOSTS) {
+    if (host === h || host.endsWith(`.${h}`)) return cls;
+  }
+  const bare = host.replace(/^www\./, "");
+  const path = url.pathname.toLowerCase();
+  for (const { host: h, pathPrefix, cls } of REFERRER_PATHS) {
+    if (bare === h && (path === pathPrefix || path.startsWith(`${pathPrefix}/`))) return cls;
+  }
+  return "other";
+}
+var AI_UTM_RULES = {
+  chatgpt: "chatgpt",
+  "chatgpt.com": "chatgpt",
+  openai: "chatgpt",
+  perplexity: "perplexity",
+  "perplexity.ai": "perplexity",
+  gemini: "gemini",
+  "gemini.google.com": "gemini",
+  copilot: "copilot",
+  "copilot.microsoft.com": "copilot",
+  claude: "claude",
+  "claude.ai": "claude",
+  grok: "grok",
+  mistral: "mistral",
+  lechat: "mistral",
+  deepseek: "deepseek",
+  metaai: "meta",
+  youcom: "you"
+};
+function classifyUtmSource(utmSource) {
+  if (typeof utmSource !== "string" || utmSource.length === 0 || utmSource.length > 200) return null;
+  const v = utmSource.trim().toLowerCase();
+  if (Object.hasOwn(AI_UTM_RULES, v)) return AI_UTM_RULES[v] ?? null;
+  for (const { host, cls } of REFERRER_HOSTS) {
+    if (v === host || v.endsWith(`.${host}`)) return cls;
+  }
+  return null;
+}
+function classifyArrival(referrer, utmSource) {
+  const fromReferrer = classifyReferrer(referrer);
+  if (fromReferrer !== "other" && fromReferrer !== "none") return fromReferrer;
+  return classifyUtmSource(utmSource) ?? fromReferrer;
+}
+
+// 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.3.0";
+
+export { CONTENT_SCHEMA_VERSION, ContentError, PSST_NEXT_VERSION, buildJsonLd, classifyArrival, classifyUserAgent, domainSchema, factValue, hashDocument, hitRequestSchema, isSafeHref, manifestResponseSchema, pageResponseSchema, parsePageDocument, prefixSchema, publicIdSchema, renderSitemap, serializeJsonForScript, shortHash, sitePathSchema };

package/dist/chunk-ZELUPPQB.js

@@ -0,0 +1,95 @@
+import { pageResponseSchema, PSST_NEXT_VERSION, manifestResponseSchema } from './chunk-X3GT7AOS.js';
+import { cache } from 'react';
+
+var PsstUnavailableError = class extends Error {
+  constructor(message, options) {
+    super(`PSST: ${message}`, options);
+    this.name = "PsstUnavailableError";
+  }
+};
+var RENDER_TIMEOUT_MS = 8e3;
+var MAX_JSON_BYTES = 2 * 1024 * 1024;
+var USER_AGENT = `psst-next/${PSST_NEXT_VERSION}`;
+async function edgeGet(url, accept, timeoutMs) {
+  try {
+    return await fetch(url, {
+      method: "GET",
+      headers: { accept, "user-agent": USER_AGENT },
+      redirect: "error",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new PsstUnavailableError(`edge unreachable (${url})`, { cause });
+  }
+}
+async function readCapped(res, maxBytes) {
+  const declared = Number(res.headers.get("content-length") ?? "0");
+  if (declared > maxBytes) {
+    await res.body?.cancel().catch(() => void 0);
+    throw new PsstUnavailableError(`edge response too large (${declared} bytes)`);
+  }
+  if (!res.body) return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new PsstUnavailableError(`edge response too large (more than ${maxBytes} bytes)`);
+      }
+      chunks.push(value);
+    }
+  } catch (cause) {
+    if (cause instanceof PsstUnavailableError) throw cause;
+    throw new PsstUnavailableError("edge response body could not be read", { cause });
+  }
+  const buf = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buf.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(buf);
+}
+async function readJson(res) {
+  const text = await readCapped(res, MAX_JSON_BYTES);
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new PsstUnavailableError("edge returned invalid JSON", { cause });
+  }
+}
+async function loadPage(edge, site, path) {
+  const url = `${edge}/v1/sites/${encodeURIComponent(site)}/pages?path=${encodeURIComponent(path)}`;
+  const res = await edgeGet(url, "application/json", RENDER_TIMEOUT_MS);
+  if (res.status === 404) return { status: "not_found" };
+  if (res.status === 410) return { status: "gone" };
+  if (res.status !== 200) throw new PsstUnavailableError(`edge answered ${res.status} for ${path}`);
+  const parsed = pageResponseSchema.safeParse(await readJson(res));
+  if (!parsed.success) throw new PsstUnavailableError(`edge page response failed validation for ${path}`);
+  if (parsed.data.publicId !== site || parsed.data.path !== path) {
+    throw new PsstUnavailableError(`edge answered for another page (${parsed.data.publicId}${parsed.data.path})`);
+  }
+  return { status: "ok", page: parsed.data };
+}
+var fetchPage = cache((config, path) => loadPage(config.edge, config.site, path));
+async function loadManifest(edge, site, timeoutMs) {
+  const res = await edgeGet(`${edge}/v1/sites/${encodeURIComponent(site)}/manifest`, "application/json", timeoutMs);
+  if (res.status !== 200) throw new PsstUnavailableError(`edge answered ${res.status} for the manifest`);
+  const parsed = manifestResponseSchema.safeParse(await readJson(res));
+  if (!parsed.success) throw new PsstUnavailableError("edge manifest failed validation");
+  if (parsed.data.site.publicId !== site) throw new PsstUnavailableError("edge answered with another site's manifest");
+  return parsed.data;
+}
+function fetchManifest(config, timeoutMs = RENDER_TIMEOUT_MS) {
+  return loadManifest(config.edge, config.site, timeoutMs);
+}
+async function fetchEdgeFile(config, path, accept) {
+  return edgeGet(`${config.edge}/s/${encodeURIComponent(config.site)}${path}`, accept, RENDER_TIMEOUT_MS);
+}
+
+export { PsstUnavailableError, USER_AGENT, fetchEdgeFile, fetchManifest, fetchPage, readCapped };