@nitrogenbuilder/connector-payload 0.1.43 → 0.1.50

package/dist/endpoints/collection-endpoints.js

@@ -1,4 +1,5 @@
-import { getNitrogenSettings, buildDynamicData, buildPageResponse, buildListItemResponse, getTemplateForType, requireAuth, } from './helpers.js';
+import { getNitrogenSettings, buildDynamicData, buildResolvedPageResponse, buildResolvedListItemResponse, getTemplateForType, requireAuth, canServeDocument, } from './helpers.js';
+import { resolveTemplateForDocument } from './templateConditions.js';
 /**
  * Creates a complete set of CRUD endpoints for a given Payload collection.
  *
@@ -28,7 +29,7 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                     limit: 0,
                     depth: 1,
                 });
-                const items = result.docs.map((doc) => buildListItemResponse(doc, settings, collectionSlug));
+                const items = await Promise.all(result.docs.map((doc) => buildResolvedListItemResponse(payload, doc, settings, collectionSlug)));
                 return Response.json(items);
             },
         },
@@ -67,16 +68,20 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                 const { payload, routeParams } = req;
                 const id = routeParams?.id;
                 try {
-                    const [doc, settings, headerTemplate, footerTemplate, pageTemplate] = await Promise.all([
+                    const [doc, settings, headerTemplate, footerTemplate] = await Promise.all([
                         payload.findByID({ collection, id, depth: 1 }),
                         getNitrogenSettings(payload),
                         getTemplateForType(payload, 'header'),
                         getTemplateForType(payload, 'footer'),
-                        getTemplateForType(payload, collectionSlug),
                     ]);
+                    if (!canServeDocument(req, doc, settings)) {
+                        return Response.json({ error: 'Not found' }, { status: 404 });
+                    }
+                    const pageTemplate = await resolveTemplateForDocument(payload, doc, collectionSlug, settings);
                     const dynamicData = buildDynamicData(doc, settings);
+                    const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                     return Response.json({
-                        ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                        ...response,
                         template: pageTemplate,
                         headerTemplate,
                         footerTemplate,
@@ -178,20 +183,24 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                 if (!slug) {
                     return Response.json({ error: 'Slug is required' }, { status: 400 });
                 }
-                const [result, settings, headerTemplate, footerTemplate, pageTemplate] = await Promise.all([
+                const [result, settings, headerTemplate, footerTemplate] = await Promise.all([
                     payload.find({ collection, where: { slug: { equals: slug } }, limit: 1, depth: 1 }),
                     getNitrogenSettings(payload),
                     getTemplateForType(payload, 'header'),
                     getTemplateForType(payload, 'footer'),
-                    getTemplateForType(payload, collectionSlug),
                 ]);
                 if (!result.docs.length) {
                     return Response.json({ error: 'Not found' }, { status: 404 });
                 }
                 const doc = result.docs[0];
+                if (!canServeDocument(req, doc, settings)) {
+                    return Response.json({ error: 'Not found' }, { status: 404 });
+                }
+                const pageTemplate = await resolveTemplateForDocument(payload, doc, collectionSlug, settings);
                 const dynamicData = buildDynamicData(doc, settings);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                 return Response.json({
-                    ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                    ...response,
                     template: pageTemplate,
                     headerTemplate,
                     footerTemplate,
@@ -205,20 +214,24 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
             handler: async (req) => {
                 const { payload, routeParams } = req;
                 const slug = routeParams?.slug;
-                const [result, settings, headerTemplate, footerTemplate, pageTemplate] = await Promise.all([
+                const [result, settings, headerTemplate, footerTemplate] = await Promise.all([
                     payload.find({ collection, where: { slug: { equals: slug } }, limit: 1, depth: 1 }),
                     getNitrogenSettings(payload),
                     getTemplateForType(payload, 'header'),
                     getTemplateForType(payload, 'footer'),
-                    getTemplateForType(payload, collectionSlug),
                 ]);
                 if (!result.docs.length) {
                     return Response.json({ error: 'Not found' }, { status: 404 });
                 }
                 const doc = result.docs[0];
+                if (!canServeDocument(req, doc, settings)) {
+                    return Response.json({ error: 'Not found' }, { status: 404 });
+                }
+                const pageTemplate = await resolveTemplateForDocument(payload, doc, collectionSlug, settings);
                 const dynamicData = buildDynamicData(doc, settings);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                 return Response.json({
-                    ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                    ...response,
                     template: pageTemplate,
                     headerTemplate,
                     footerTemplate,

package/dist/endpoints/ctrlLinkResolver.d.ts

@@ -0,0 +1,3 @@
+import type { Payload } from 'payload';
+import type { NitrogenSettingsGlobal } from '../types.js';
+export declare function resolveCtrlLinksInNitrogenData<T>(payload: Payload, value: T, settings: NitrogenSettingsGlobal): Promise<T>;

package/dist/endpoints/ctrlLinkResolver.js

@@ -0,0 +1,228 @@
+import { buildRelativePermalink, getRegisteredCollections, } from '../collection-registry.js';
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function getString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function getId(value) {
+    if (typeof value === 'string' || typeof value === 'number')
+        return value;
+    return null;
+}
+function cloneJson(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeRelativePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === '/home')
+        return '/';
+    try {
+        const parsed = new URL(trimmed);
+        return normalizeRelativePath(`${parsed.pathname}${parsed.search}${parsed.hash}`);
+    }
+    catch {
+        // Treat as already relative.
+    }
+    const [path = '', suffix = ''] = trimmed.split(/([?#].*)/, 2);
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const withoutTrailingSlash = normalizedPath.length > 1 ? normalizedPath.replace(/\/+$/, '') : normalizedPath;
+    return `${withoutTrailingSlash}${suffix}`;
+}
+function getPathname(value) {
+    const normalized = normalizeRelativePath(value);
+    return normalized.split(/[?#]/)[0] || '/';
+}
+function matchRoutePattern(pathname, routePattern) {
+    if (!routePattern)
+        return 1;
+    const pattern = getPathname(routePattern);
+    const placeholderMatch = pattern.match(/\[(?:\.\.\.)?slug\]/);
+    if (placeholderMatch) {
+        const base = pattern.slice(0, placeholderMatch.index).replace(/\/+$/, '');
+        if (!base) {
+            return pathname === '/' ? 0 : 20;
+        }
+        return pathname.startsWith(`${base}/`) ? 100 + base.length : 0;
+    }
+    if (pathname === pattern)
+        return 90 + pattern.length;
+    return pathname.startsWith(`${pattern}/`) ? 50 + pattern.length : 0;
+}
+function getCollectionCandidates(link, internalRef) {
+    const explicitCollection = getString(internalRef.collection) ||
+        getString(internalRef.collectionSlug) ||
+        getString(link.collection) ||
+        getString(link.collectionSlug);
+    const savedPath = getString(internalRef.relativePermalink) ||
+        getString(link.url) ||
+        getString(internalRef.slug);
+    const pathname = getPathname(savedPath);
+    const candidates = new Map();
+    if (explicitCollection) {
+        candidates.set(explicitCollection, Number.MAX_SAFE_INTEGER);
+    }
+    for (const collection of getRegisteredCollections()) {
+        const score = matchRoutePattern(pathname, collection.routePattern);
+        if (score <= 0)
+            continue;
+        candidates.set(collection.collectionSlug, Math.max(candidates.get(collection.collectionSlug) || 0, score));
+    }
+    if (!candidates.has('pages')) {
+        candidates.set('pages', 1);
+    }
+    return Array.from(candidates.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([collection]) => collection);
+}
+function getDocumentRelativePermalink(doc, collectionSlug) {
+    const breadcrumbs = doc.breadcrumbs;
+    const lastUrl = Array.isArray(breadcrumbs)
+        ? breadcrumbs.at(-1)?.url
+        : undefined;
+    if (typeof lastUrl === 'string' && lastUrl.trim()) {
+        return normalizeRelativePath(lastUrl);
+    }
+    return buildRelativePermalink(collectionSlug, String(doc.slug || ''));
+}
+function getDocumentPermalink(doc, settings, collectionSlug) {
+    const relativePermalink = getDocumentRelativePermalink(doc, collectionSlug);
+    const baseUrl = (settings.frontendUrl || '').replace(/\/$/, '');
+    return baseUrl ? `${baseUrl}${relativePermalink}` : relativePermalink;
+}
+function getPayloadBaseUrl(settings) {
+    return (process.env.NEXT_PUBLIC_PAYLOAD_API_URL ||
+        process.env.NEXT_PUBLIC_SERVER_URL ||
+        settings.nitrogenEditorUrl ||
+        settings.instanceUrl ||
+        '').replace(/\/$/, '');
+}
+function resolveMediaUrl(url, settings) {
+    if (!url || /^https?:\/\//i.test(url))
+        return url;
+    const baseUrl = getPayloadBaseUrl(settings);
+    const relativeUrl = url.startsWith('/') ? url : `/${url}`;
+    return baseUrl ? `${baseUrl}${relativeUrl}` : relativeUrl;
+}
+async function findInternalTarget(context, link, internalRef) {
+    const entryId = getId(internalRef.entryId);
+    if (entryId === null)
+        return null;
+    const candidates = getCollectionCandidates(link, internalRef);
+    for (const collection of candidates) {
+        try {
+            const doc = (await context.payload.findByID({
+                collection: collection,
+                id: entryId,
+                depth: 1,
+                disableErrors: true,
+            }));
+            if (!doc)
+                continue;
+            return {
+                slug: String(doc.slug || internalRef.slug || ''),
+                relativePermalink: getDocumentRelativePermalink(doc, collection),
+                url: getDocumentPermalink(doc, context.settings, collection),
+            };
+        }
+        catch {
+            // Try the next candidate collection.
+        }
+    }
+    return null;
+}
+async function resolveInternalLink(context, link, internalRef) {
+    const entryId = getId(internalRef.entryId);
+    if (entryId === null)
+        return null;
+    const key = [
+        entryId,
+        getString(internalRef.relativePermalink),
+        getString(link.url),
+        getString(internalRef.collection),
+        getString(link.collection),
+    ].join(':');
+    if (!context.internalLinks.has(key)) {
+        context.internalLinks.set(key, findInternalTarget(context, link, internalRef));
+    }
+    return context.internalLinks.get(key);
+}
+async function findMediaTarget(context, mediaRef) {
+    const mediaId = getId(mediaRef.mediaId);
+    if (mediaId === null)
+        return null;
+    try {
+        const doc = (await context.payload.findByID({
+            collection: 'media',
+            id: mediaId,
+            depth: 0,
+            disableErrors: true,
+        }));
+        const url = doc?.url || '';
+        if (!doc || !url)
+            return null;
+        return {
+            filename: doc.filename || getString(mediaRef.filename),
+            mimeType: doc.mimeType || getString(mediaRef.mimeType),
+            url: resolveMediaUrl(url, context.settings),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveMediaLink(context, mediaRef) {
+    const mediaId = getId(mediaRef.mediaId);
+    if (mediaId === null)
+        return null;
+    const key = String(mediaId);
+    if (!context.mediaLinks.has(key)) {
+        context.mediaLinks.set(key, findMediaTarget(context, mediaRef));
+    }
+    return context.mediaLinks.get(key);
+}
+async function resolveLinkRecord(context, link) {
+    if (link.type === 'internal' && isRecord(link.internalRef)) {
+        const resolved = await resolveInternalLink(context, link, link.internalRef);
+        if (!resolved)
+            return;
+        link.url = resolved.url;
+        link.internalRef.slug = resolved.slug;
+        link.internalRef.relativePermalink = resolved.relativePermalink;
+        return;
+    }
+    if (link.type === 'media' && isRecord(link.mediaRef)) {
+        const resolved = await resolveMediaLink(context, link.mediaRef);
+        if (!resolved)
+            return;
+        link.url = resolved.url;
+        link.mediaRef.url = resolved.url;
+        link.mediaRef.filename = resolved.filename;
+        link.mediaRef.mimeType = resolved.mimeType;
+    }
+}
+async function walk(context, value) {
+    if (Array.isArray(value)) {
+        await Promise.all(value.map((item) => walk(context, item)));
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    await resolveLinkRecord(context, value);
+    await Promise.all(Object.values(value).map((item) => walk(context, item)));
+}
+export async function resolveCtrlLinksInNitrogenData(payload, value, settings) {
+    if (!value)
+        return value;
+    const cloned = cloneJson(value);
+    const context = {
+        internalLinks: new Map(),
+        mediaLinks: new Map(),
+        payload,
+        settings,
+    };
+    await walk(context, cloned);
+    return cloned;
+}

package/dist/endpoints/helpers.d.ts

@@ -31,6 +31,29 @@ export declare function buildPageResponse(doc: NitrogenPageDoc | NitrogenTemplat
         wysiwygColors: {};
     };
 };
+export declare function buildResolvedPageResponse(payload: Payload, doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, dynamicData: JsonObject, collectionSlug?: string): Promise<{
+    id: string | number;
+    token: string;
+    title: string;
+    author: string | number;
+    slug: string;
+    permalink: string;
+    relative_permalink: string;
+    content: string;
+    dynamic_data: JsonObject;
+    settings: JsonObject;
+    nitrogen_settings: {
+        variables?: Record<string, {
+            type?: string;
+            value?: string | boolean;
+        }> | Array<{
+            name: string;
+            value?: string;
+        }>;
+        urlMaps: never[];
+        wysiwygColors: {};
+    };
+}>;
 export declare function buildListItemResponse(doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, collectionSlug?: string): {
     id: string | number;
     title: string;
@@ -51,6 +74,26 @@ export declare function buildListItemResponse(doc: NitrogenPageDoc | NitrogenTem
         wysiwygColors: {};
     };
 };
+export declare function buildResolvedListItemResponse(payload: Payload, doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, collectionSlug?: string): Promise<{
+    id: string | number;
+    title: string;
+    slug: string;
+    permalink: string;
+    relative_permalink: string;
+    content: string;
+    settings: JsonObject;
+    nitrogen_settings: {
+        variables?: Record<string, {
+            type?: string;
+            value?: string | boolean;
+        }> | Array<{
+            name: string;
+            value?: string;
+        }>;
+        urlMaps: never[];
+        wysiwygColors: {};
+    };
+}>;
 export declare function buildMediaItemResponse(doc: MediaDoc): {
     id: string | number;
     filename: string;
@@ -98,3 +141,16 @@ export declare function getNitrogenSettings(payload: Payload): Promise<NitrogenS
  */
 export declare function getTemplateForType(payload: Payload, type: string): Promise<TemplateRef | null>;
 export declare function requireAuth(req: PayloadRequest): Response | null;
