@publish.os/nextjs 0.0.1-alpha.2 → 0.0.1-alpha.3

package/dist/{layouts → kernel/routes/layouts}/group.js

@@ -1,4 +1,4 @@
-// src/layouts/group.tsx
+// src/kernel/routes/layouts/group.tsx
 import { cacheLife, cacheTag } from "next/cache";
 import { notFound } from "next/navigation";
 
@@ -48,14 +48,18 @@ var tags = {
   },
   llms(scope = "root") {
     return assertTag(`llms:${safeSegment(scope)}`);
+  },
+  feed(format, scope = "site") {
+    return assertTag(`feed:${safeSegment(format)}:${safeSegment(scope)}`);
   }
 };
 
 // src/internal/utils/logger.ts
 var isDev = process.env.NODE_ENV !== "production";
+var isDebugEnabled = process.env.NEXT_PRIVATE_DEBUG_CACHE === "1";
 var log = {
   debug(...args) {
-    if (isDev) console.debug("[publish.os:debug]", ...args);
+    if (isDev && isDebugEnabled) console.debug("[publish.os:debug]", ...args);
   },
   info(...args) {
     console.log("[publish.os]", ...args);
@@ -96,35 +100,55 @@ function resolveGroupLayout(manifest, group, children) {
   return { ...resolved, children };
 }
 
-// src/layouts/group.tsx
+// src/kernel/routes/layouts/group.tsx
 import { jsx } from "react/jsx-runtime";
 var manifests = /* @__PURE__ */ new Map();
-var layouts = /* @__PURE__ */ new Map();
-async function CachedGroupLayoutData({ group }) {
+var layoutChains = /* @__PURE__ */ new Map();
+async function CachedGroupLayoutData({
+  routeGroup,
+  layoutGroup
+}) {
   "use cache";
   cacheLife("page");
-  cacheTag(tags.site(), tags.group(group));
-  const manifest = manifests.get(group);
+  cacheTag(tags.site(), tags.group(layoutGroup));
+  const manifest = manifests.get(routeGroup);
   if (!manifest) notFound();
   cacheTag(tags.manifest(manifest.contentHash));
-  log.debug("[cache]", `${group}/layout`);
-  const resolved = resolveGroupLayout(manifest, group, null);
+  log.debug("[cache]", `${routeGroup}/layout:${layoutGroup}`);
+  const resolved = resolveGroupLayout(manifest, layoutGroup, null);
   if (!resolved) notFound();
   return resolved;
 }
 function createGroupLayout({
   group,
   manifest,
-  Layout
+  layouts
 }) {
   manifests.set(group, manifest);
-  layouts.set(group, Layout);
+  layoutChains.set(group, layouts);
   return async function GroupLayout({ children }) {
     log.debug("[render]", `${group}/layout`);
-    const Layout2 = layouts.get(group);
-    if (!Layout2) notFound();
-    const resolved = await CachedGroupLayoutData({ group });
-    return /* @__PURE__ */ jsx(Layout2, { ...resolved, children });
+    const chain = layoutChains.get(group);
+    if (!chain?.length) notFound();
+    const resolvedLayouts = await Promise.all(
+      chain.map(async (item) => ({
+        item,
+        props: await CachedGroupLayoutData({
+          layoutGroup: item.group,
+          routeGroup: group
+        })
+      }))
+    );
+    let output = children;
+    for (let index = resolvedLayouts.length - 1; index >= 0; index -= 1) {
+      const resolvedLayout = resolvedLayouts[index];
+      if (resolvedLayout) {
+        const Layout = resolvedLayout.item.Layout;
+        const fontClassName = resolvedLayout.item.fontClassName;
+        output = /* @__PURE__ */ jsx(Layout, { ...resolvedLayout.props, children: fontClassName ? /* @__PURE__ */ jsx("div", { className: fontClassName, children: output }) : output });
+      }
+    }
+    return output;
   };
 }
 export {

package/dist/kernel/routes/metadata/feed.cjs

@@ -0,0 +1,297 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/kernel/routes/metadata/feed.ts
+var feed_exports = {};
+__export(feed_exports, {
+  createAtomFeedRoute: () => createAtomFeedRoute,
+  createJsonFeedRoute: () => createJsonFeedRoute,
+  createPrecomputedFeedRoute: () => createPrecomputedFeedRoute,
+  createRssFeedRoute: () => createRssFeedRoute
+});
+module.exports = __toCommonJS(feed_exports);
+var import_cache = require("next/cache");
+
+// src/cache/tags.ts
+var import_node_crypto = require("crypto");
+var MAX_TAG_LEN = 256;
+var MAX_SEGMENT_LEN = 80;
+var TAG_PATTERN = /^[a-z0-9:_./-]+$/;
+function sha256(value) {
+  return (0, import_node_crypto.createHash)("sha256").update(value).digest("hex").slice(0, 16);
+}
+function safeSegment(value) {
+  const raw = value.trim().toLowerCase() || "root";
+  const normalized = raw.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "").replace(/[^a-z0-9:_./-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const segment = normalized || "root";
+  if (segment.length <= MAX_SEGMENT_LEN) return segment;
+  return `${segment.slice(0, 48)}.${sha256(segment)}`;
+}
+function assertTag(tag) {
+  if (tag.length > MAX_TAG_LEN || !TAG_PATTERN.test(tag)) {
+    return `tag:${sha256(tag)}`;
+  }
+  return tag;
+}
+var tags = {
+  site() {
+    return "site";
+  },
+  pages() {
+    return "pages";
+  },
+  group(group) {
+    return assertTag(`group:${safeSegment(group)}`);
+  },
+  page(group, slug) {
+    const path = Array.isArray(slug) ? slug.join("/") : slug;
+    return assertTag(`page:${safeSegment(group)}:${safeSegment(path)}`);
+  },
+  manifest(contentHash) {
+    return assertTag(`manifest:${safeSegment(contentHash)}`);
+  },
+  sitemap() {
+    return "sitemap";
+  },
+  robots() {
+    return "robots";
+  },
+  llms(scope = "root") {
+    return assertTag(`llms:${safeSegment(scope)}`);
+  },
+  feed(format, scope = "site") {
+    return assertTag(`feed:${safeSegment(format)}:${safeSegment(scope)}`);
+  }
+};
+
+// src/kernel/routes/response.ts
+var CACHE_CONTROL = "public, max-age=300, s-maxage=86400, stale-while-revalidate=3600, must-revalidate";
+var CDN_CACHE_CONTROL = "public, max-age=2592000, stale-while-revalidate=31536000";
+var SHORT_CACHE_CONTROL = "public, max-age=60, s-maxage=600, stale-while-revalidate=300, must-revalidate";
+var SHORT_CDN_CACHE_CONTROL = "public, max-age=300, stale-while-revalidate=3600";
+function cacheControl(policy) {
+  if (!policy || policy === "default") return CACHE_CONTROL;
+  if (policy === "short") return SHORT_CACHE_CONTROL;
+  return policy;
+}
+function cdnCacheControl(policy) {
+  if (!policy || policy === "default") return CDN_CACHE_CONTROL;
+  if (policy === "short") return SHORT_CDN_CACHE_CONTROL;
+  return policy;
+}
+function cachedTextHeaders(contentType, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set("cache-control", cacheControl(options.cachePolicy));
+  headers.set("cdn-cache-control", cdnCacheControl(options.cachePolicy));
+  headers.set("vercel-cdn-cache-control", cdnCacheControl(options.cachePolicy));
+  headers.set("content-type", contentType);
+  headers.set("x-content-type-options", "nosniff");
+  if (options.etag) headers.set("etag", options.etag);
+  if (options.noindex) headers.set("x-robots-tag", "noindex");
+  return headers;
+}
+function createCachedTextResponse(options) {
+  const status = options.status ?? 200;
+  const method = options.method ?? options.request?.method ?? "GET";
+  const headers = cachedTextHeaders(options.contentType, options);
+  const isNotModified = status === 200 && options.etag && options.request?.headers.get("if-none-match") === options.etag;
+  return new Response(
+    method === "HEAD" || isNotModified ? null : options.body,
+    {
+      headers,
+      status: isNotModified ? 304 : status
+    }
+  );
+}
+
+// src/kernel/routes/metadata/feed.ts
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function pageTimestamp(page) {
+  const value = page.publishedAt ?? page.updatedAt;
+  if (!value) return -Infinity;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? -Infinity : timestamp;
+}
+function canonicalUrl(manifest, path) {
+  const origin = manifest.site.url?.replace(/\/+$/, "");
+  if (!origin) return path;
+  try {
+    return new URL(path, `${origin}/`).toString();
+  } catch {
+    return path;
+  }
+}
+function pageInScope(page, options) {
+  if (options.scope === "site" || !options.group) return true;
+  if (options.scope === "self") return page.group === options.group;
+  return page.group === options.group || page.group.startsWith(`${options.group}/`);
+}
+function feedPages(manifest, options) {
+  const statuses = options.status ?? ["published"];
+  const pages = manifest.pages.filter((page) => statuses.includes(page.status)).filter((page) => pageInScope(page, options)).sort((a, b) => pageTimestamp(b) - pageTimestamp(a));
+  return options.limit ? pages.slice(0, options.limit) : pages;
+}
+async function rssXml(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("rss", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const title = manifest.site.name;
+  const description = manifest.site.description ?? title;
+  const pages = feedPages(manifest, options);
+  const homeUrl = canonicalUrl(manifest, "/");
+  const items = pages.map((page) => {
+    const pageUrl = canonicalUrl(manifest, page.path);
+    const pubDate = page.publishedAt ? `
+      <pubDate>${xmlEscape(new Date(page.publishedAt).toUTCString())}</pubDate>` : "";
+    const description2 = page.description ? `
+      <description>${xmlEscape(page.description)}</description>` : "";
+    return `    <item>
+      <title>${xmlEscape(page.title)}</title>
+      <link>${xmlEscape(pageUrl)}</link>
+      <guid>${xmlEscape(pageUrl)}</guid>${pubDate}${description2}
+    </item>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${xmlEscape(title)}</title>
+    <link>${xmlEscape(homeUrl)}</link>
+    <description>${xmlEscape(description)}</description>
+${items}
+  </channel>
+</rss>
+`;
+}
+function pageDate(page) {
+  return page.publishedAt ?? page.updatedAt;
+}
+function latestFeedDate(pages) {
+  const timestamp = Math.max(0, ...pages.map((page) => pageTimestamp(page)));
+  return new Date(timestamp).toISOString();
+}
+async function atomXml(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("atom", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const title = manifest.site.name;
+  const pages = feedPages(manifest, options);
+  const homeUrl = canonicalUrl(manifest, "/");
+  const entries = pages.map((page) => {
+    const date = pageDate(page);
+    const updated = date ? new Date(date).toISOString() : latestFeedDate([]);
+    const pageUrl = canonicalUrl(manifest, page.path);
+    const summary = page.description ? `
+    <summary>${xmlEscape(page.description)}</summary>` : "";
+    return `  <entry>
+    <title>${xmlEscape(page.title)}</title>
+    <id>${xmlEscape(pageUrl)}</id>
+    <link href="${xmlEscape(pageUrl)}" />
+    <updated>${xmlEscape(updated)}</updated>${summary}
+  </entry>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${xmlEscape(title)}</title>
+  <id>${xmlEscape(homeUrl)}</id>
+  <updated>${xmlEscape(latestFeedDate(pages))}</updated>
+${entries}
+</feed>
+`;
+}
+async function jsonFeed(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("json", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const pages = feedPages(manifest, options);
+  return `${JSON.stringify(
+    {
+      version: "https://jsonfeed.org/version/1.1",
+      title: manifest.site.name,
+      description: manifest.site.description,
+      home_page_url: canonicalUrl(manifest, "/"),
+      items: pages.map((page) => ({
+        id: canonicalUrl(manifest, page.path),
+        url: canonicalUrl(manifest, page.path),
+        title: page.title,
+        summary: page.description,
+        content_text: page.body,
+        date_published: page.publishedAt,
+        date_modified: page.updatedAt,
+        tags: page.tags
+      }))
+    },
+    null,
+    2
+  )}
+`;
+}
+function createRssFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await rssXml(manifest, options),
+      contentType: "application/rss+xml; charset=utf-8"
+    });
+  };
+}
+function createAtomFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await atomXml(manifest, options),
+      contentType: "application/atom+xml; charset=utf-8"
+    });
+  };
+}
+function createJsonFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await jsonFeed(manifest, options),
+      contentType: "application/feed+json; charset=utf-8"
+    });
+  };
+}
+function createPrecomputedFeedRoute(output) {
+  return function GET() {
+    return createCachedTextResponse({
+      body: output.body,
+      contentType: output.contentType,
+      etag: output.etag
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAtomFeedRoute,
+  createJsonFeedRoute,
+  createPrecomputedFeedRoute,
+  createRssFeedRoute
+});

package/dist/kernel/routes/metadata/feed.d.cts

@@ -0,0 +1,21 @@
+import { ManifestLike, PageStatus } from '../../../types.cjs';
+import 'react';
+
+type FeedScope = "site" | "group" | "self";
+type FeedRouteOptions = {
+    scope?: FeedScope;
+    group?: string;
+    limit?: number;
+    status?: PageStatus[];
+};
+type PrecomputedFeedOutput = {
+    body: string;
+    contentType: string;
+    etag?: string;
+};
+declare function createRssFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createAtomFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createJsonFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createPrecomputedFeedRoute(output: PrecomputedFeedOutput): () => Response;
+
+export { type FeedRouteOptions, type FeedScope, type PrecomputedFeedOutput, createAtomFeedRoute, createJsonFeedRoute, createPrecomputedFeedRoute, createRssFeedRoute };

package/dist/kernel/routes/metadata/feed.d.ts

@@ -0,0 +1,21 @@
+import { ManifestLike, PageStatus } from '../../../types.js';
+import 'react';
+
+type FeedScope = "site" | "group" | "self";
+type FeedRouteOptions = {
+    scope?: FeedScope;
+    group?: string;
+    limit?: number;
+    status?: PageStatus[];
+};
+type PrecomputedFeedOutput = {
+    body: string;
+    contentType: string;
+    etag?: string;
+};
+declare function createRssFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createAtomFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createJsonFeedRoute(manifest: ManifestLike, options?: FeedRouteOptions): () => Promise<Response>;
+declare function createPrecomputedFeedRoute(output: PrecomputedFeedOutput): () => Response;
+
+export { type FeedRouteOptions, type FeedScope, type PrecomputedFeedOutput, createAtomFeedRoute, createJsonFeedRoute, createPrecomputedFeedRoute, createRssFeedRoute };