@ampless/runtime 0.2.0-alpha.0

package/dist/index.js

@@ -0,0 +1,530 @@
+// src/storage.ts
+import { formatPublicAssetUrl } from "ampless";
+function createStorage(outputs) {
+  const storage = outputs.storage ?? null;
+  return {
+    publicAssetUrl(key) {
+      if (!storage) {
+        throw new Error(
+          "amplify storage output missing \u2014 run `npx ampx sandbox` (or deploy) before invoking this code path"
+        );
+      }
+      return formatPublicAssetUrl(storage.bucket_name, storage.aws_region, key);
+    },
+    isStorageConfigured() {
+      return storage !== null;
+    }
+  };
+}
+
+// src/posts.ts
+import { cookies } from "next/headers";
+import { generateServerClientUsingCookies } from "@aws-amplify/adapter-nextjs/api";
+function decodeBody(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function toCorePost(p) {
+  return {
+    postId: p.postId,
+    siteId: p.siteId,
+    slug: p.slug,
+    title: p.title,
+    excerpt: p.excerpt ?? void 0,
+    format: p.format ?? "markdown",
+    body: decodeBody(p.body),
+    status: p.status ?? "draft",
+    publishedAt: p.publishedAt ?? void 0,
+    tags: (p.tags ?? []).filter((t) => typeof t === "string")
+  };
+}
+function createPostsApi(outputs) {
+  const client = generateServerClientUsingCookies({
+    // generateServerClientUsingCookies expects the resourcesConfig shape
+    // — the full amplify_outputs.json satisfies it at runtime.
+    config: outputs,
+    cookies,
+    authMode: "apiKey"
+  });
+  return {
+    async listPublishedPosts(opts = {}) {
+      const { data, errors } = await client.queries.listPublishedPosts({
+        siteId: opts.siteId ?? "default",
+        from: opts.from,
+        to: opts.to,
+        limit: opts.limit ?? 20,
+        nextToken: opts.nextToken
+      });
+      if (errors) throw new Error(errors[0]?.message ?? "Failed to list posts");
+      const items = (data?.items ?? []).filter((p) => p !== null).map(toCorePost);
+      return { items, nextToken: data?.nextToken ?? null };
+    },
+    async getPublishedPost(slug, opts = {}) {
+      const { data, errors } = await client.queries.getPublishedPost({
+        siteId: opts.siteId ?? "default",
+        slug
+      });
+      if (errors) throw new Error(errors[0]?.message ?? "Failed to get post");
+      return data ? toCorePost(data) : null;
+    },
+    async listPostsByTag(tag, opts = {}) {
+      const { data, errors } = await client.queries.listPostsByTag({
+        siteId: opts.siteId ?? "default",
+        tag,
+        limit: opts.limit ?? 20,
+        nextToken: opts.nextToken
+      });
+      if (errors) throw new Error(errors[0]?.message ?? "Failed to list posts by tag");
+      const items = (data?.items ?? []).filter((p) => p !== null).map(toCorePost);
+      return { items, nextToken: data?.nextToken ?? null };
+    }
+  };
+}
+
+// src/site-settings.ts
+import { DEFAULT_SITE_ID, siteFor, unflattenSettings } from "ampless";
+function createSiteSettings(cmsConfig, storage) {
+  async function fetchRemote(siteId) {
+    if (!storage.isStorageConfigured()) return null;
+    let url;
+    try {
+      url = storage.publicAssetUrl(`public/site-settings/${siteId}.json`);
+    } catch {
+      return null;
+    }
+    const res = await fetch(url, { next: { revalidate: 60, tags: [`site-settings:${siteId}`] } });
+    if (!res.ok) return null;
+    const flat = await res.json();
+    return unflattenSettings(flat);
+  }
+  return {
+    async loadSiteSettings(siteId = DEFAULT_SITE_ID) {
+      const remote = await fetchRemote(siteId).catch(() => null);
+      const baseSite = siteFor(siteId, cmsConfig);
+      return {
+        site: {
+          name: remote?.site?.name ?? baseSite.name,
+          url: remote?.site?.url ?? baseSite.url,
+          description: remote?.site?.description ?? baseSite.description
+        },
+        media: {
+          imageDisplay: remote?.media?.imageDisplay ?? cmsConfig.media?.imageDisplay,
+          imageMaxWidth: remote?.media?.imageMaxWidth ?? cmsConfig.media?.imageMaxWidth,
+          processing: {
+            maxDimension: remote?.media?.processing?.maxDimension ?? cmsConfig.media?.processing?.maxDimension,
+            format: remote?.media?.processing?.format ?? cmsConfig.media?.processing?.format,
+            quality: remote?.media?.processing?.quality ?? cmsConfig.media?.processing?.quality,
+            losslessForPng: remote?.media?.processing?.losslessForPng ?? cmsConfig.media?.processing?.losslessForPng
+          }
+        },
+        dateFormat: remote?.dateFormat ?? cmsConfig.dateFormat,
+        timezone: remote?.timezone ?? cmsConfig.timezone
+      };
+    }
+  };
+}
+
+// src/seo.ts
+import { DEFAULT_SITE_ID as DEFAULT_SITE_ID2 } from "ampless";
+function isPlugin(p) {
+  return typeof p === "object" && p !== null && "apiVersion" in p;
+}
+function createSeo(cmsConfig, settingsApi) {
+  const plugins = (cmsConfig.plugins ?? []).filter(isPlugin);
+  return {
+    async postMetadata(post, siteId = DEFAULT_SITE_ID2) {
+      const settings = await settingsApi.loadSiteSettings(siteId);
+      const accum = {};
+      for (const plugin of plugins) {
+        if (!plugin.metadata) continue;
+        const m = plugin.metadata(post, settings.site);
+        Object.assign(accum, m, {
+          openGraph: { ...accum.openGraph ?? {}, ...m.openGraph ?? {} },
+          twitter: { ...accum.twitter ?? {}, ...m.twitter ?? {} },
+          alternates: {
+            ...accum.alternates ?? {},
+            ...m.alternates ?? {},
+            types: { ...accum.alternates?.types ?? {}, ...m.alternates?.types ?? {} }
+          }
+        });
+      }
+      return accum;
+    },
+    async siteMetadata(siteId = DEFAULT_SITE_ID2) {
+      const settings = await settingsApi.loadSiteSettings(siteId);
+      const accum = {
+        title: settings.site.name,
+        description: settings.site.description
+      };
+      for (const plugin of plugins) {
+        if (!plugin.siteMetadata) continue;
+        const m = plugin.siteMetadata(settings.site);
+        Object.assign(accum, m, {
+          openGraph: { ...accum.openGraph ?? {}, ...m.openGraph ?? {} },
+          twitter: { ...accum.twitter ?? {}, ...m.twitter ?? {} },
+          alternates: {
+            ...accum.alternates ?? {},
+            ...m.alternates ?? {},
+            types: { ...accum.alternates?.types ?? {}, ...m.alternates?.types ?? {} }
+          }
+        });
+      }
+      return accum;
+    }
+  };
+}
+
+// src/theme-active.ts
+import { headers } from "next/headers";
+import { DEFAULT_SITE_ID as DEFAULT_SITE_ID3 } from "ampless";
+function createThemeActive(registry, storage) {
+  async function fetchActiveFromCache(siteId) {
+    if (!storage.isStorageConfigured()) return null;
+    let url;
+    try {
+      url = storage.publicAssetUrl(`public/site-settings/${siteId}.json`);
+    } catch {
+      return null;
+    }
+    const res = await fetch(url, { next: { revalidate: 60, tags: [`site-settings:${siteId}`] } });
+    if (!res.ok) return null;
+    const flat = await res.json();
+    const v = flat["theme.active"];
+    return typeof v === "string" ? v : null;
+  }
+  return {
+    async resolveActiveTheme(siteId = DEFAULT_SITE_ID3) {
+      let previewOverride = null;
+      try {
+        const h = await headers();
+        previewOverride = h.get("x-preview-theme");
+      } catch {
+      }
+      if (previewOverride && previewOverride in registry.themes) {
+        const mod2 = registry.themes[previewOverride];
+        if (mod2) return { name: previewOverride, module: mod2 };
+      }
+      const stored = await fetchActiveFromCache(siteId).catch(() => null);
+      const name = stored && stored in registry.themes ? stored : registry.defaultTheme;
+      const mod = registry.themes[name] ?? registry.themes[registry.defaultTheme];
+      if (!mod) {
+        throw new Error(
+          `themes registry is empty \u2014 at least one theme must be registered before resolveActiveTheme is called`
+        );
+      }
+      return { name, module: mod };
+    }
+  };
+}
+
+// src/theme-config.ts
+import {
+  DEFAULT_SITE_ID as DEFAULT_SITE_ID4,
+  resolveThemeValues,
+  themeSettingKey
+} from "ampless";
+function createThemeConfig(themeActive, storage) {
+  async function fetchRemote(siteId) {
+    if (!storage.isStorageConfigured()) return null;
+    let url;
+    try {
+      url = storage.publicAssetUrl(`public/site-settings/${siteId}.json`);
+    } catch {
+      return null;
+    }
+    const res = await fetch(url, { next: { revalidate: 60, tags: [`site-settings:${siteId}`] } });
+    if (!res.ok) return null;
+    return await res.json();
+  }
+  return {
+    async loadThemeConfig(siteId = DEFAULT_SITE_ID4) {
+      const [active, flat] = await Promise.all([
+        themeActive.resolveActiveTheme(siteId),
+        fetchRemote(siteId).catch(() => null)
+      ]);
+      const manifest = active.module.manifest;
+      const stored = {};
+      if (flat) {
+        for (const field of manifest.fields) {
+          const k = themeSettingKey(field.key);
+          if (k in flat) stored[k] = flat[k];
+        }
+      }
+      const values = resolveThemeValues(manifest, stored);
+      const cssVars = collectCssVars(manifest.fields, values);
+      return { activeTheme: active.name, manifest, values, cssVars };
+    }
+  };
+}
+function collectCssVars(fields, values) {
+  const out = {};
+  for (const field of fields) {
+    if (field.type === "linkList") continue;
+    if (!field.cssVar) continue;
+    const v = values[field.key];
+    if (v) out[field.cssVar] = v;
+  }
+  return out;
+}
+function renderThemeCss(cssVars) {
+  const lines = Object.entries(cssVars).map(([name, value]) => `  ${name}: ${value};`);
+  if (lines.length === 0) return "";
+  return `:root {
+${lines.join("\n")}
+}`;
+}
+
+// src/rendering.ts
+function escape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderTiptap(node) {
+  if (node.type === "text") {
+    let html = escape(node.text ?? "");
+    for (const mark of node.marks ?? []) {
+      if (mark.type === "bold") html = `<strong>${html}</strong>`;
+      else if (mark.type === "italic") html = `<em>${html}</em>`;
+      else if (mark.type === "code") html = `<code>${html}</code>`;
+      else if (mark.type === "strike") html = `<s>${html}</s>`;
+      else if (mark.type === "link") {
+        const href = escape(String(mark.attrs?.href ?? "#"));
+        html = `<a href="${href}" target="_blank" rel="noopener">${html}</a>`;
+      }
+    }
+    return html;
+  }
+  const children = (node.content ?? []).map(renderTiptap).join("");
+  switch (node.type) {
+    case "doc":
+      return children;
+    case "paragraph":
+      return `<p>${children}</p>`;
+    case "heading": {
+      const level = Number(node.attrs?.level ?? 1);
+      return `<h${level}>${children}</h${level}>`;
+    }
+    case "bulletList":
+      return `<ul>${children}</ul>`;
+    case "orderedList":
+      return `<ol>${children}</ol>`;
+    case "listItem":
+      return `<li>${children}</li>`;
+    case "codeBlock": {
+      const lang = node.attrs?.language ? ` class="language-${escape(String(node.attrs.language))}"` : "";
+      return `<pre><code${lang}>${children}</code></pre>`;
+    }
+    case "blockquote":
+      return `<blockquote>${children}</blockquote>`;
+    case "hardBreak":
+      return "<br />";
+    case "horizontalRule":
+      return "<hr />";
+    case "image": {
+      const src = escape(String(node.attrs?.src ?? ""));
+      const alt = escape(String(node.attrs?.alt ?? ""));
+      const title = node.attrs?.title ? ` title="${escape(String(node.attrs.title))}"` : "";
+      const display = node.attrs?.display ? ` data-display="${escape(String(node.attrs.display))}"` : "";
+      return `<img src="${src}" alt="${alt}"${title}${display} loading="lazy" />`;
+    }
+    default:
+      return children;
+  }
+}
+function renderMarkdown(md) {
+  const lines = md.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("# ")) {
+      out.push(`<h1>${escape(line.slice(2))}</h1>`);
+      i++;
+    } else if (line.startsWith("## ")) {
+      out.push(`<h2>${escape(line.slice(3))}</h2>`);
+      i++;
+    } else if (line.startsWith("```")) {
+      const lang = line.slice(3).trim();
+      const code = [];
+      i++;
+      while (i < lines.length && !(lines[i] ?? "").startsWith("```")) {
+        code.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      out.push(
+        `<pre><code${lang ? ` class="language-${escape(lang)}"` : ""}>${escape(code.join("\n"))}</code></pre>`
+      );
+    } else if (line.startsWith("- ")) {
+      const items = [];
+      while (i < lines.length && (lines[i] ?? "").startsWith("- ")) {
+        items.push(`<li>${renderInlineMarkdown((lines[i] ?? "").slice(2))}</li>`);
+        i++;
+      }
+      out.push(`<ul>${items.join("")}</ul>`);
+    } else if (line.trim() === "") {
+      i++;
+    } else {
+      out.push(`<p>${renderInlineMarkdown(line)}</p>`);
+      i++;
+    }
+  }
+  return out.join("\n");
+}
+function renderInlineMarkdown(text) {
+  return text.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+}
+function renderBody(post) {
+  if (post.format === "html") return String(post.body);
+  if (post.format === "markdown") return renderMarkdown(String(post.body));
+  if (post.format === "tiptap") {
+    if (typeof post.body === "string") return post.body;
+    return renderTiptap(post.body);
+  }
+  return "";
+}
+function tiptapToHtml(doc) {
+  if (typeof doc === "string") return doc;
+  return renderTiptap(doc);
+}
+function markdownToHtml(md) {
+  return renderMarkdown(md);
+}
+function tiptapToMarkdown(doc) {
+  if (typeof doc === "string") return htmlToMarkdown(doc);
+  const node = doc;
+  return tiptapNodeToMarkdown(node).trim() + "\n";
+}
+function tiptapNodeToMarkdown(node) {
+  if (node.type === "text") {
+    let txt = node.text ?? "";
+    for (const mark of node.marks ?? []) {
+      if (mark.type === "bold") txt = `**${txt}**`;
+      else if (mark.type === "italic") txt = `*${txt}*`;
+      else if (mark.type === "code") txt = `\`${txt}\``;
+      else if (mark.type === "strike") txt = `~~${txt}~~`;
+      else if (mark.type === "link") txt = `[${txt}](${String(mark.attrs?.href ?? "#")})`;
+    }
+    return txt;
+  }
+  const children = (node.content ?? []).map(tiptapNodeToMarkdown).join("");
+  switch (node.type) {
+    case "doc":
+      return children;
+    case "paragraph":
+      return children + "\n\n";
+    case "heading": {
+      const level = Math.max(1, Math.min(6, Number(node.attrs?.level ?? 1)));
+      return "#".repeat(level) + " " + children + "\n\n";
+    }
+    case "bulletList":
+      return children + "\n";
+    case "orderedList":
+      return children + "\n";
+    case "listItem": {
+      const trimmed = children.replace(/\n+$/, "");
+      return "- " + trimmed + "\n";
+    }
+    case "codeBlock": {
+      const lang = node.attrs?.language ? String(node.attrs.language) : "";
+      return "```" + lang + "\n" + children + "\n```\n\n";
+    }
+    case "blockquote":
+      return children.replace(/\n+$/, "").split("\n").map((l) => "> " + l).join("\n") + "\n\n";
+    case "hardBreak":
+      return "  \n";
+    case "horizontalRule":
+      return "\n---\n\n";
+    case "image": {
+      const src = String(node.attrs?.src ?? "");
+      const alt = String(node.attrs?.alt ?? "");
+      return `![${alt}](${src})`;
+    }
+    default:
+      return children;
+  }
+}
+function htmlToMarkdown(html) {
+  let md = html;
+  md = md.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, text) => {
+    return "\n" + "#".repeat(Number(level)) + " " + String(text).trim() + "\n\n";
+  });
+  md = md.replace(
+    /<pre[^>]*><code[^>]*(?:\sclass="language-([^"]+)")?[^>]*>([\s\S]*?)<\/code><\/pre>/gi,
+    (_, lang, code) => {
+      return "\n```" + (lang ?? "") + "\n" + String(code) + "\n```\n\n";
+    }
+  );
+  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
+    return "\n" + String(content).trim().split("\n").map((l) => "> " + l).join("\n") + "\n\n";
+  });
+  md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_, items) => {
+    return "\n" + String(items).replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n") + "\n";
+  });
+  md = md.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (_, items) => {
+    let i = 1;
+    return "\n" + String(items).replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, () => `${i++}. $1
+`) + "\n";
+  });
+  md = md.replace(/<hr\s*\/?>/gi, "\n---\n\n");
+  md = md.replace(/<br\s*\/?>/gi, "  \n");
+  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, "$1\n\n");
+  md = md.replace(/<img[^>]*?src="([^"]*)"[^>]*?alt="([^"]*)"[^>]*?\/?>/gi, "![$2]($1)");
+  md = md.replace(/<img[^>]*?alt="([^"]*)"[^>]*?src="([^"]*)"[^>]*?\/?>/gi, "![$1]($2)");
+  md = md.replace(/<img[^>]*?src="([^"]*)"[^>]*?\/?>/gi, "![]($1)");
+  md = md.replace(/<a[^>]*?href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<(strong|b)>([\s\S]*?)<\/\1>/gi, "**$2**");
+  md = md.replace(/<(em|i)>([\s\S]*?)<\/\1>/gi, "*$2*");
+  md = md.replace(/<s>([\s\S]*?)<\/s>/gi, "~~$1~~");
+  md = md.replace(/<code>([\s\S]*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<\/?[^>]+>/g, "");
+  md = md.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+  md = md.replace(/\n{3,}/g, "\n\n");
+  return md.trim() + "\n";
+}
+
+// src/index.ts
+function createAmpless(opts) {
+  const { outputs, cmsConfig, themes } = opts;
+  const storage = createStorage(outputs);
+  const posts = createPostsApi(outputs);
+  const settings = createSiteSettings(cmsConfig, storage);
+  const seo = createSeo(cmsConfig, settings);
+  const themeActive = createThemeActive(themes, storage);
+  const themeConfig = createThemeConfig(themeActive, storage);
+  return {
+    listPublishedPosts: (o) => posts.listPublishedPosts(o),
+    getPublishedPost: (slug, o) => posts.getPublishedPost(slug, o),
+    listPostsByTag: (tag, o) => posts.listPostsByTag(tag, o),
+    loadSiteSettings: (siteId) => settings.loadSiteSettings(siteId),
+    resolveActiveTheme: (siteId) => themeActive.resolveActiveTheme(siteId),
+    loadThemeConfig: (siteId) => themeConfig.loadThemeConfig(siteId),
+    postMetadata: (post, siteId) => seo.postMetadata(post, siteId),
+    siteMetadata: (siteId) => seo.siteMetadata(siteId),
+    renderBody: (post) => renderBody(post),
+    renderThemeCss: (cssVars) => renderThemeCss(cssVars),
+    publicAssetUrl: (key) => storage.publicAssetUrl(key),
+    isStorageConfigured: () => storage.isStorageConfigured(),
+    outputs,
+    cmsConfig,
+    themes,
+    posts,
+    settings,
+    seo,
+    themeActive,
+    themeConfig,
+    storageApi: storage
+  };
+}
+export {
+  createAmpless,
+  htmlToMarkdown,
+  markdownToHtml,
+  renderBody,
+  renderThemeCss,
+  tiptapToHtml,
+  tiptapToMarkdown
+};