+/**
+ * True when the request carries the connector token (the `x-nitrogen-token`
+ * header, or `nitrogen-token` query param for iframe URLs) matching the stored
+ * `connectorToken` setting. Lets the staging frontend / editor preview draft &
+ * private docs without a logged-in session. Mirrors WP `preview_token_valid`.
+ */
+export declare function previewTokenValid(req: PayloadRequest, settings: NitrogenSettingsGlobal): boolean;
+/**
+ * Whether a document may be served for a given request. Published docs are
+ * public; non-published (draft/pending/private) docs require either a logged-in
+ * user or a valid preview token. Mirrors the WP status gate in `get_item`.
+ */
+export declare function canServeDocument(req: PayloadRequest, doc: Record<string, unknown> | null | undefined, settings: NitrogenSettingsGlobal): boolean;

package/dist/endpoints/helpers.js

@@ -1,4 +1,5 @@
 import { buildRelativePermalink } from '../collection-registry.js';
+import { resolveCtrlLinksInNitrogenData } from './ctrlLinkResolver.js';
 function normalizeRelativePath(value) {
     const trimmed = value.trim();
     if (!trimmed || trimmed === '/home')
@@ -95,6 +96,13 @@ export function buildPageResponse(doc, settings, dynamicData, collectionSlug = '
         },
     };
 }
