@ampless/runtime 0.2.0-alpha.9 → 1.0.0-alpha.14

package/dist/middleware.js

@@ -1,30 +1,189 @@
 // src/middleware.ts
 import { NextResponse } from "next/server";
-import { resolveSiteId, isMultiSite } from "ampless";
-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 });
+var runtime = "nodejs";
+var FLAG_CACHE_MAX = 200;
+var FLAG_CACHE_TTL_MS = 6e4;
+var FLAG_CACHE = /* @__PURE__ */ new Map();
+function cacheGet(slug) {
+  const hit = FLAG_CACHE.get(slug);
+  if (!hit) return void 0;
+  if (hit.expires < Date.now()) {
+    FLAG_CACHE.delete(slug);
+    return void 0;
+  }
+  FLAG_CACHE.delete(slug);
+  FLAG_CACHE.set(slug, hit);
+  return hit.value;
+}
+function cacheSet(slug, value) {
+  if (FLAG_CACHE.size >= FLAG_CACHE_MAX) {
+    const oldest = FLAG_CACHE.keys().next().value;
+    if (oldest !== void 0) FLAG_CACHE.delete(oldest);
+  }
+  FLAG_CACHE.set(slug, { value, expires: Date.now() + FLAG_CACHE_TTL_MS });
+}
+function _resetFlagCache() {
+  FLAG_CACHE.clear();
+}
+async function fetchFlags(opts, slug) {
+  const query = `query MiddlewareFlags($slug: String!) {
+    getPublishedPost(slug: $slug) { format metadata updatedAt }
+  }`;
+  let res;
+  try {
+    res = await fetch(opts.appsyncUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": opts.apiKey
+      },
+      body: JSON.stringify({ query, variables: { slug } })
+    });
+  } catch (err) {
+    console.error("[ampless-middleware] AppSync fetch failed", err);
+    return null;
+  }
+  if (!res.ok) {
+    console.error(
+      `[ampless-middleware] AppSync returned ${res.status} for slug=${slug}`
+    );
+    return null;
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    console.error("[ampless-middleware] AppSync JSON parse failed", err);
+    return null;
+  }
+  if (body.errors && body.errors.length > 0) {
+    console.error(
+      "[ampless-middleware] AppSync errors",
+      body.errors.map((e) => e.message)
+    );
+    return null;
+  }
+  const post = body.data?.getPublishedPost;
+  if (!post) return null;
+  let metadata = null;
+  if (post.metadata) {
+    try {
+      const parsed = typeof post.metadata === "string" ? JSON.parse(post.metadata) : post.metadata;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        metadata = parsed;
+      }
+    } catch (err) {
+      console.error(
+        `[ampless-middleware] metadata parse failed for slug=${slug}`,
+        err
+      );
+      metadata = null;
     }