package/dist/middleware.d.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { Config } from 'ampless';
+
+interface CreateMiddlewareOpts {
+    cmsConfig: Config;
+}
+type MiddlewareFn = (request: NextRequest) => NextResponse;
+/**
+ * Build the ampless public-site middleware. Performs:
+ *
+ *  - hostname → siteId resolution (multi-site rewrites)
+ *  - `/path` → `/site/<siteId>/path` internal rewrite
+ *  - `<slug>.html` → `/site/<siteId>/raw/<slug>.html` (bare HTML route)
+ *  - `?previewTheme=<name>` → `x-preview-theme` header forwarding
+ *  - `Cache-Control: private, no-store` in multi-site mode (Amplify
+ *    Hosting's CloudFront cache key doesn't include Host, so SSR
+ *    responses would cross-contaminate at the same path)
+ *
+ * The factory captures the multi-site flag at construction time so the
+ * hot path stays a pair of cheap header lookups.
+ */
+declare function createAmplessMiddleware({ cmsConfig }: CreateMiddlewareOpts): MiddlewareFn;
+/**
+ * Default Next.js middleware matcher config. Exposed as a constant so
+ * templates can re-export it directly:
+ *
+ *     export const config = defaultMatcherConfig
+ *
+ * Excludes admin / api / login / static assets / amplify_outputs.json
+ * — without these exclusions middleware would rewrite legitimate
+ * non-blog routes into the public site tree.
+ */
+declare const defaultMatcherConfig: {
+    matcher: string[];
+};
+
+export { type CreateMiddlewareOpts, type MiddlewareFn, createAmplessMiddleware, defaultMatcherConfig };

