@ampless/runtime 0.2.0-alpha.3 → 0.2.0-alpha.4

package/dist/dispatchers/index.d.ts

@@ -29,8 +29,24 @@ type ThemePostDispatcher = (props: Props$1) => Promise<ReactNode>;
 type ThemePostMetadata = (props: Props$1) => Promise<Metadata>;
 /**
  * Post page dispatcher. Resolves the active theme and renders the
- * theme's `components.Post` server component. If the theme doesn't
- * declare a Post component, returns Next.js's notFound() (404).
+ * theme's `components.Post` server component.
+ *
+ * Before delegating, the dispatcher peeks at the post's metadata: if
+ * `metadata.no_layout === true`, the post is meant to be served as
+ * bare HTML (own DOCTYPE, no theme chrome, no Next.js root layout).
+ * Next.js page.tsx can't bypass the root layout, so we 308-redirect
+ * to the raw route handler at `/raw/<slug>` which returns the body
+ * unchanged. The redirect is permanent because no_layout is a
+ * persistent property of the post — bookmarks naturally settle on
+ * the `/raw/` URL.
+ *
+ * The metadata peek is an extra AppSync call before theme resolve,
+ * but it's the same query the theme's Post component would make
+ * anyway; AppSync's query-level dedupe within a single request keeps
+ * the wire cost flat in practice.
+ *
+ * If the theme doesn't declare a Post component at all, returns
+ * Next.js's notFound() (404).
  */
 declare function createThemePostDispatcher(ampless: Ampless): ThemePostDispatcher;
 /** generateMetadata factory for the post dispatcher. */

package/dist/dispatchers/index.js

@@ -17,10 +17,14 @@ function createThemeHomeMetadata(ampless) {
 }
 
 // src/dispatchers/post.ts
-import { notFound } from "next/navigation";
+import { notFound, redirect } from "next/navigation";
 function createThemePostDispatcher(ampless) {
   return async function SitePostDispatcher({ params }) {
-    const { siteId } = await params;
+    const { siteId, slug } = await params;
+    const post = await ampless.getPublishedPost(slug, { siteId });
+    if (post?.metadata?.no_layout === true) {
+      redirect(`/raw/${slug}`);
+    }
     const { module } = await ampless.resolveActiveTheme(siteId);
     const Post = module.components.Post;
     if (!Post) notFound();

package/dist/index.d.ts

@@ -34,6 +34,7 @@ interface PublicPostShape {
     status?: string | null;
     publishedAt?: string | null;
     tags?: Array<string | null> | null;
+    metadata?: unknown;
 }
 interface PublicPostConnectionShape {
     items?: Array<PublicPostShape | null> | null;

package/dist/index.js

@@ -28,6 +28,18 @@ function decodeBody(value) {
     return value;
   }
 }
+function decodeMetadata(value) {
+  if (value === null || value === void 0) return void 0;
+  const parsed = typeof value === "string" ? safeJsonParse(value) : value;
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
 function toCorePost(p) {
   return {
     postId: p.postId,
@@ -39,7 +51,8 @@ function toCorePost(p) {
     body: decodeBody(p.body),
     status: p.status ?? "draft",
     publishedAt: p.publishedAt ?? void 0,
-    tags: (p.tags ?? []).filter((t) => typeof t === "string")
+    tags: (p.tags ?? []).filter((t) => typeof t === "string"),
+    metadata: decodeMetadata(p.metadata)
   };
 }
 function createPostsApi(outputs) {

package/dist/middleware.d.ts

@@ -10,12 +10,18 @@ type MiddlewareFn = (request: NextRequest) => NextResponse;
  *
  *  - 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)
  *
+ * No-layout / bare-HTML routing is data-driven: the theme post
+ * dispatcher reads `post.metadata.no_layout` and redirects to
+ * `/raw/<slug>` when set. The plain prefix-prepend below picks up
+ * that path because the raw route lives at
+ * `app/site/<siteId>/raw/<slug>/route.ts` — no special middleware
+ * branch is needed.
+ *
  * The factory captures the multi-site flag at construction time so the
  * hot path stays a pair of cheap header lookups.
  */

package/dist/middleware.js

@@ -1,7 +1,6 @@
 // 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) {
@@ -12,13 +11,8 @@ function createAmplessMiddleware({ cmsConfig }) {
     }
     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 tail = url.pathname === "/" ? "" : url.pathname;
+      url.pathname = `/site/${siteId}${tail}`;
     }
     const previewTheme = url.searchParams.get("previewTheme");
     const requestHeaders = new Headers(request.headers);

package/dist/routes/index.d.ts

@@ -48,10 +48,13 @@ 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.
+ * 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).
  *
  * Why this is a route handler (not a page): Next.js's root layout
  * always emits `<html>` / `<head>` / `<body>`, which means a normal

package/dist/routes/index.js

@@ -75,6 +75,9 @@ function createRawRouteHandler(ampless) {
     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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ampless/runtime",
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.4",
   "description": "Public-side runtime for ampless: post fetching, theme dispatch, middleware, public route handlers",
   "license": "MIT",
   "type": "module",
@@ -48,8 +48,8 @@
     "clsx": "^2.1.1",
     "lucide-react": "^1.16.0",
     "tailwind-merge": "^3.6.0",
-    "ampless": "0.2.0-alpha.1",
-    "@ampless/plugin-og-image": "0.2.0-alpha.1"
+    "ampless": "0.2.0-alpha.2",
+    "@ampless/plugin-og-image": "0.2.0-alpha.2"
   },
   "peerDependencies": {
     "next": "^15 || ^16",