+export async function buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug = 'pages') {
+    const response = buildPageResponse(doc, settings, dynamicData, collectionSlug);
+    if (doc.nitrogenData) {
+        response.content = JSON.stringify(await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings));
+    }
+    return response;
+}
 export function buildListItemResponse(doc, settings, collectionSlug = 'pages') {
     const pageSettings = 'pageSettings' in doc ? doc.pageSettings : undefined;
     const templateSettings = 'templateSettings' in doc ? doc.templateSettings : undefined;
@@ -114,6 +122,13 @@ export function buildListItemResponse(doc, settings, collectionSlug = 'pages') {
         },
     };
 }
+export async function buildResolvedListItemResponse(payload, doc, settings, collectionSlug = 'pages') {
+    const response = buildListItemResponse(doc, settings, collectionSlug);
+    if (doc.nitrogenData) {
+        response.content = JSON.stringify(await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings));
+    }
+    return response;
+}
 export function buildMediaItemResponse(doc) {
     const filename = doc.filename || '';
     const ext = filename.includes('.') ? `.${filename.split('.').pop()}` : '';
@@ -197,9 +212,13 @@ export async function getTemplateForType(payload, type) {
         const doc = result.docs[0];
         if (!doc)
             return null;
+        const settings = await getNitrogenSettings(payload);
+        const resolvedNitrogenData = doc.nitrogenData
+            ? await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings)
+            : null;
         return {
             ID: doc.id,
-            content: doc.nitrogenData ? JSON.stringify(doc.nitrogenData) : '[]',
+            content: resolvedNitrogenData ? JSON.stringify(resolvedNitrogenData) : '[]',
         };
     }
     catch {
@@ -212,3 +231,49 @@ export function requireAuth(req) {
     }
     return null;
 }
