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

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,19 @@ 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}`);
+    }
+    if (post?.format === "static") {
+      const body = post.body ?? null;
+      const entrypoint = typeof body?.entrypoint === "string" && body.entrypoint ? body.entrypoint : "index.html";
+      redirect(`/${slug}/${entrypoint}`);
+    }
     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

@@ -2,21 +2,21 @@ import { Ampless } from '../index.js';
 import 'ampless';
 import 'next';
 
-interface Ctx$3 {
+interface Ctx$4 {
     params: Promise<{
         siteId: string;
         slug: string;
     }>;
 }
-type OgRouteHandler = (req: Request, ctx: Ctx$3) => Promise<Response>;
+type OgRouteHandler = (req: Request, ctx: Ctx$4) => Promise<Response>;
 declare function createOgRouteHandler(ampless: Ampless): OgRouteHandler;
 
-interface Ctx$2 {
+interface Ctx$3 {
     params: Promise<{
         siteId: string;
     }>;
 }
-type SitemapRouteHandler = (req: Request, ctx: Ctx$2) => Promise<Response>;
+type SitemapRouteHandler = (req: Request, ctx: Ctx$3) => Promise<Response>;
 /**
  * Sitemap route delegate. Looks up the active theme for the request's
  * siteId and forwards to whichever `routes.sitemap` handler the theme
@@ -24,12 +24,12 @@ type SitemapRouteHandler = (req: Request, ctx: Ctx$2) => Promise<Response>;
  */
 declare function createSitemapRouteHandler(ampless: Ampless): SitemapRouteHandler;
 
-interface Ctx$1 {
+interface Ctx$2 {
     params: Promise<{
         siteId: string;
     }>;
 }
-type FeedRouteHandler = (req: Request, ctx: Ctx$1) => Promise<Response>;
+type FeedRouteHandler = (req: Request, ctx: Ctx$2) => Promise<Response>;
 /**
  * Feed route delegate. Looks up the active theme for the request's
  * siteId and forwards to whichever `routes.feed` handler the theme
@@ -37,21 +37,24 @@ type FeedRouteHandler = (req: Request, ctx: Ctx$1) => Promise<Response>;
  */
 declare function createFeedRouteHandler(ampless: Ampless): FeedRouteHandler;
 
-interface Ctx {
+interface Ctx$1 {
     params: Promise<{
         siteId: string;
         slug: string;
     }>;
 }
-type RawRouteHandler = (req: Request, ctx: Ctx) => Promise<Response>;
+type RawRouteHandler = (req: Request, ctx: Ctx$1) => 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
@@ -74,4 +77,37 @@ type RawRouteHandler = (req: Request, ctx: Ctx) => Promise<Response>;
  */
 declare function createRawRouteHandler(ampless: Ampless): RawRouteHandler;
 
-export { type FeedRouteHandler, type OgRouteHandler, type RawRouteHandler, type SitemapRouteHandler, createFeedRouteHandler, createOgRouteHandler, createRawRouteHandler, createSitemapRouteHandler };
+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 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+declare function createStaticRouteHandler(ampless: Ampless): StaticRouteHandler;
+
+export { type FeedRouteHandler, type OgRouteHandler, type RawRouteHandler, type SitemapRouteHandler, type StaticRouteHandler, createFeedRouteHandler, createOgRouteHandler, createRawRouteHandler, createSitemapRouteHandler, createStaticRouteHandler };

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: {
@@ -84,9 +87,78 @@ function createRawRouteHandler(ampless) {
     });
   };
 }
+
+// src/routes/static.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) {
+  const { runWithAmplifyServerContext } = createServerRunner({
+    config: ampless.outputs
+  });
+  return async function GET(request, { params }) {
+    const { siteId, path } = await params;
+    if (!path || path.length === 0) {
+      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;
+    }
+    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 }
+      });
+    }
+  };
+}
 export {
   createFeedRouteHandler,
   createOgRouteHandler,
   createRawRouteHandler,
-  createSitemapRouteHandler
+  createSitemapRouteHandler,
+  createStaticRouteHandler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ampless/runtime",
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.5",
   "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.3",
+    "@ampless/plugin-og-image": "0.2.0-alpha.3"
   },
   "peerDependencies": {
     "next": "^15 || ^16",