+  }
+  return {
+    format: post.format ?? "markdown",
+    metadata,
+    updatedAt: post.updatedAt ?? ""
+  };
+}
+async function getCachedFlags(opts, slug) {
+  const cached = cacheGet(slug);
+  if (cached !== void 0) return cached;
+  const fresh = await fetchFlags(opts, slug);
+  cacheSet(slug, fresh);
+  return fresh;
+}
+var DEFAULT_COOLDOWN_MS = 60 * 60 * 1e3;
+var DEFAULT_FRESH_TTL_SECONDS = 300;
+var DEFAULT_DEEP_TTL_SECONDS = 60 * 60;
+var NO_STORE = "public, max-age=0, must-revalidate, s-maxage=0";
+function computeCacheControl(flags, cmsConfig) {
+  const cache = cmsConfig.cache ?? {};
+  const strategy = flags.metadata?.cache ?? "auto";
+  if (strategy === "hot") return NO_STORE;
+  if (strategy === "deep") {
+    const ttl = cache.deepTtlSeconds ?? DEFAULT_DEEP_TTL_SECONDS;
+    return `public, max-age=${ttl}, s-maxage=${ttl}`;
+  }
+  const cooldownMs = cache.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+  const freshTtl = cache.freshTtlSeconds ?? DEFAULT_FRESH_TTL_SECONDS;
+  const updatedMs = flags.updatedAt ? Date.parse(flags.updatedAt) : NaN;
+  if (Number.isFinite(updatedMs)) {
+    const ageMs = Date.now() - updatedMs;
+    if (ageMs < cooldownMs) return NO_STORE;
+  }
+  return `public, max-age=${freshTtl}, s-maxage=${freshTtl}`;
+}
+var RESERVED_PREFIXES = /* @__PURE__ */ new Set([
+  "admin",
+  "api",
+  "login",
+  "_next",
+  "favicon.ico",
+  "robots.txt",
+  "amplify_outputs.json",
+  // route handler folders that live alongside `app/[slug]/page.tsx`
+  "feed.xml",
+  "sitemap.xml",
+  "og",
+  "tag",
+  // internal rewrite target — direct hits should not be middleware-driven
+  "r"
+]);
+function createAmplessMiddleware(opts) {
+  return async function middleware(request) {
     const url = request.nextUrl.clone();
-    if (!url.pathname.startsWith("/site/")) {
-      const tail = url.pathname === "/" ? "" : url.pathname;
-      url.pathname = `/site/${siteId}${tail}`;
-    }
     const previewTheme = url.searchParams.get("previewTheme");
     const previewColorScheme = url.searchParams.get("previewColorScheme");
     const requestHeaders = new Headers(request.headers);
-    requestHeaders.set("x-site-id", siteId);
     if (previewTheme) requestHeaders.set("x-preview-theme", previewTheme);
-    if (previewColorScheme) requestHeaders.set("x-preview-color-scheme", previewColorScheme);
-    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");
+    if (previewColorScheme) {
+      requestHeaders.set("x-preview-color-scheme", previewColorScheme);
+    }
+    const passthrough = () => NextResponse.next({ request: { headers: requestHeaders } });
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      return passthrough();
+    }
+    const slug = segments[0];
+    if (RESERVED_PREFIXES.has(slug)) {
+      return passthrough();
+    }
+    const restPath = segments.slice(1);
+    const flags = await getCachedFlags(opts, slug);
+    if (!flags) {
+      if (restPath.length > 0) {
+        return new NextResponse("Not Found", { status: 404 });
+      }
+      return passthrough();
+    }
+    const cacheControl = computeCacheControl(flags, opts.cmsConfig);
+    let response;
+    if (restPath.length === 0) {
+      if (flags.format === "html" && flags.metadata?.no_layout === true) {
+        url.pathname = `/r/${slug}`;
+        response = NextResponse.rewrite(url, {
+          request: { headers: requestHeaders }
+        });
+      } else if (flags.format === "static") {
+        url.pathname = `/r/${slug}`;
+        response = NextResponse.rewrite(url, {
+          request: { headers: requestHeaders }
+        });
+      } else {
+        response = passthrough();
+      }
+    } else {
+      if (flags.format === "static") {
+        url.pathname = `/r/${slug}/${restPath.join("/")}`;
+        response = NextResponse.rewrite(url, {
+          request: { headers: requestHeaders }
+        });
+      } else {
+        return new NextResponse("Not Found", { status: 404 });
+      }
     }
+    response.headers.set("Cache-Control", cacheControl);
     return response;
   };
 }
@@ -34,6 +193,9 @@ var defaultMatcherConfig = {
   ]
 };
 export {
+  _resetFlagCache,
+  computeCacheControl,
   createAmplessMiddleware,
-  defaultMatcherConfig
+  defaultMatcherConfig,
+  runtime
 };

package/dist/routes/index.d.ts

@@ -2,112 +2,85 @@ import { Ampless } from '../index.js';
 import 'ampless';
 import 'next';
 