+// Constant-time string compare in pure JS — deliberately avoids importing a
+// node builtin. Payload's tsx-based `migrate` bin transpiles the config graph
+// and chokes when esbuild normalizes a builtin import to `node:crypto`
+// (ENOENT on `node:crypto?tsx-namespace=…`), so nothing reachable from the
+// config at load time may statically import `crypto`.
+function timingSafeStringEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let mismatch = 0;
+    for (let i = 0; i < a.length; i++) {
+        mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return mismatch === 0;
+}
+/**
+ * True when the request carries the connector token (the `x-nitrogen-token`
+ * header, or `nitrogen-token` query param for iframe URLs) matching the stored
+ * `connectorToken` setting. Lets the staging frontend / editor preview draft &
+ * private docs without a logged-in session. Mirrors WP `preview_token_valid`.
+ */
+export function previewTokenValid(req, settings) {
+    const expected = settings.connectorToken;
+    if (!expected)
+        return false;
+    let token = req.headers?.get?.('x-nitrogen-token') || '';
+    if (!token) {
+        const url = new URL(req.url || '', 'http://localhost');
+        token = url.searchParams.get('nitrogen-token') || '';
+    }
+    if (!token)
+        return false;
+    return timingSafeStringEqual(String(expected), token);
+}
+/**
+ * Whether a document may be served for a given request. Published docs are
+ * public; non-published (draft/pending/private) docs require either a logged-in
+ * user or a valid preview token. Mirrors the WP status gate in `get_item`.
+ */
+export function canServeDocument(req, doc, settings) {
+    if (!doc)
+        return false;
+    const status = String(doc._status ?? doc.status ?? 'published');
+    if (status === 'published')
+        return true;
+    return !!req.user || previewTokenValid(req, settings);
+}

