canopycms-next 0.0.62 → 0.0.64

package/dist/adapter.d.ts

@@ -23,7 +23,7 @@ export declare function wrapNextRequest(req: Request): CanopyRequest;
  * // app/api/canopycms/[...canopycms]/route.ts
  * import { createCanopyCatchAllHandler } from 'canopycms-next'
  * import { createClerkAuthPlugin } from 'canopycms-auth-clerk'
- * import config from '../../../../canopycms.config'
+ * import config from '../../../../canopycms.config.js'
  *
  * const handler = createCanopyCatchAllHandler({
  *   config: config.server,
@@ -46,4 +46,3 @@ export declare const createCanopyCatchAllHandler: (options: CanopyNextOptions) =
         [key: string]: unknown;
     };
 }) => Promise<Response>;
-//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.js

@@ -92,7 +92,7 @@ async function extractPathSegments(ctx) {
  * // app/api/canopycms/[...canopycms]/route.ts
  * import { createCanopyCatchAllHandler } from 'canopycms-next'
  * import { createClerkAuthPlugin } from 'canopycms-auth-clerk'
- * import config from '../../../../canopycms.config'
+ * import config from '../../../../canopycms.config.js'
  *
  * const handler = createCanopyCatchAllHandler({
  *   config: config.server,
@@ -130,4 +130,3 @@ export const createCanopyCatchAllHandler = (options) => {
         }
     };
 };
-//# sourceMappingURL=adapter.js.map

package/dist/client.d.ts

@@ -16,7 +16,7 @@ import type { CanopyClientConfig, CustomFieldRenderers } from 'canopycms/client'
  * // app/edit/page.tsx
  * 'use client'
  * import { NextCanopyEditorPage } from 'canopycms-next/client'
- * import config from '../../canopycms.config'
+ * import config from '../../canopycms.config.js'
  *
  * export default function EditPage() {
  *   const clientConfig = config.client()
@@ -26,4 +26,3 @@ import type { CanopyClientConfig, CustomFieldRenderers } from 'canopycms/client'
  * ```
  */
 export declare const NextCanopyEditorPage: (config: CanopyClientConfig, customRenderers?: CustomFieldRenderers) => () => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=client.d.ts.map

package/dist/client.js

@@ -20,7 +20,7 @@ import { CanopyEditorPage } from 'canopycms/client';
  * // app/edit/page.tsx
  * 'use client'
  * import { NextCanopyEditorPage } from 'canopycms-next/client'
- * import config from '../../canopycms.config'
+ * import config from '../../canopycms.config.js'
  *
  * export default function EditPage() {
  *   const clientConfig = config.client()
@@ -47,4 +47,3 @@ export const NextCanopyEditorPage = (config, customRenderers) => {
         return (_jsx(Suspense, { fallback: null, children: _jsx(EditorWithSearchParams, {}) }));
     };
 };
-//# sourceMappingURL=client.js.map

package/dist/config.d.ts

@@ -1,2 +1 @@
-export { withCanopy, type WithCanopyOptions } from './with-canopy';
-//# sourceMappingURL=config.d.ts.map
+export { withCanopy, type WithCanopyOptions } from './with-canopy.js';

package/dist/config.js

@@ -1,2 +1 @@
-export { withCanopy } from './with-canopy';
-//# sourceMappingURL=config.js.map
+export { withCanopy } from './with-canopy.js';

package/dist/context-wrapper.d.ts

@@ -1,12 +1,43 @@
-import { type CanopyContext, type CanopyBuildContext, type CanopyServices } from 'canopycms/server';
+import { type CanopyContext, type CanopyBuildContext, type CanopyServices, type SeoFieldLocation } from 'canopycms/server';
 import type { CanopyConfig, AuthPlugin, FieldConfig } from 'canopycms';
-import { createCanopyCatchAllHandler } from './adapter';
-import { type GenerateContentStaticParamsOptions } from './static';
+import type { Metadata, MetadataRoute } from 'next';
+import { createCanopyCatchAllHandler } from './adapter.js';
+import { type EntryToMetadataOptions, type GenerateContentSitemapOptions, type GenerateContentStaticParamsOptions } from './static.js';
+/**
+ * Merge a context-wide default SEO field location (`createNextCanopyContext({ seo })`) with a
+ * per-call override.
+ *
+ * `generateContentSitemap`'s `noindex` exclusion and `entryToMetadata`'s field extraction/`noindex`
+ * read must agree on where the SEO fields live, or the two surfaces drift: an entry can end up
+ * `noindex` on the page while the sitemap still advertises its URL (or the reverse), because each
+ * call site independently forgot (or mis-set) `group`/`fields`. Both bound helpers below call this
+ * SAME function with the SAME context-wide default, which is what makes agreement structural
+ * rather than a matter of adopter discipline.
+ *
+ * Only keys the caller actually supplies override the default — an omitted (or explicitly
+ * `undefined`) `fields`/`group` falls through to the context-wide value, so setting a default once
+ * and never repeating it per call is the common case. A plain `{ ...contextDefault, ...callOverride
+ * }` would NOT have this property: `entryToMetadata`'s options type always has `fields`/`group`
+ * keys, so a caller who omits them still produces an object whose `fields`/`group` are present but
+ * `undefined`, and spreading that would silently clobber the default. Checking each key explicitly
+ * avoids that trap. Exported for direct unit testing.
+ */
+export declare function mergeSeoFieldLocation(contextDefault: SeoFieldLocation | undefined, callOverride: SeoFieldLocation | undefined): SeoFieldLocation;
 export interface NextCanopyOptions {
     config: CanopyConfig;
     /** Auth plugin for user authentication. Optional for static deployments (deployedAs: 'static'). */
     authPlugin?: AuthPlugin;
     entrySchemaRegistry: Record<string, readonly FieldConfig[]>;
+    /**
+     * Where the SEO fields live (`fields` name overrides, and/or a nested `group`). Set once here
+     * and it is shared by BOTH the returned `generateContentSitemap`'s `noindex` exclusion and the
+     * returned `entryToMetadata`'s field extraction, so the two surfaces cannot independently forget
+     * or mis-set it and drift apart — see `mergeSeoFieldLocation`. Omit for the flat (inline-group)
+     * convention, which is the default on both the schema side (`defineSeoFieldGroup()`) and here.
+     * A per-call `seo`/`fields`/`group` option on either helper still overrides this default for
+     * that one call.
+     */
+    seo?: SeoFieldLocation;
 }
 /**
  * Wrap a build context so its operations throw if misused at request time on a production server.
@@ -55,6 +86,25 @@ export interface NextCanopyContextResult {
     readByUrlPath: CanopyContext['readByUrlPath'];
     /** Phase-selecting `read` (build context at build, runtime context at request) — counterpart to readByUrlPath. */
     read: CanopyContext['read'];
+    /**
+     * Phase-selecting `listEntries` — every entry under `rootPath` in a single filesystem
+     * pass, each with its `urlPath`, `slug`, `entryType`, `data` and `schema`. Use it instead
+     * of "enumerate paths, then read each one", which is an N+1 over the content tree and
+     * invites URL-reconstruction bugs; the returned `urlPath` round-trips through
+     * `readByUrlPath` by construction, including for multi-segment paths.
+     *
+     * ```ts
+     * const articles = await listEntries<ArticleContent>({
+     *   filter: (e) => e.entryType === 'article',
+     * })
+     * ```
+     *
+     * At build time this reads filesystem-direct; at request time it uses the branch-aware,
+     * **ACL-enforced** runtime context, so entries the current user cannot read are omitted.
+     * Note it takes no `branch` option — see `CanopyContext['listEntries']` for the
+     * base-branch pinning caveat in prod.
+     */
+    listEntries: CanopyContext['listEntries'];
     /**
      * Build the array Next's `generateStaticParams` expects from CanopyCMS content. Enumeration-only
      * (reads the set of routable paths, never entry content) and closes over the build context, so your
@@ -62,6 +112,28 @@ export interface NextCanopyContextResult {
      * `[slug]` route, or the default catch-all for `[...slug]`.
      */
     generateContentStaticParams: (options?: GenerateContentStaticParamsOptions) => Promise<Array<Record<string, string | string[]>>>;
+    /**
+     * Build `app/sitemap.ts`'s `MetadataRoute.Sitemap` from CanopyCMS content. Includes EVERY
+     * routable entry type by default and excludes `noindex` entries through the same predicate
+     * `entryToMetadata` uses for `robots`. Bound to the build context, so your `sitemap.ts` never
+     * imports the admin `getCanopyForBuild`.
+     *
+     * Reads the SEO field location from `createNextCanopyContext({ seo })` by default (shared with
+     * `entryToMetadata` below via `mergeSeoFieldLocation` — see that function's doc). Pass `seo` on a
+     * given call to override just that call.
+     */
+    generateContentSitemap: (options: GenerateContentSitemapOptions) => Promise<MetadataRoute.Sitemap>;
+    /**
+     * Map an entry's SEO fields onto a Next `Metadata` for `generateMetadata`. Re-exposed here so a
+     * page module has one CanopyCMS import (your `lib/canopy.ts`) rather than two.
+     *
+     * Reads the SAME SEO field location as `generateContentSitemap` above by default (the
+     * `createNextCanopyContext({ seo })` value); the two are bound from one context-wide default so
+     * they cannot silently disagree about where `noindex` (or a renamed field) lives. Pass
+     * `fields`/`group` on a given call to override just that call. This is a pure
+     * mapping and touches no context.
+     */
+    entryToMetadata: (entryData: unknown, options?: EntryToMetadataOptions) => Metadata;
     /** API catch-all route handler */
     handler: ReturnType<typeof createCanopyCatchAllHandler>;
     /** Underlying services (rarely needed directly) */
@@ -77,4 +149,3 @@ export interface NextCanopyContextResult {
  * auth works without network access (Lambda in prod, local in dev). The cache is populated by the worker daemon.
  */
 export declare function createNextCanopyContext(options: NextCanopyOptions): Promise<NextCanopyContextResult>;
-//# sourceMappingURL=context-wrapper.d.ts.map

package/dist/context-wrapper.js

@@ -4,8 +4,35 @@ import { headers } from 'next/headers';
 import { createCanopyContext, isBuildMode, startDevContentWatcher, createCanopyServices, createAssetStore, operatingStrategy, resolveCanopyUser, STATIC_DEPLOY_USER, } from 'canopycms/server';
 import { assertAuthPluginAllowedForMode } from 'canopycms/auth';
 import { CachingAuthPlugin, FileBasedAuthCache } from 'canopycms/auth/cache';
-import { createCanopyCatchAllHandler } from './adapter';
-import { collectStaticParams } from './static';
+import { createCanopyCatchAllHandler } from './adapter.js';
+import { collectStaticParams, entryToMetadata as entryToMetadataCore, generateContentSitemap, } from './static.js';
+/**
+ * Merge a context-wide default SEO field location (`createNextCanopyContext({ seo })`) with a
+ * per-call override.
+ *
+ * `generateContentSitemap`'s `noindex` exclusion and `entryToMetadata`'s field extraction/`noindex`
+ * read must agree on where the SEO fields live, or the two surfaces drift: an entry can end up
+ * `noindex` on the page while the sitemap still advertises its URL (or the reverse), because each
+ * call site independently forgot (or mis-set) `group`/`fields`. Both bound helpers below call this
+ * SAME function with the SAME context-wide default, which is what makes agreement structural
+ * rather than a matter of adopter discipline.
+ *
+ * Only keys the caller actually supplies override the default — an omitted (or explicitly
+ * `undefined`) `fields`/`group` falls through to the context-wide value, so setting a default once
+ * and never repeating it per call is the common case. A plain `{ ...contextDefault, ...callOverride
+ * }` would NOT have this property: `entryToMetadata`'s options type always has `fields`/`group`
+ * keys, so a caller who omits them still produces an object whose `fields`/`group` are present but
+ * `undefined`, and spreading that would silently clobber the default. Checking each key explicitly
+ * avoids that trap. Exported for direct unit testing.
+ */
+export function mergeSeoFieldLocation(contextDefault, callOverride) {
+    const merged = { ...contextDefault };
+    if (callOverride?.fields !== undefined)
+        merged.fields = callOverride.fields;
+    if (callOverride?.group !== undefined)
+        merged.group = callOverride.group;
+    return merged;
+}
 let warnedStaticMode = false;
 /**
  * Stub auth plugin for static deployments where no real auth is needed.
@@ -209,11 +236,36 @@ export async function createNextCanopyContext(options) {
         const ctx = isBuildMode() ? await getCanopyForBuild() : await getCanopy();
         return ctx.read(input);
     };
+    const listEntries = async (opts) => {
+        const ctx = isBuildMode() ? await getCanopyForBuild() : await getCanopy();
+        return ctx.listEntries(opts);
+    };
     // Enumeration-only static-params helper, bound to the (guarded) build context so page modules don't
     // import the admin context just to list paths. generateStaticParams is build-only, so this is safe.
     const generateContentStaticParams = async (options = {}) => {
         return collectStaticParams(await getCanopyForBuild(), options);
     };
+    // Sitemap generation reads entry CONTENT (to apply the noindex predicate), so unlike
+    // generateContentStaticParams it is not enumeration-only — but sitemap.ts is build-only in a
+    // static export, and on a prod `server` deployment guardBuildContext throws if it is reached at
+    // request time. Binding it here keeps the admin context out of the route module either way.
+    //
+    // Both this and boundEntryToMetadata below feed options.seo (the context-wide default set on
+    // createNextCanopyContext) through the SAME mergeSeoFieldLocation call, so the noindex exclusion
+    // here and entryToMetadata's noindex/field read cannot independently drift out of sync.
+    const boundGenerateContentSitemap = async (callOptions) => {
+        return generateContentSitemap(await getCanopyForBuild(), {
+            ...callOptions,
+            seo: mergeSeoFieldLocation(options.seo, callOptions.seo),
+        });
+    };
+    const boundEntryToMetadata = (entryData, callOptions = {}) => {
+        const seoLocation = mergeSeoFieldLocation(options.seo, {
+            fields: callOptions.fields,
+            group: callOptions.group,
+        });
+        return entryToMetadataCore(entryData, { ...callOptions, ...seoLocation });
+    };
     // Create API handler using same services
     const handler = createCanopyCatchAllHandler({
         ...options,
@@ -226,9 +278,11 @@ export async function createNextCanopyContext(options) {
         getCanopyForBuild,
         readByUrlPath,
         read,
+        listEntries,
         generateContentStaticParams,
+        generateContentSitemap: boundGenerateContentSitemap,
+        entryToMetadata: boundEntryToMetadata,
         handler,
         services,
     };
 }
-//# sourceMappingURL=context-wrapper.js.map

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export { createCanopyCatchAllHandler, wrapNextRequest, type CanopyNextOptions } from './adapter';
-export { createNextCanopyContext, type NextCanopyOptions, type NextCanopyContextResult, } from './context-wrapper';
-export { collectStaticParams, type GenerateContentStaticParamsOptions } from './static';
-export { createMockAuthPlugin, createRejectingAuthPlugin } from './test-utils';
-//# sourceMappingURL=index.d.ts.map
+export { createCanopyCatchAllHandler, wrapNextRequest, type CanopyNextOptions } from './adapter.js';
+export { createNextCanopyContext, type NextCanopyOptions, type NextCanopyContextResult, } from './context-wrapper.js';
+export { collectStaticParams, generateContentSitemap, entryToMetadata, type GenerateContentStaticParamsOptions, type GenerateContentSitemapOptions, type EntryToMetadataOptions, type SitemapExtraUrl, } from './static.js';
+export { createMockAuthPlugin, createRejectingAuthPlugin } from './test-utils.js';

package/dist/index.js

@@ -1,5 +1,4 @@
-export { createCanopyCatchAllHandler, wrapNextRequest } from './adapter';
-export { createNextCanopyContext, } from './context-wrapper';
-export { collectStaticParams } from './static';
-export { createMockAuthPlugin, createRejectingAuthPlugin } from './test-utils';
-//# sourceMappingURL=index.js.map
+export { createCanopyCatchAllHandler, wrapNextRequest } from './adapter.js';
+export { createNextCanopyContext, } from './context-wrapper.js';
+export { collectStaticParams, generateContentSitemap, entryToMetadata, } from './static.js';
+export { createMockAuthPlugin, createRejectingAuthPlugin } from './test-utils.js';

package/dist/static.d.ts

@@ -1,10 +1,17 @@
-import { type CanopyBuildContext, type CollectStaticPathsOptions } from 'canopycms/server';
+import type { Metadata, MetadataRoute } from 'next';
+import { type CanopyBuildContext, type CollectStaticPathsOptions, type ExtractSeoFieldsOptions, type RoutableEntry, type SeoFieldLocation, type SeoOgType } from 'canopycms/server';
 /**
- * Next.js static-export helpers built on the framework-agnostic core in `canopycms/server`.
+ * Next.js static-export helpers built on the framework-agnostic core in `canopycms/server`:
+ * static params (`collectStaticParams`), the content sitemap (`generateContentSitemap`), and
+ * per-entry metadata (`entryToMetadata`).
  *
- * Today this ships static-params generation. Sitemap and SEO-metadata helpers are tracked as
- * follow-up work (see .claude/future-tasks/static-export-sitemap.md and
- * .claude/future-tasks/static-export-seo-metadata.md).
+ * The last two ship together on purpose. `noindex` has to suppress a page in BOTH surfaces —
+ * `robots: { index: false }` on the page and absence from the sitemap — and both read it through
+ * the same core `isNoindexEntry` predicate, so they cannot disagree about which pages are
+ * advertised.
+ *
+ * `robots.txt` is out of scope: it is a handful of static lines with no CanopyCMS content behind
+ * it. Write `app/robots.ts` yourself, and point its `sitemap` at the route below.
  */
 export interface GenerateContentStaticParamsOptions extends CollectStaticPathsOptions {
     /** Route param name. Default 'slug'. */
@@ -20,6 +27,10 @@ export interface GenerateContentStaticParamsOptions extends CollectStaticPathsOp
      * route's base (e.g. `'/docs'`). Entries are scoped to that prefix and `segments` are made relative
      * to it, so the params match the route. Without it, segments are the full URL path. Applies to
      * catch-all shapes (it rewrites `segments`); it has no effect with `shape: 'single'`.
+     *
+     * Note that `shape: 'single'` also SKIPS collection index entries, whose URL is the
+     * collection's own path rather than a single slug segment. Render those from the collection's
+     * route (e.g. `app/posts/page.tsx`), not from `[slug]`.
      */
     basePath?: string;
 }
@@ -36,4 +47,197 @@ export interface GenerateContentStaticParamsOptions extends CollectStaticPathsOp
  * `[[...slug]]`, otherwise exclude it via `options.filter` (e.g. `(e) => e.segments.length > 0`).
  */
 export declare function collectStaticParams(buildCtx: Pick<CanopyBuildContext, 'listEntries'>, options?: GenerateContentStaticParamsOptions): Promise<Array<Record<string, string | string[]>>>;
-//# sourceMappingURL=static.d.ts.map
+type SitemapItem = MetadataRoute.Sitemap[number];
+/**
+ * A URL with no CanopyCMS entry behind it (a hand-written app route, a feed).
+ *
+ * **An extra URL is entirely hand-managed — it inherits nothing from the entry pipeline.**
+ * `generateContentSitemap` applies `isNoindexEntry` and a default `lastModified` only while
+ * walking real entries; this list is appended afterwards and passes through both:
+ *
+ * - **No `noindex` gate.** Nothing checks the SEO flag for an extra URL, because there is no
+ *   entry data to check. If you are using `extraUrls` to re-advertise a real entry under a
+ *   different path (the usual reason — an entry whose structural `urlPath` no route serves),
+ *   you are responsible for not listing it when that entry is marked `noindex`. Marking the
+ *   entry does not remove the extra URL.
+ * - **No `lastModified` fallback.** The per-entry branch defaults to `entry.updatedAt`; here,
+ *   omitting `lastModified` means the URL simply ships without a date.
+ *
+ * Both are easy to get wrong in exactly the same direction, and both used to be unavoidable:
+ * `extraUrls` was once the only way to advertise a real entry at a different URL, so every such
+ * use re-derived `noindex` and `lastModified` by hand — this repo's own reference app among them,
+ * and it got `lastModified` wrong.
+ *
+ * It is no longer the only way, so it should no longer be that way:
+ *
+ * 1. **Model the entry so its natural `urlPath` IS the URL you serve.** An `index` entry collapses
+ *    onto its collection's path, and a root `index` entry onto `/`. Nothing to keep in sync. This
+ *    is what the reference app does now, which is why its sitemap passes neither option.
+ * 2. **Failing that, use `pathFor`** (see `GenerateContentSitemapOptions`), which overrides the
+ *    URL while keeping the entry inside the walk — so the `noindex` gate, the `lastModified`
+ *    default and `priority` all still apply.
+ * 3. **Keep `extraUrls` for what its name says:** URLs with no entry behind them at all.
+ */
+export interface SitemapExtraUrl {
+    /** Site-relative path ('/blog') or an absolute URL. Trailing-slash rules apply to the former. */
+    path: string;
+    /** No fallback: omit this and the URL ships with no date at all (entries default to `updatedAt`). */
+    lastModified?: Date | string;
+    changeFrequency?: SitemapItem['changeFrequency'];
+    priority?: number;
+}
+export interface GenerateContentSitemapOptions {
+    /**
+     * Site origin, e.g. `https://example.com`. Required: a sitemap must carry absolute URLs, or
+     * search engines reject the whole file. Enforced — `generateContentSitemap` throws if this
+     * isn't an absolute URL (no scheme, or empty).
+     */
+    siteUrl: string;
+    /**
+     * Emit site-relative URLs with a trailing slash (`/contact/` rather than `/contact`).
+     *
+     * **Explicit on purpose.** CanopyCMS cannot see your `next.config.ts`, so it cannot know
+     * whether your site serves `trailingSlash: true`. Set this to match, or the sitemap advertises
+     * URLs that redirect — a real adopter shipped exactly that mismatch.
+     */
+    trailingSlash?: boolean;
+    /** Scope to a collection logical path (e.g. 'content/posts'). Defaults to the whole content root. */
+    rootPath?: string;
+    /** Where the SEO fields live, when they aren't the flat defaults. Drives the `noindex` read. */
+    seo?: SeoFieldLocation;
+    /**
+     * Drop entries from the sitemap. Applied ON TOP of the `noindex` exclusion, which is not
+     * optional. Use for structural URLs that shouldn't be advertised (e.g. a bare collection index).
+     */
+    exclude?: (entry: RoutableEntry) => boolean;
+    /**
+     * `<lastmod>` per entry. Defaults to the entry's `updatedAt`.
+     *
+     * **`updatedAt` is filesystem mtime, not an editorial timestamp.** A fresh CI clone resets every
+     * file's mtime to checkout time, so on a clean build agent the default dates every URL to the
+     * moment the tree was cloned. Treat the default as "changed since the last build" at best; if
+     * you need a truthful `<lastmod>`, supply one here (a content date field, or git commit time)
+     * or return `undefined` to omit the element entirely, which is better than asserting a date you
+     * cannot stand behind.
+     */
+    lastModified?: (entry: RoutableEntry) => Date | string | undefined;
+    /** `<priority>` per entry. Omitted from the URL when this returns undefined (the default). */
+    priority?: (entry: RoutableEntry) => number | undefined;
+    /**
+     * Override the URL an entry is advertised at, keeping it INSIDE the entry walk.
+     *
+     * Return a path to advertise the entry at instead of its structural `urlPath`; return `null`
+     * (or `undefined`) to leave it alone.
+     *
+     * **`null` means "no opinion", not "drop it".** So the obvious shape — handle the one entry
+     * type you care about, return `null` for the rest — advertises every other entry at its own
+     * path rather than silently emitting a one-URL sitemap. Dropping an entry stays `exclude`'s
+     * job, and keeping the two separate is the whole reason for this choice: a `pathFor` whose
+     * natural-looking callback silently omitted everything else would re-introduce exactly the
+     * quietly-short sitemap this module exists to prevent.
+     *
+     * This is the principled alternative to reaching for `extraUrls` to reroute a REAL entry.
+     * Because the entry stays in the walk, it keeps the `isNoindexEntry` gate, the `updatedAt`
+     * `lastModified` default and its `priority` automatically — all three of which an `extraUrls`
+     * entry makes you re-derive by hand, and get wrong independently (see {@link SitemapExtraUrl}).
+     *
+     * **It changes what is ADVERTISED, not what is BUILT.** `generateContentStaticParams` still
+     * enumerates the entry at its structural path, so the URL returned here must be one your app
+     * actually routes — otherwise you have advertised a 404, the same hazard `extraUrls` carries.
+     *
+     * Return a **site-relative path**. The value is trimmed, and an empty or off-site return (an
+     * absolute `https://…` or a protocol-relative `//host/…`) throws rather than being emitted:
+     * the first silently claims `/`, and the second lands in the sitemap as a non-absolute `<loc>`,
+     * which invalidates the whole file. `extraUrls` is where an off-origin URL is legitimate.
+     *
+     * Reach for it only when the URL is fixed by something OUTSIDE the content tree: published URLs
+     * you cannot change, or a route prefix that deliberately differs from the content layout. When
+     * you control the modelling, model the entry so its natural `urlPath` is already the URL you
+     * serve — an `index` entry collapses onto its collection's path, and a root `index` entry onto
+     * `/` — which needs no option at all. That ordering is not advice we only give: it is what the
+     * reference app in this repo does, which is why its sitemap passes neither this nor `extraUrls`.
+     *
+     * Runs AFTER the `noindex` and `exclude` gates (a dropped entry needs no URL). `exclude`,
+     * `lastModified` and `priority` receive the entry as ENUMERATED, so `entry.urlPath` there is
+     * always the structural path and never your override — branch on the entry, not on the URL.
+     *
+     * Two entries rewritten onto one URL are NOT caught by the build's `assertNoDuplicateUrlPaths`
+     * guard, which runs on the raw listing and never sees these rewrites; `dedupeSitemapItems`
+     * warns and keeps the first.
+     *
+     * @example
+     * // Content lives under content/articles/*, but this site has always published /blog/*.
+     * pathFor: (entry) =>
+     *   entry.entryType === 'article' ? entry.urlPath.replace(/^\/articles\//, '/blog/') : null,
+     */
+    pathFor?: (entry: RoutableEntry) => string | null | undefined;
+    /**
+     * URLs with NO entry behind them — hand-written app routes, feeds — appended to the result.
+     *
+     * Appended after the entry walk, so these bypass BOTH the `isNoindexEntry` gate and the
+     * `lastModified` default. To point a REAL entry at a different URL, use `pathFor` above, which
+     * keeps both. See {@link SitemapExtraUrl}.
+     */
+    extraUrls?: SitemapExtraUrl[];
+}
+/**
+ * Build Next's `MetadataRoute.Sitemap` from CanopyCMS content.
+ *
+ * **Every routable entry type is included by default.** There is no list of "sitemap-able" entry
+ * types to keep in sync, and that is the whole design: a hand-rolled sitemap that enumerates a
+ * remembered list of entry types omits whichever type nobody added, ships green, and takes the
+ * missing pages out of search results silently. Omitting a URL here requires an explicit
+ * `exclude` predicate or a `noindex` flag on the entry.
+ *
+ * `noindex` entries are excluded, via the same core `isNoindexEntry` predicate that drives
+ * `robots: { index: false }` in `entryToMetadata`. They are still BUILT — enumeration
+ * (`generateContentStaticParams`) does not filter them, so the page exists for anyone holding
+ * the link; it just isn't advertised.
+ *
+ * `changeFrequency` is not emitted for entries: a blanket value asserted for every URL carries no
+ * information, and search engines say they ignore it. Set it per-URL via `extraUrls` if you want it.
+ *
+ * Output is stably ordered ('/' first, then alphabetical) so a rebuild doesn't reshuffle the file.
+ *
+ * @example
+ * // app/sitemap.ts
+ * export const dynamic = 'force-static' // required for output: 'export'
+ * export default () => contentSitemap({ siteUrl: 'https://example.com', trailingSlash: true })
+ */
+export declare function generateContentSitemap(buildCtx: Pick<CanopyBuildContext, 'listEntries'>, options: GenerateContentSitemapOptions): Promise<MetadataRoute.Sitemap>;
+export interface EntryToMetadataOptions extends ExtractSeoFieldsOptions {
+    /** Route path for this entry — the canonical URL when the entry sets none. */
+    path?: string;
+    /**
+     * Site origin for resolving relative canonical / OG image URLs. Omit to leave them relative and
+     * let Next's `metadataBase` resolve them.
+     */
+    siteUrl?: string;
+    /** Emit site-relative URLs with a trailing slash. Match your sitemap and your routing config. */
+    trailingSlash?: boolean;
+    /** Site name (openGraph.siteName, and the social-card title fallback). */
+    siteName?: string;
+    /** Root-layout mode: emit `title: { template, default }` (e.g. `'%s | Example'`). */
+    titleTemplate?: string;
+    /** og:type when the entry sets none. Defaults to 'website'. */
+    defaultOgType?: SeoOgType;
+}
+/**
+ * Map an entry's SEO fields onto a Next `Metadata` object.
+ *
+ * Title and description follow ONE convention everywhere: the entry's meta field, else the
+ * fallback you pass, else unset (so the root layout's default applies). An empty CMS field counts
+ * as unset — see `extractSeoFields`.
+ *
+ * `noindex` goes through the same core predicate the sitemap uses, so a page marked noindex is
+ * suppressed in both surfaces or neither.
+ *
+ * @example
+ * export async function generateMetadata({ params }): Promise<Metadata> {
+ *   const { slug } = await params
+ *   const result = await readByUrlPath(`/posts/${slug}`)
+ *   return entryToMetadata(result?.data, { path: `/posts/${slug}`, fallbackTitle: result?.data.title })
+ * }
+ */
+export declare function entryToMetadata(entryData: unknown, opts?: EntryToMetadataOptions): Metadata;
+export {};

package/dist/static.js

@@ -1,4 +1,4 @@
-import { collectStaticPaths, } from 'canopycms/server';
+import { collectRoutableEntries, collectStaticPaths, extractSeoFields, isAbsoluteUrl, isIndexSlug, isNoindexEntry, resolveSeoUrl, } from 'canopycms/server';
 /**
  * Shape CanopyCMS content paths into the array Next's `generateStaticParams` expects.
  *
@@ -14,7 +14,13 @@ import { collectStaticPaths, } from 'canopycms/server';
 export async function collectStaticParams(buildCtx, options = {}) {
     const { paramName = 'slug', shape = 'catch-all', basePath, ...collectOptions } = options;
     let entries = await collectStaticPaths(buildCtx, collectOptions);
-    if (basePath) {
+    // basePath only means something for the catch-all shape: it rewrites `segments` relative to the
+    // route's URL prefix, and 'single' shape never reads `segments` (it emits `entry.slug`). Applying
+    // the prefix FILTER unconditionally — as this once did — silently dropped every entry outside the
+    // prefix for 'single' too, contradicting this option's own doc above ("no effect with shape:
+    // 'single'") and meaning unbuilt pages for anyone who set basePath alongside 'single'. Scope with
+    // `rootPath` for 'single' instead.
+    if (basePath && shape !== 'single') {
         // Make segments relative to a nested route's base prefix (e.g. '/docs' for app/docs/[[...slug]]).
         // urlPath is always lowercased (see content-listing), so lowercase the prefix to match.
         const prefix = (basePath.endsWith('/') ? basePath.slice(0, -1) : basePath).toLowerCase();
@@ -25,6 +31,227 @@ export async function collectStaticParams(buildCtx, options = {}) {
             return { ...entry, segments: rel ? rel.split('/') : [] };
         });
     }
-    return entries.map((entry) => shape === 'single' ? { [paramName]: entry.slug } : { [paramName]: entry.segments });
+    if (shape === 'single') {
+        // Drop index entries. Their URL is the COLLECTION's path (`/posts`, not `/posts/index`), a
+        // shape a single-segment `[slug]` route cannot represent — that page belongs to the
+        // collection's own route. Emitting one produced a param whose URL `readByUrlPath` refuses to
+        // resolve, so Next prerendered a guaranteed notFound (and an `output: export` build can fail
+        // outright). Catch-all is unaffected: it reads the already-collapsed `segments`, which for an
+        // index entry are the collection's.
+        return entries
+            .filter((entry) => !isIndexSlug(entry.slug))
+            .map((entry) => ({ [paramName]: entry.slug }));
+    }
+    return entries.map((entry) => ({ [paramName]: entry.segments }));
+}
+/**
+ * Build Next's `MetadataRoute.Sitemap` from CanopyCMS content.
+ *
+ * **Every routable entry type is included by default.** There is no list of "sitemap-able" entry
+ * types to keep in sync, and that is the whole design: a hand-rolled sitemap that enumerates a
+ * remembered list of entry types omits whichever type nobody added, ships green, and takes the
+ * missing pages out of search results silently. Omitting a URL here requires an explicit
+ * `exclude` predicate or a `noindex` flag on the entry.
+ *
+ * `noindex` entries are excluded, via the same core `isNoindexEntry` predicate that drives
+ * `robots: { index: false }` in `entryToMetadata`. They are still BUILT — enumeration
+ * (`generateContentStaticParams`) does not filter them, so the page exists for anyone holding
+ * the link; it just isn't advertised.
+ *
+ * `changeFrequency` is not emitted for entries: a blanket value asserted for every URL carries no
+ * information, and search engines say they ignore it. Set it per-URL via `extraUrls` if you want it.
+ *
+ * Output is stably ordered ('/' first, then alphabetical) so a rebuild doesn't reshuffle the file.
+ *
+ * @example
+ * // app/sitemap.ts
+ * export const dynamic = 'force-static' // required for output: 'export'
+ * export default () => contentSitemap({ siteUrl: 'https://example.com', trailingSlash: true })
+ */
+export async function generateContentSitemap(buildCtx, options) {
+    const { siteUrl, trailingSlash, rootPath, seo, exclude, lastModified, priority, pathFor } = options;
+    // A sitemap with a non-absolute <loc> is invalid — search engines reject the WHOLE file, not
+    // just the bad entry, and the build stays green because nothing here threw. 'example.com' (no
+    // scheme) and '' both pass through resolveSeoUrl unmodified today; catch them here instead.
+    if (!isAbsoluteUrl(siteUrl)) {
+        throw new Error(`CanopyCMS: generateContentSitemap requires an absolute siteUrl (e.g. "https://example.com"), ` +
+            `got ${JSON.stringify(siteUrl)}. A sitemap whose <loc> values aren't absolute URLs is invalid ` +
+            'and search engines silently reject the entire file.');
+    }
+    const urlOpts = { siteUrl, trailingSlash };
+    const entries = await collectRoutableEntries(buildCtx, { rootPath });
+    const items = [];
+    for (const entry of entries) {
+        if (isNoindexEntry(entry.data, seo))
+            continue;
+        if (exclude?.(entry))
+            continue;
+        const modified = lastModified ? lastModified(entry) : entry.updatedAt;
+        const entryPriority = priority?.(entry);
+        items.push({
+            url: resolveSeoUrl(resolveEntrySitemapPath(entry, pathFor), urlOpts),
+            ...(modified ? { lastModified: modified } : {}),
+            ...(entryPriority === undefined ? {} : { priority: entryPriority }),
+        });
+    }
+    // Deliberately outside the entry loop above, and therefore outside its `isNoindexEntry` gate
+    // and its `entry.updatedAt` fallback — an extra URL has no entry to derive either from. This is
+    // the behaviour documented on SitemapExtraUrl; if that ever changes, change the doc with it.
+    for (const extra of options.extraUrls ?? []) {
+        items.push({
+            url: resolveSeoUrl(extra.path, urlOpts),
+            ...(extra.lastModified ? { lastModified: extra.lastModified } : {}),
+            ...(extra.changeFrequency ? { changeFrequency: extra.changeFrequency } : {}),
+            ...(extra.priority === undefined ? {} : { priority: extra.priority }),
+        });
+    }
+    const root = resolveSeoUrl('/', urlOpts);
+    return dedupeSitemapItems(items).sort((a, b) => a.url === root ? -1 : b.url === root ? 1 : a.url.localeCompare(b.url));
+}
+/**
+ * Resolve the path an entry is advertised at, applying the caller's `pathFor` override.
+ *
+ * `null`/`undefined` mean "no opinion" and keep the entry's own `urlPath` — see the `pathFor`
+ * doc for why that is not "drop it".
+ *
+ * Two shapes are rejected rather than passed through, because each produces a WRONG SITEMAP THAT
+ * SHIPS GREEN — the failure mode every other guard in this file exists to convert into a red
+ * build. (A third, the WHATWG-backslash spellings like `/\evil.com/x`, is not thrown but
+ * neutralized downstream by `resolveSeoUrl`'s `neutralizeImplicitOffOrigin`.)
+ *
+ * - **Empty or whitespace-only.** `resolveSeoUrl('')` resolves to the site root, so an empty
+ *   return would quietly advertise this entry at `/` and collide with whatever really lives there.
+ * - **Absolute (scheme-qualified or protocol-relative).** `resolveSeoUrl` passes both through
+ *   verbatim, by design — for `extraUrls`, where an absolute URL is explicitly allowed. Here it is
+ *   not: a protocol-relative `//host/x` lands in the sitemap as a NON-absolute `<loc>`, the exact
+ *   invalidity `generateContentSitemap`'s `siteUrl` guard exists to prevent, and search engines
+ *   reject the whole file for it. Refused whatever the origin — including one matching `siteUrl` —
+ *   so the rule is "return a site-relative path" with no host comparison to get subtly wrong.
+ *
+ * The returned path is TRIMMED. Surrounding whitespace is never intended and survives into the
+ * URL otherwise (`' /blog'` → `<siteUrl>/ /blog`) — which this function would previously detect
+ * while checking for emptiness and then hand back untrimmed anyway.
+ */
+function resolveEntrySitemapPath(entry, pathFor) {
+    if (!pathFor)
+        return entry.urlPath;
+    const override = pathFor(entry);
+    if (override === null || override === undefined)
+        return entry.urlPath;
+    const trimmed = override.trim();
+    const where = `the ${JSON.stringify(entry.entryType)} entry at ${JSON.stringify(entry.urlPath)}`;
+    if (trimmed === '') {
+        throw new Error(`CanopyCMS: generateContentSitemap's pathFor returned an empty path for ${where}. An empty ` +
+            'path resolves to the site root, so honouring it would advertise this entry at "/" and ' +
+            "collide with whatever really lives there. Return null to keep the entry's own urlPath.");
+    }
+    if (isAbsoluteUrl(trimmed)) {
+        throw new Error(`CanopyCMS: generateContentSitemap's pathFor returned an absolute URL ` +
+            `(${JSON.stringify(trimmed)}) for ${where}. Return a site-relative path instead — the ` +
+            'site origin is applied for you. Absolute returns are refused whatever the origin, rather ' +
+            'than only off-origin ones, so there is one rule to remember and no host comparison to get ' +
+            'subtly wrong; a protocol-relative value (`//host/x`) is the reason it matters, since that ' +
+            'ships as a non-absolute <loc> and invalidates the entire sitemap. Use extraUrls to list a ' +
+            'URL on another origin.');
+    }
+    return trimmed;
+}
+/**
+ * Drop duplicate `<loc>` entries, keeping the first occurrence and warning about each collision.
+ *
+ * A duplicate URL isn't fatal to a crawler, but it usually means two URLs are unintentionally
+ * sharing one `<loc>` — an index entry collapsing onto a sibling's path, two `urlPath`s that only
+ * differ by case (`urlPath` is lowercased — see `content-listing.ts`), an `extraUrls` path
+ * repeating an entry's URL, or a `pathFor` that rewrote two entries onto the same path. Warning
+ * rather than silently deduping turns that into a build-time signal an adopter can act on instead
+ * of a sitemap that just quietly has fewer URLs than expected.
+ *
+ * Still needed alongside `assertNoDuplicateUrlPaths` (canopycms `static/index.ts`), which fails a
+ * production build on the entry-vs-entry case before generation ever reaches here. This covers the
+ * three cases that guard cannot: a collision involving an `extraUrls` path, which is supplied here
+ * and never appears in the content enumeration; a collision created by `pathFor`, which rewrites
+ * URLs after that guard has already run on the raw listing; and any call outside build mode, where
+ * that guard is deliberately silent.
+ */
+function dedupeSitemapItems(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        if (seen.has(item.url)) {
+            console.warn(`CanopyCMS: generateContentSitemap found more than one entry resolving to the same sitemap ` +
+                `URL ${JSON.stringify(item.url)}. Keeping the first and dropping the rest — this usually means ` +
+                'two entries, an entry and an extraUrls path, or a pathFor override are unintentionally ' +
+                'sharing one URL.');
+            continue;
+        }
+        seen.add(item.url);
+        result.push(item);
+    }
+    return result;
+}
+/**
+ * Map an entry's SEO fields onto a Next `Metadata` object.
+ *
+ * Title and description follow ONE convention everywhere: the entry's meta field, else the
+ * fallback you pass, else unset (so the root layout's default applies). An empty CMS field counts
+ * as unset — see `extractSeoFields`.
+ *
+ * `noindex` goes through the same core predicate the sitemap uses, so a page marked noindex is
+ * suppressed in both surfaces or neither.
+ *
+ * @example
+ * export async function generateMetadata({ params }): Promise<Metadata> {
+ *   const { slug } = await params
+ *   const result = await readByUrlPath(`/posts/${slug}`)
+ *   return entryToMetadata(result?.data, { path: `/posts/${slug}`, fallbackTitle: result?.data.title })
+ * }
+ */
+export function entryToMetadata(entryData, opts = {}) {
+    const seo = extractSeoFields(entryData, opts);
+    const urlOpts = { siteUrl: opts.siteUrl, trailingSlash: opts.trailingSlash };
+    // The entry's own canonical wins over the route path; an absolute one passes through verbatim
+    // (see resolveSeoUrl — the absolute check runs before any normalization, which is a fixed bug).
+    const canonicalSource = seo.canonical ?? opts.path;
+    const canonical = canonicalSource ? resolveSeoUrl(canonicalSource, urlOpts) : undefined;
+    // Images are files, never directory-style URLs: never append a trailing slash to one.
+    const ogImage = seo.ogImage ? resolveSeoUrl(seo.ogImage, { siteUrl: opts.siteUrl }) : undefined;
+    // og:title falls back to the site name so a page that inherits the layout title still emits a
+    // usable card — Next REPLACES `openGraph` wholesale rather than deep-merging it.
+    const socialTitle = seo.title ?? opts.siteName;
+    const ogType = seo.ogType ?? opts.defaultOgType ?? 'website';
+    const openGraphBase = {
+        ...(socialTitle ? { title: socialTitle } : {}),
+        ...(seo.description ? { description: seo.description } : {}),
+        ...(canonical ? { url: canonical } : {}),
+        ...(opts.siteName ? { siteName: opts.siteName } : {}),
+        ...(ogImage ? { images: [{ url: ogImage }] } : {}),
+    };
+    const metadata = {
+        ...(canonical ? { alternates: { canonical } } : {}),
+        // Spelled out per branch rather than cast: Next's OpenGraph metadata is a discriminated
+        // union on `type`.
+        openGraph: ogType === 'article'
+            ? { ...openGraphBase, type: 'article' }
+            : ogType === 'profile'
+                ? { ...openGraphBase, type: 'profile' }
+                : { ...openGraphBase, type: 'website' },
+        twitter: {
+            card: seo.twitterCard ?? 'summary_large_image',
+            ...(socialTitle ? { title: socialTitle } : {}),
+            ...(seo.description ? { description: seo.description } : {}),
+            ...(ogImage ? { images: [ogImage] } : {}),
+        },
+    };
+    if (opts.titleTemplate) {
+        metadata.title = { template: opts.titleTemplate, default: seo.title ?? opts.siteName ?? '' };
+    }
+    else if (seo.title) {
+        metadata.title = seo.title;
+    }
+    if (seo.description)
+        metadata.description = seo.description;
+    // Same predicate as the sitemap's exclusion — these two must never be derived separately.
+    if (isNoindexEntry(entryData, opts))
+        metadata.robots = { index: false, follow: false };
+    return metadata;
 }