package/dist/middleware.js

@@ -0,0 +1,43 @@
+// src/middleware.ts
+import { NextResponse } from "next/server";
+import { resolveSiteId, isMultiSite } from "ampless";
+var RAW_HTML_PATH_RE = /^\/([^/]+\.html)$/;
+function createAmplessMiddleware({ cmsConfig }) {
+  const MULTI_SITE = isMultiSite(cmsConfig);
+  return function middleware(request) {
+    const host = (request.headers.get("host") ?? "").split(":")[0];
+    const siteId = resolveSiteId(host ?? "", cmsConfig);
+    if (!siteId) {
+      return new NextResponse("Site not found", { status: 404 });
+    }
+    const url = request.nextUrl.clone();
+    if (!url.pathname.startsWith("/site/")) {
+      const rawMatch = RAW_HTML_PATH_RE.exec(url.pathname);
+      if (rawMatch) {
+        url.pathname = `/site/${siteId}/raw/${rawMatch[1]}`;
+      } else {
+        const tail = url.pathname === "/" ? "" : url.pathname;
+        url.pathname = `/site/${siteId}${tail}`;
+      }
+    }
+    const previewTheme = url.searchParams.get("previewTheme");
+    const requestHeaders = new Headers(request.headers);
+    requestHeaders.set("x-site-id", siteId);
+    if (previewTheme) requestHeaders.set("x-preview-theme", previewTheme);
+    const response = NextResponse.rewrite(url, { request: { headers: requestHeaders } });
+    response.headers.set("x-site-id", siteId);
+    if (MULTI_SITE) {
+      response.headers.set("Cache-Control", "private, no-store");
+    }
+    return response;
+  };
+}
+var defaultMatcherConfig = {
+  matcher: [
+    "/((?!admin|api|login|_next/static|_next/image|favicon\\.ico|amplify_outputs\\.json).*)"
+  ]
+};
+export {
+  createAmplessMiddleware,
+  defaultMatcherConfig
+};