package/dist/endpoints/sitemap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Sitemap endpoints — ported from the WordPress connector
+ * (rest-routes.php: get_sitemap_index, get_sitemap_for_post_type,
+ * build_sitemap_urls_for_post_type, resolve_sitemap_locs_for_post).
+ *
+ * PORTING NOTE: in WP a single post could emit MULTIPLE `loc`s — one per
+ * nitrogen_template matching the post, each contributing its own `url_prefix`
+ * (so a post served at both canonical and prefixed URLs appeared multiple
+ * times). The TARGET (Payload) model has exactly one `routePattern` per
+ * registered collection, so we emit ONE canonical URL per document via
+ * `buildRelativePermalink`. Per-template prefix multiplexing is deferred.
+ */
+import type { Endpoint } from 'payload';
+export declare const sitemapEndpoints: Endpoint[];

package/dist/endpoints/sitemap.js

@@ -0,0 +1,109 @@
+/**
+ * Sitemap endpoints — ported from the WordPress connector
+ * (rest-routes.php: get_sitemap_index, get_sitemap_for_post_type,
+ * build_sitemap_urls_for_post_type, resolve_sitemap_locs_for_post).
+ *
+ * PORTING NOTE: in WP a single post could emit MULTIPLE `loc`s — one per
+ * nitrogen_template matching the post, each contributing its own `url_prefix`
+ * (so a post served at both canonical and prefixed URLs appeared multiple
+ * times). The TARGET (Payload) model has exactly one `routePattern` per
+ * registered collection, so we emit ONE canonical URL per document via
+ * `buildRelativePermalink`. Per-template prefix multiplexing is deferred.
+ */
+import { buildRelativePermalink, getRegisteredCollections, resolveCollection, } from '../collection-registry.js';
+import { findAllDocs } from '../inventory/indexing.js';
+/** Internal Nitrogen collections that must never appear in the sitemap. */
+const EXCLUDED_COLLECTIONS = new Set([
+    'nitrogen-templates',
+    'nitrogen-component-catalog',
+    'nitrogen-component-usage',
+]);
+/**
+ * Fetch published docs for a collection selecting only `slug` and `updatedAt`.
+ *
+ * Payload collections may or may not have drafts enabled (the `_status`
+ * field). We first try filtering by `_status: 'published'`; if that throws
+ * (collection has no `_status`), we fall back to fetching all docs.
+ */
+async function fetchPublishedSitemapDocs(payload, collection) {
+    const select = { slug: true, updatedAt: true };
+    try {
+        return await findAllDocs(payload, collection, {
+            where: { _status: { equals: 'published' } },
+            select,
+        });
+    }
+    catch {
+        return findAllDocs(payload, collection, { select });
+    }
+}
+/** Coerce a doc's updatedAt into an ISO-8601 string, or null when absent. */
+function toIsoString(value) {
+    if (!value)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+export const sitemapEndpoints = [
+    // GET /nitrogen/v1/sitemap — sitemap index (mirror get_sitemap_index)
+    {
+        path: '/nitrogen/v1/sitemap',
+        method: 'get',
+        handler: async (req) => {
+            const { payload } = req;
+            const postTypes = [];
+            for (const { collectionSlug } of getRegisteredCollections()) {
+                if (EXCLUDED_COLLECTIONS.has(collectionSlug))
+                    continue;
+                let docs;
+                try {
+                    docs = await fetchPublishedSitemapDocs(payload, collectionSlug);
+                }
+                catch {
+                    // One bad collection shouldn't 500 the whole index — skip it.
+                    continue;
+                }
+                if (docs.length === 0)
+                    continue;
+                let lastmod = null;
+                for (const doc of docs) {
+                    const iso = toIsoString(doc.updatedAt);
+                    if (iso !== null && (lastmod === null || iso > lastmod)) {
+                        lastmod = iso;
+                    }
+                }
+                postTypes.push({ post_type: collectionSlug, lastmod });
+            }
+            return Response.json({ post_types: postTypes });
+        },
+    },
+    // GET /nitrogen/v1/sitemap/:post_type — URLs for one post type
+    // (mirror get_sitemap_for_post_type)
+    {
+        path: '/nitrogen/v1/sitemap/:post_type',
+        method: 'get',
+        handler: async (req) => {
+            const { payload, routeParams } = req;
+            const postType = String(routeParams?.post_type || '');
+            const collection = resolveCollection(postType);
+            if (EXCLUDED_COLLECTIONS.has(collection)) {
+                return Response.json({ error: 'Post type not eligible for sitemap' }, { status: 404 });
+            }
+            let docs;
+            try {
+                docs = await fetchPublishedSitemapDocs(payload, collection);
+            }
+            catch {
+                return Response.json({ error: 'No URLs for this post type' }, { status: 404 });
+            }
+            const urls = docs.map((doc) => ({
+                loc: buildRelativePermalink(postType, String(doc.slug || '')),
+                lastmod: toIsoString(doc.updatedAt),
+            }));
+            if (urls.length === 0) {
+                return Response.json({ error: 'No URLs for this post type' }, { status: 404 });
+            }
+            return Response.json({ urls });
+        },
+    },
+];

package/dist/endpoints/templateConditions.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Template Conditions — TypeScript port of the WordPress
+ * `Nitrogen\TemplateConditions` scoring engine
+ * (nitrogen-connector/includes/template-conditions.php).
+ *
+ * Resolves the best-matching nitrogen-template for a document by scoring
+ * editor-authored condition groups (OR'd groups, AND'd conditions within a
+ * group) and falling back to a legacy associatedCollection match.
+ *
+ * Everything here is pure/typed and defensive: the evaluators never throw —
+ * malformed input simply yields a non-match (false).
+ */
+import type { Payload } from 'payload';
+import type { JsonObject, NitrogenPageDoc, NitrogenTemplateDoc, NitrogenSettingsGlobal } from '../types.js';
+import { type TemplateRef } from './helpers.js';
+/**
+ * Evaluation context for a single document.
+ *
+ * `dynamic` holds the buildDynamicData() namespace; `post` is the raw document.
+ * The dynamic_data evaluator resolves its dot-path against both (dynamic first,
+ * then post) so editor-authored paths match leniently.
+ */
+export interface TemplateContext {
+    post: NitrogenPageDoc | NitrogenTemplateDoc | Record<string, unknown>;
+    postType: string;
+    postId: string;
+    dynamic: JsonObject;
+}
+/**
+ * Evaluate authored conditions against a context (php:45-100).
+ *
+ * Groups are OR'd; conditions within a group are AND'd. An `exclude` flag
+ * inverts a condition's result. An unknown condition type fails the whole group.
+ *
+ * Returns the matched-condition count (score) of the first matching group, or
+ * false. If there are no conditionGroups, returns false (the caller handles the
+ * legacy fallback).
+ */
+export declare function evaluateConditions(templateConditions: unknown, context: TemplateContext): number | false;
+/**
+ * Build the evaluation context for a document (php:187-216, Payload-adapted).
+ */
+export declare function buildTemplateContext(doc: NitrogenPageDoc | NitrogenTemplateDoc, collectionSlug: string, settings: NitrogenSettingsGlobal): TemplateContext;
+/**
+ * Resolve the best-matching template for a document
+ * (php:140-182 resolve_template + php:106-132 evaluate_legacy).
+ *
+ * Returns a { ID, content } ref with ctrl-links resolved and content
+ * JSON-stringified — the same shape getTemplateForType() returns — or null if
+ * no template matches.
+ */
+export declare function resolveTemplateForDocument(payload: Payload, doc: NitrogenPageDoc | NitrogenTemplateDoc, collectionSlug: string, settings: NitrogenSettingsGlobal): Promise<TemplateRef | null>;