-interface Ctx$4 {
+interface Ctx$3 {
     params: Promise<{
-        siteId: string;
         slug: string;
     }>;
 }
-type OgRouteHandler = (req: Request, ctx: Ctx$4) => Promise<Response>;
+type OgRouteHandler = (req: Request, ctx: Ctx$3) => Promise<Response>;
 declare function createOgRouteHandler(ampless: Ampless): OgRouteHandler;
 
-interface Ctx$3 {
-    params: Promise<{
-        siteId: string;
-    }>;
+interface Ctx$2 {
+    params: Promise<Record<string, never>>;
 }
-type SitemapRouteHandler = (req: Request, ctx: Ctx$3) => Promise<Response>;
+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.
+ * Sitemap route delegate. Looks up the active theme 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$2 {
-    params: Promise<{
-        siteId: string;
-    }>;
+interface Ctx$1 {
+    params: Promise<Record<string, never>>;
 }
-type FeedRouteHandler = (req: Request, ctx: Ctx$2) => Promise<Response>;
+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.
+ * Feed route delegate. Looks up the active theme 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$1 {
+interface Ctx {
     params: Promise<{
-        siteId: string;
         slug: string;
+        path?: string[];
     }>;
 }
-type RawRouteHandler = (req: Request, ctx: Ctx$1) => Promise<Response>;
+type UnderscoreRouteHandler = (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 data-driven dispatcher path: the theme post page
- * checks `post.metadata.no_layout` and redirects to `/raw/<slug>` when
- * set. Posts without that flag never hit this route in practice; the
- * handler additionally enforces the same check here so a direct
- * `/raw/<slug>` request can't bypass the theme for a post that wasn't
- * marked no-layout (would otherwise surface the body without any
- * chrome the editor didn't intend).
+ * Unified internal route handler for no_layout HTML and static bundle
+ * posts. Mounted at `app/r/[slug]/[[...path]]/route.ts`; reached via
+ * middleware rewrite from the public `/<slug>(/<path>)` URL, never
+ * directly.
  *
- * 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.
+ * Two cases that both need to bypass the themed post page:
  *
- * 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'`.
+ *  1. `format: 'html'` posts with `metadata.no_layout === true` — the
+ *     body is its own complete HTML document and ships as the entire
+ *     response. Reached via middleware rewrite of `/<slug>`.
+ *  2. `format: 'static'` posts — the body is a manifest describing a
+ *     bundle of files in S3 at `public/static/<slug>/`. The bundle's
+ *     entrypoint is served at `/<slug>/`, every internal file at
+ *     `/<slug>/<relative-path>` (middleware rewrites both to
+ *     `/r/<slug>/...`).
  *
- * 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;
-
-interface Ctx {
-    params: Promise<{
-        siteId: string;
-        path: string[];
-    }>;
-}
-type StaticRouteHandler = (req: Request, ctx: Ctx) => Promise<Response>;
-/**
- * Catch-all route for static bundles. Lives at
- * `app/site/[siteId]/[...path]/route.ts` and serves every file
- * inside a `format: 'static'` post's bundle. The first segment of
- * `path` is the post slug; the rest is the relative path inside the
- * bundle (or empty, in which case the manifest's entrypoint is used).
+ * Routing model:
+ *   - File location: `app/r/[slug]/[[...path]]/route.ts`. The literal
+ *     folder is `r/` (not `_/` etc.) because Next.js's App Router
+ *     skips any path part starting with `_` during route discovery
+ *     (see `recursive-readdir` + `ignorePartFilter` in
+ *     next/dist/build/route-discovery.js). The `r/` prefix is an
+ *     internal filesystem detail — the public URL stays `/<slug>(/...)`.
+ *   - `params.path` is `undefined` (or `[]`) for single-segment
+ *     requests, an array of remaining segments otherwise.
  *
- * Routing precedence: Next.js prefers the more specific
- * `[siteId]/[slug]/page.tsx` for single-segment URLs, so this catch-all
- * only fires when path.length >= 2. The post dispatcher detects
- * `format === 'static'` and 308-redirects to `/<slug>/<entrypoint>`
- * so the catch-all picks up from there.
+ * Trailing-slash responsibility lives here. For static bundles the
+ * handler 308-redirects `/<slug>` to `/<slug>/` so relative asset
+ * paths inside the bundle resolve correctly — `<img src="img.png">`
+ * must resolve to `/<slug>/img.png`, not the site root.
  *
- * Single-segment requests (`/<siteId>/<slug>`) that somehow do reach
- * here are 308-redirected to add a trailing slash, which is what makes
- * relative paths in the bundle resolve correctly in the browser.
+ * Trust model: no_layout HTML bodies are emitted verbatim, same trust
+ * shape as `format: 'html'` post bodies on the regular path. Static
+ * bundle assets are served via short-lived S3 presigned URLs; the
+ * bucket stays private. See docs/architecture/04-access-layer-mcp.md
+ * §"editor の信頼モデル".
  *
- * Implementation: generate a short-lived presigned URL for the S3
- * object and 302-redirect to it. Same model as `/api/media/[...path]`
- * — keeps the bucket private while letting CloudFront cache the 302
- * for the Cache-Control window. The presigned URL itself expires in
- * an hour; the 302 cache is 5 minutes so re-issued presigns stay
- * fresh.
+ * Cache-Control: deliberately omitted from the responses here.
+ * Middleware computes the strategy from `metadata.cache` +
+ * `post.updatedAt` and sets the header on the rewritten response.
  */
-declare function createStaticRouteHandler(ampless: Ampless): StaticRouteHandler;
+declare function createUnderscoreRouteHandler(ampless: Ampless): UnderscoreRouteHandler;
 
-export { type FeedRouteHandler, type OgRouteHandler, type RawRouteHandler, type SitemapRouteHandler, type StaticRouteHandler, createFeedRouteHandler, createOgRouteHandler, createRawRouteHandler, createSitemapRouteHandler, createStaticRouteHandler };
+export { type FeedRouteHandler, type OgRouteHandler, type SitemapRouteHandler, type UnderscoreRouteHandler, createFeedRouteHandler, createOgRouteHandler, createSitemapRouteHandler, createUnderscoreRouteHandler };

package/dist/routes/index.js

@@ -6,13 +6,13 @@ function hasOgImage(p) {
 }
 function createOgRouteHandler(ampless) {
   return async function GET(_req, { params }) {
-    const { siteId, slug } = await params;
+    const { slug } = await params;
     const cleanSlug = slug.replace(/\.png$/, "");
-    const post = await ampless.getPublishedPost(cleanSlug, { siteId });
+    const post = await ampless.getPublishedPost(cleanSlug);
     if (!post) return new Response("not found", { status: 404 });
     const plugin = (ampless.cmsConfig.plugins ?? []).find(hasOgImage);
     if (!plugin) return new Response("og not configured", { status: 404 });
-    const settings = await ampless.loadSiteSettings(siteId);
+    const settings = await ampless.loadSiteSettings();
     const fonts = await Promise.all(
       plugin.ogImage.fonts.map(async (f) => ({
         name: f.name,
@@ -43,122 +43,128 @@ function createOgRouteHandler(ampless) {
 
 // src/routes/sitemap.ts
 function createSitemapRouteHandler(ampless) {
-  return async function GET(request, { params }) {
-    const { siteId } = await params;
-    const { module } = await ampless.resolveActiveTheme(siteId);
+  return async function GET(request) {
+    const { module } = await ampless.resolveActiveTheme();
     const handler = module.routes?.sitemap;
     if (!handler) {
       return new Response("sitemap not implemented for this theme", { status: 404 });
     }
-    return handler({ siteId, request });
+    return handler({ request });
   };
 }
 
 // src/routes/feed.ts
 function createFeedRouteHandler(ampless) {
-  return async function GET(request, { params }) {
-    const { siteId } = await params;
-    const { module } = await ampless.resolveActiveTheme(siteId);
+  return async function GET(request) {
+    const { module } = await ampless.resolveActiveTheme();
     const handler = module.routes?.feed;
     if (!handler) {
       return new Response("feed not implemented for this theme", { status: 404 });
     }
-    return handler({ siteId, request });
+    return handler({ request });
   };
 }
 
-// src/routes/raw.ts
-function createRawRouteHandler(ampless) {
-  return async function GET(_request, { params }) {
-    const { siteId, slug } = await params;
-    const post = await ampless.getPublishedPost(slug, { siteId });
-    if (!post) {
-      return new Response("Not Found", { status: 404 });
-    }
-    if (post.metadata?.no_layout !== true) {
-      return new Response("Not Found", { status: 404 });
-    }
-    return new Response(ampless.renderBody(post), {
-      status: 200,
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "public, max-age=300"
-      }
-    });
-  };
-}
-
-// src/routes/static.ts
+// src/routes/underscore.ts
 import { createServerRunner } from "@aws-amplify/adapter-nextjs";
 import { cookies } from "next/headers";
 import { getUrl } from "aws-amplify/storage/server";
-var FALLBACK_MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".htm": "text/html; charset=utf-8"
-};
-function createStaticRouteHandler(ampless) {
+function createUnderscoreRouteHandler(ampless) {
   const { runWithAmplifyServerContext } = createServerRunner({
     config: ampless.outputs
   });
   return async function GET(request, { params }) {
-    const { siteId, path } = await params;
-    if (!path || path.length === 0) {
+    const { slug, path } = await params;
+    const restSegments = path ?? [];
+    const post = await ampless.getPublishedPost(slug);
+    if (!post) {
+      return new Response("Not Found", { status: 404 });
+    }
+    if (restSegments.length === 0) {
+      if (post.format === "html" && post.metadata?.no_layout === true) {
+        return new Response(ampless.renderBody(post), {
+          status: 200,
+          headers: {
+            "Content-Type": "text/html; charset=utf-8"
+            // Cache-Control set by middleware (cache strategy depends on
+            // post.metadata.cache + post.updatedAt).
+          }
+        });
+      }
+      if (post.format === "static") {
+        const url = new URL(request.url);
+        if (!url.pathname.endsWith("/")) {
+          const next = new URL(url);
+          next.pathname = `${url.pathname}/`;
+          return Response.redirect(next.toString(), 308);
+        }
+        const body2 = post.body ?? null;
+        const entrypoint = typeof body2?.entrypoint === "string" && body2.entrypoint ? body2.entrypoint : "index.html";
+        const presignedUrl2 = await signStaticAsset({
+          runWithAmplifyServerContext,
+          slug,
+          rest: entrypoint
+        });
+        if (!presignedUrl2) {
+          return new Response("Not Found", { status: 404 });
+        }
+        return Response.redirect(presignedUrl2, 302);
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+    if (post.format !== "static") {
       return new Response("Not Found", { status: 404 });
     }
-    const slug = path[0];
-    const restSegments = path.slice(1);
     if (restSegments.some(
       (s) => !s || s === "." || s === ".." || s.includes("/") || s.includes("\\") || s.includes("\0")
     )) {
       return new Response("Invalid path", { status: 400 });
     }
-    const post = await ampless.getPublishedPost(slug, { siteId });
-    if (!post || post.format !== "static") {
-      return new Response("Not Found", { status: 404 });
-    }
     const body = post.body ?? null;
-    const entrypoint = typeof body?.entrypoint === "string" && body.entrypoint ? body.entrypoint : "index.html";
     const fileList = Array.isArray(body?.files) ? body.files : [];
-    let rest = restSegments.join("/");
-    if (rest === "") {
-      const url = new URL(request.url);
-      if (!url.pathname.endsWith("/")) {
-        const next = new URL(url);
-        next.pathname = `${url.pathname}/`;
-        return Response.redirect(next.toString(), 308);
-      }
-      rest = entrypoint;
-    }
+    const rest = restSegments.join("/");
     if (fileList.length > 0 && !fileList.includes(rest)) {
       return new Response("Not Found", { status: 404 });
     }
-    const objectPath = `public/static/${siteId}/${slug}/${rest}`;
-    try {
-      const presignedUrl = await runWithAmplifyServerContext({
-        nextServerContext: { cookies },
-        operation: async (amplifyContext) => {
-          const result = await getUrl(amplifyContext, {
-            path: objectPath,
-            options: { expiresIn: 60 * 60 }
-          });
-          return result.url.toString();
-        }
-      });
-      return Response.redirect(presignedUrl, 302);
-    } catch {
-      const ext = rest.slice(rest.lastIndexOf("."));
-      const fallback = FALLBACK_MIME[ext] ?? "text/plain; charset=utf-8";
-      return new Response("Not Found", {
-        status: 404,
-        headers: { "Content-Type": fallback }
-      });
+    const presignedUrl = await signStaticAsset({
+      runWithAmplifyServerContext,
+      slug,
+      rest
+    });
+    if (!presignedUrl) {
+      return new Response("Not Found", { status: 404 });
     }
+    return Response.redirect(presignedUrl, 302);
   };
 }
+async function signStaticAsset({
+  runWithAmplifyServerContext,
+  slug,
+  rest
+}) {
+  const objectPath = `public/static/${slug}/${rest}`;
+  try {
+    return await runWithAmplifyServerContext({
+      nextServerContext: { cookies },
+      operation: async (amplifyContext) => {
+        const result = await getUrl(amplifyContext, {
+          path: objectPath,
+          options: { expiresIn: 60 * 60 }
+        });
+        return result.url.toString();
+      }
+    });
+  } catch (err) {
+    console.error(
+      `[underscore-route] presign failed for ${objectPath}:`,
+      err
+    );
+    return null;
+  }
+}
 export {
   createFeedRouteHandler,
   createOgRouteHandler,
-  createRawRouteHandler,
   createSitemapRouteHandler,
-  createStaticRouteHandler
+  createUnderscoreRouteHandler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ampless/runtime",
-  "version": "0.2.0-alpha.9",
+  "version": "1.0.0-alpha.14",
   "description": "Public-side runtime for ampless: post fetching, theme dispatch, middleware, public route handlers",
   "license": "MIT",
   "type": "module",
@@ -47,9 +47,10 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^1.16.0",
+    "marked": "^14.1.4",
     "tailwind-merge": "^3.6.0",
-    "ampless": "0.2.0-alpha.6",
-    "@ampless/plugin-og-image": "0.2.0-alpha.6"
+    "ampless": "1.0.0-alpha.10",
+    "@ampless/plugin-og-image": "0.2.0-alpha.10"
   },
   "peerDependencies": {
     "next": "^15 || ^16",