package/dist/routes/index.d.ts

@@ -0,0 +1,77 @@
+import { Ampless } from '../index.js';
+import 'ampless';
+import 'next';
+
+interface Ctx$3 {
+    params: Promise<{
+        siteId: string;
+        slug: string;
+    }>;
+}
+type OgRouteHandler = (req: Request, ctx: Ctx$3) => Promise<Response>;
+declare function createOgRouteHandler(ampless: Ampless): OgRouteHandler;
+
+interface Ctx$2 {
+    params: Promise<{
+        siteId: string;
+    }>;
+}
+type SitemapRouteHandler = (req: Request, ctx: Ctx$2) => Promise<Response>;
+/**
+ * Sitemap route delegate. Looks up the active theme for the request's
+ * siteId and forwards to whichever `routes.sitemap` handler the theme
+ * provides. Themes without a sitemap handler return 404.
+ */
+declare function createSitemapRouteHandler(ampless: Ampless): SitemapRouteHandler;
+
+interface Ctx$1 {
+    params: Promise<{
+        siteId: string;
+    }>;
+}
+type FeedRouteHandler = (req: Request, ctx: Ctx$1) => Promise<Response>;
+/**
+ * Feed route delegate. Looks up the active theme for the request's
+ * siteId and forwards to whichever `routes.feed` handler the theme
+ * provides. Themes without a feed handler return 404.
+ */
+declare function createFeedRouteHandler(ampless: Ampless): FeedRouteHandler;
+
+interface Ctx {
+    params: Promise<{
+        siteId: string;
+        slug: string;
+    }>;
+}
+type RawRouteHandler = (req: Request, ctx: Ctx) => Promise<Response>;
+/**
+ * Bare HTML route. Returns the published post's rendered body as the
+ * entire HTTP response — no Next.js root layout, no theme chrome.
+ *
+ * Reached via the slug-suffix convention: middleware rewrites
+ * `/<slug>.html` → `/site/<siteId>/raw/<slug>.html`. The post is
+ * looked up by the full slug (including the `.html` part), so what
+ * the admin types in the slug field IS the URL.
+ *
+ * Why this is a route handler (not a page): Next.js's root layout
+ * always emits `<html>` / `<head>` / `<body>`, which means a normal
+ * page can't replace the document. A `route.ts` returns a Response
+ * directly and bypasses React rendering entirely.
+ *
+ * Format pairing:
+ *   - `format: 'html'` with a full `<!DOCTYPE html>...</html>` body
+ *     → the body lands in the response unchanged. Best fit for
+ *     custom landing pages with their own `<head>`, styles, scripts.
+ *   - `format: 'tiptap'` / `'markdown'` → renderBody returns an
+ *     HTML fragment. Browsers render fragments fine, but the page
+ *     ships without `<!DOCTYPE>` / `<head>` / `<title>`. If you care
+ *     about those, use `format: 'html'`.
+ *
+ * Trust model: the response body is the editor's content verbatim,
+ * with no sanitization. Same trust assumption as `format: 'html'`
+ * post bodies on the regular path — see
+ * docs/architecture/04-access-layer-mcp.md §"editor の信頼モデル".
+ */
+declare function createRawRouteHandler(ampless: Ampless): RawRouteHandler;
+
+export { type FeedRouteHandler, type OgRouteHandler, type RawRouteHandler, type SitemapRouteHandler, createFeedRouteHandler, createOgRouteHandler, createRawRouteHandler, createSitemapRouteHandler };