-//# sourceMappingURL=static.js.map

package/dist/test-utils.d.ts

@@ -9,4 +9,3 @@ export declare const createMockAuthPlugin: (user?: AuthenticatedUser) => AuthPlu
  * Create a mock AuthPlugin that rejects all authentication.
  */
 export declare const createRejectingAuthPlugin: (error?: string) => AuthPlugin;
-//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.js

@@ -33,4 +33,3 @@ export const createRejectingAuthPlugin = (error = 'Unauthorized') => ({
     getGroupMetadata: async () => null,
     listGroups: async () => [],
 });
-//# sourceMappingURL=test-utils.js.map

package/dist/with-canopy.d.ts

@@ -60,4 +60,3 @@ export interface WithCanopyOptions {
  * ```
  */
 export declare function withCanopy(nextConfig?: NextConfig, options?: WithCanopyOptions): NextConfig;
-//# sourceMappingURL=with-canopy.d.ts.map

package/dist/with-canopy.js

@@ -217,4 +217,3 @@ export function withCanopy(nextConfig = {}, options = {}) {
         rewrites: withAssetsRewrite(nextConfig.rewrites),
     };
 }
-//# sourceMappingURL=with-canopy.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopycms-next",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "description": "Next.js adapter for CanopyCMS",
   "license": "MIT",
   "repository": {
@@ -36,7 +36,7 @@
   "peerDependencies": {
     "next": "^13.5.7 || ^14.2.25 || ^15.5.21 || >=16.0.0 <16.2.0 || >=16.3.0 <17.0.0",
     "react": "^18.0.0 || ^19.0.0",
-    "canopycms": "0.0.62"
+    "canopycms": "0.0.64"
   },
   "devDependencies": {
     "@types/node": "^22.9.0",
@@ -46,10 +46,10 @@
     "react": "^18.3.1",
     "typescript": "^5.6.3",
     "vitest": "^4.1.0",
-    "canopycms": "0.0.62"
+    "canopycms": "0.0.64"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && esbuild src/config.ts --bundle --platform=node --packages=external --external:next --format=cjs --outfile=dist/config.cjs && esbuild src/config.ts --bundle --platform=node --packages=external --external:next --format=esm --outfile=dist/config.mjs",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node ../../scripts/add-js-extensions.mjs dist && esbuild src/config.ts --bundle --platform=node --packages=external --external:next --format=cjs --outfile=dist/config.cjs && esbuild src/config.ts --bundle --platform=node --packages=external --external:next --format=esm --outfile=dist/config.mjs",
     "lint": "eslint src/",
     "test": "vitest run --reporter=dot",
     "typecheck": "tsc --noEmit"

package/dist/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAEnB,MAAM,gBAAgB,CAAA;AAGvB;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CA0B3D;AAkDD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB,MAIlE,KAAK,OAAO,EACZ,MAAM;IACJ,MAAM,CAAC,EACH,OAAO,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,GACzD;QAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;CACrD,KACA,OAAO,CAAC,QAAQ,CAoBpB,CAAA"}

package/dist/adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,kBAAkB,EAC1B,kBAAkB,oBAAoB,kDAwBvC,CAAA"}

package/dist/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAEZ,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,MAA0B,EAC1B,eAAsC,EACtC,EAAE;IACF,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAE1D,8EAA8E;IAC9E,0EAA0E;IAC1E,+EAA+E;IAC/E,4EAA4E;IAC5E,SAAS,sBAAsB;QAC7B,MAAM,eAAe,GAAG,eAAe,EAAE,CAAA;QACzC,MAAM,YAAY,GAAG;YACnB,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,SAAS;YAClD,KAAK,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,SAAS;SACjD,CAAA;QACD,OAAO,KAAC,QAAQ,IAAC,YAAY,EAAE,YAAY,GAAI,CAAA;IACjD,CAAC;IAED,OAAO,SAAS,cAAc;QAC5B,OAAO,CACL,KAAC,QAAQ,IAAC,QAAQ,EAAE,IAAI,YACtB,KAAC,sBAAsB,KAAG,GACjB,CACZ,CAAA;IACH,CAAC,CAAA;AACH,CAAC,CAAA"}

package/dist/client.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=client.test.d.ts.map

package/dist/client.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../src/client.test.tsx"],"names":[],"mappings":""}

package/dist/client.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-// Mocked so this stays a node-environment test: the factory under test calls
-// CanopyEditorPage at CALL time (not render time), so asserting what it was
-// handed needs no DOM, no jsdom and no testing-library.
-const canopyEditorPage = vi.fn(() => () => null);
-vi.mock('canopycms/client', () => ({
-    CanopyEditorPage: (...args) => canopyEditorPage(...args),
-}));
-vi.mock('next/navigation', () => ({ useSearchParams: () => new URLSearchParams() }));
-const { NextCanopyEditorPage } = await import('./client');
-const config = { apiBase: '/api/canopycms' };
-describe('NextCanopyEditorPage', () => {
-    it('forwards customRenderers to CanopyEditorPage', () => {
-        // Next is the primary target, so this wrapper is the entrypoint adopters
-        // import. Accepting `customRenderers` only on the core CanopyEditorPage
-        // left the extension point unreachable from the path every adopter uses
-        // - and silently, since an ignored extra argument is not a type error at
-        // the call site.
-        const customRenderers = { number: () => null };
-        NextCanopyEditorPage(config, customRenderers);
-        expect(canopyEditorPage).toHaveBeenCalledWith(config, customRenderers);
-    });
-    it('still works with no customRenderers (the scaffolded call shape)', () => {
-        canopyEditorPage.mockClear();
-        NextCanopyEditorPage(config);
-        expect(canopyEditorPage).toHaveBeenCalledWith(config, undefined);
-    });
-});
-//# sourceMappingURL=client.test.js.map

package/dist/client.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.test.js","sourceRoot":"","sources":["../src/client.test.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAEjD,6EAA6E;AAC7E,4EAA4E;AAC5E,wDAAwD;AACxD,MAAM,gBAAgB,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA;AAChD,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,CAAC;IACjC,gBAAgB,EAAE,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,gBAAgB,CAAC,GAAI,IAAW,CAAC;CAC5E,CAAC,CAAC,CAAA;AACH,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,eAAe,EAAE,GAAG,EAAE,CAAC,IAAI,eAAe,EAAE,EAAE,CAAC,CAAC,CAAA;AAEpF,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,CAAA;AAEzD,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,gBAAgB,EAAW,CAAA;AAErD,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACtD,yEAAyE;QACzE,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,iBAAiB;QACjB,MAAM,eAAe,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAA;QAE9C,oBAAoB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;QAE7C,MAAM,CAAC,gBAAgB,CAAC,CAAC,oBAAoB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACxE,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,gBAAgB,CAAC,SAAS,EAAE,CAAA;QAE5B,oBAAoB,CAAC,MAAM,CAAC,CAAA;QAE5B,MAAM,CAAC,gBAAgB,CAAC,CAAC,oBAAoB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAClE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAA"}

package/dist/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA0B,MAAM,eAAe,CAAA"}

package/dist/context-wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-wrapper.d.ts","sourceRoot":"","sources":["../src/context-wrapper.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EAWpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAc,WAAW,EAAE,MAAM,WAAW,CAAA;AAGlF,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAuB,KAAK,kCAAkC,EAAE,MAAM,UAAU,CAAA;AAiCvF,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,mGAAmG;IACnG,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC,CAAA;CAC5D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,YAAY,GACnB,kBAAkB,CA4CpB;AAED,MAAM,WAAW,uBAAuB;IACtC,8GAA8G;IAC9G,SAAS,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAA;IACvC;;;;;;;;;;;;;OAaG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAA;IACpD;;;;;;;OAOG;IACH,aAAa,EAAE,aAAa,CAAC,eAAe,CAAC,CAAA;IAC7C,kHAAkH;IAClH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3B;;;;;OAKG;IACH,2BAA2B,EAAE,CAC3B,OAAO,CAAC,EAAE,kCAAkC,KACzC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,CAAA;IACtD,kCAAkC;IAClC,OAAO,EAAE,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAA;IACvD,mDAAmD;IACnD,QAAQ,EAAE,cAAc,CAAA;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,uBAAuB,CAAC,CAkLlC"}

package/dist/context-wrapper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-wrapper.js","sourceRoot":"","sources":["../src/context-wrapper.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAEhG,OAAO,EACL,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,kCAAkC,EAAE,MAAM,UAAU,CAAA;AAEvF,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAA0B,MAAM,WAAW,CAAA;AAEhG,OAAO,EACL,uBAAuB,GAGxB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,mBAAmB,EAA2C,MAAM,UAAU,CAAA;AAEvF,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA"}

package/dist/static.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../src/static.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AAEH,MAAM,WAAW,kCAAmC,SAAQ,yBAAyB;IACnF,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAA;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,EACjD,OAAO,GAAE,kCAAuC,GAC/C,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,CAmBnD"}

package/dist/static.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static.js","sourceRoot":"","sources":["../src/static.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,GAGnB,MAAM,kBAAkB,CAAA;AA4BzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,QAAiD,EACjD,UAA8C,EAAE;IAEhD,MAAM,EAAE,SAAS,GAAG,MAAM,EAAE,KAAK,GAAG,WAAW,EAAE,QAAQ,EAAE,GAAG,cAAc,EAAE,GAAG,OAAO,CAAA;IACxF,IAAI,OAAO,GAAG,MAAM,kBAAkB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAA;IAEhE,IAAI,QAAQ,EAAE,CAAC;QACb,kGAAkG;QAClG,wFAAwF;QACxF,MAAM,MAAM,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAA;QACxF,OAAO,GAAG,OAAO;aACd,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;aACrF,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACb,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;YAClF,OAAO,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAA;QAC1D,CAAC,CAAC,CAAA;IACN,CAAC;IAED,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3B,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,QAAQ,EAAE,CACnF,CAAA;AACH,CAAC"}

package/dist/test-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAIlD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAM,iBAIL,KACA,UAeD,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAI,cAAsB,KAAG,UAMjE,CAAA"}

package/dist/test-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,GAAG,QAAQ,CAAA;AAEvB;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,OAA0B;IACxB,IAAI,EAAE,eAAe;IACrB,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,CAAC,MAAM,CAAC;CACjB,EACW,EAAE,CAAC,CAAC;IAChB,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;QACzB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE;YACJ,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,cAAc,EAAE,IAAI,CAAC,MAAM;SAC5B;KACF,CAAC;IACF,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,EAAE;IAC3B,eAAe,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;IACjC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;IAClC,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,EAAE;CAC3B,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,KAAK,GAAG,cAAc,EAAc,EAAE,CAAC,CAAC;IAChF,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACrD,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,EAAE;IAC3B,eAAe,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;IACjC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;IAClC,UAAU,EAAE,KAAK,IAAI,EAAE,CAAC,EAAE;CAC3B,CAAC,CAAA"}

package/dist/with-canopy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-canopy.d.ts","sourceRoot":"","sources":["../src/with-canopy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAoGtC,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAyBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,UAAU,CACxB,UAAU,GAAE,UAAe,EAC3B,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CA2EZ"}

package/dist/with-canopy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-canopy.js","sourceRoot":"","sources":["../src/with-canopy.ts"],"names":[],"mappings":"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"}