astro 7.0.9 → 7.1.1

package/dist/core/fetch/fetch-state.js

@@ -1,6 +1,7 @@
 import colors from "piccolore";
 import {
   collapseDuplicateLeadingSlashes,
+  collapseDuplicateSlashes,
   prependForwardSlash,
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
@@ -16,7 +17,7 @@ import {
   pipelineSymbol,
   responseSentSymbol
 } from "../constants.js";
-import { pushDirective } from "../csp/runtime.js";
+import { normalizeCspResourceEntry, pushDirective } from "../csp/runtime.js";
 import { generateCspDigest } from "../encryption.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import {
@@ -28,7 +29,6 @@ import {
 import { getParams, getProps } from "../render/index.js";
 import { Rewrites } from "../rewrites/handler.js";
 import { isRoute404or500, isRouteServerIsland } from "../routing/match.js";
-import { normalizeUrl } from "../util/normalized-url.js";
 import { MultiLevelEncodingError, validateAndDecodePathname } from "../util/pathname.js";
 import { getOriginPathname, setOriginPathname } from "../routing/rewrite.js";
 import { computePathnameFromDomain } from "../i18n/domain.js";
@@ -178,28 +178,29 @@ class FetchState {
     this.componentInstance = void 0;
     this.slots = void 0;
     const url = new URL(request.url);
+    const publicPathname = this.#normalizePathname(url.pathname);
+    const pathname = this.#computePathname(publicPathname);
+    url.pathname = publicPathname;
+    url.pathname = collapseDuplicateSlashes(url.pathname);
     const domainPathname = computePathnameFromDomain(
       request,
       url,
       pipeline.manifest.i18n,
       pipeline.manifest.base,
       pipeline.manifest.trailingSlash,
-      pipeline.logger
+      pipeline.logger,
+      pathname
     );
     if (domainPathname) {
       this.#domainPathname = domainPathname;
-      try {
-        this.pathname = decodeURI(domainPathname);
-      } catch {
-        this.pathname = domainPathname;
-      }
+      this.pathname = domainPathname;
     } else {
-      this.pathname = this.#computePathname(url);
+      this.pathname = pathname;
     }
     this.timeStart = performance.now();
     this.clientAddress = options?.clientAddress;
     this.locals = options?.locals ?? {};
-    this.url = normalizeUrl(url);
+    this.url = url;
     this.cookies = new AstroCookies(request);
     if (pipeline.manifest.allowedDomains && pipeline.manifest.allowedDomains.length > 0 && !this.routeData?.prerender) {
       this.#applyForwardedHeaders();
@@ -304,12 +305,26 @@ class FetchState {
       cspDestination: manifest.csp?.cspDestination ?? (routeData.prerender ? "meta" : "header"),
       shouldInjectCspMetaTags,
       cspAlgorithm,
+      directives: manifest.csp?.directives ? [...manifest.csp.directives] : [],
+      // Deprecated flat fields, kept for back-compat. Seeded from the manifest; the runtime CSP
+      // API updates the structured `scriptDirective`/`styleDirective` below (which the renderer
+      // reads), not these.
       scriptHashes: manifest.csp?.scriptHashes ? [...manifest.csp.scriptHashes] : [],
       scriptResources: manifest.csp?.scriptResources ? [...manifest.csp.scriptResources] : [],
       styleHashes: manifest.csp?.styleHashes ? [...manifest.csp.styleHashes] : [],
       styleResources: manifest.csp?.styleResources ? [...manifest.csp.styleResources] : [],
-      directives: manifest.csp?.directives ? [...manifest.csp.directives] : [],
       isStrictDynamic: manifest.csp?.isStrictDynamic ?? false,
+      // Structured fields (source of truth). Arrays are cloned so per-request runtime inserts
+      // don't mutate the shared manifest.
+      scriptDirective: {
+        resources: manifest.csp?.scriptDirective ? [...manifest.csp.scriptDirective.resources] : [],
+        hashes: manifest.csp?.scriptDirective ? [...manifest.csp.scriptDirective.hashes] : [],
+        strictDynamic: manifest.csp?.scriptDirective?.strictDynamic ?? false
+      },
+      styleDirective: {
+        resources: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.resources] : [],
+        hashes: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.hashes] : []
+      },
       internalFetchHeaders: manifest.internalFetchHeaders
     };
     this.result = result;
@@ -451,23 +466,51 @@ class FetchState {
       }
       return void 0;
     }
+    const warnedFallback = /* @__PURE__ */ new Set();
+    const warnFallback = (family, kind) => {
+      if (kind === "default" || !state.result) {
+        return;
+      }
+      const directive = family === "script" ? state.result.scriptDirective : state.result.styleDirective;
+      const defaultResources = directive.resources.map(normalizeCspResourceEntry).filter((entry) => entry.kind === "default").map((entry) => entry.resource);
+      if (defaultResources.length === 0) {
+        return;
+      }
+      const key = `${family}:${kind}`;
+      if (warnedFallback.has(key)) {
+        return;
+      }
+      warnedFallback.add(key);
+      const general = `${family}-src`;
+      const specific = `${general}-${kind === "element" ? "elem" : "attr"}`;
+      pipeline.logger.warn(
+        "csp",
+        `A resource was added to \`${specific}\`, but \`${general}\` also defines custom resources (${defaultResources.join(
+          " "
+        )}). Because \`${specific}\` overrides \`${general}\` for its scope (browsers do not fall back), those resources will not apply there. Add them to \`${specific}\` as well if needed.`
+      );
+    };
     return {
       insertDirective(payload) {
         if (state.result) {
           state.result.directives = pushDirective(state.result.directives, payload);
         }
       },
-      insertScriptResource(resource) {
-        state.result?.scriptResources.push(resource);
+      insertScriptResource(payload) {
+        if (!state.result) return;
+        warnFallback("script", normalizeCspResourceEntry(payload).kind);
+        state.result.scriptDirective.resources.push(payload);
       },
-      insertStyleResource(resource) {
-        state.result?.styleResources.push(resource);
+      insertStyleResource(payload) {
+        if (!state.result) return;
+        warnFallback("style", normalizeCspResourceEntry(payload).kind);
+        state.result.styleDirective.resources.push(payload);
       },
-      insertStyleHash(hash) {
-        state.result?.styleHashes.push(hash);
+      insertStyleHash(payload) {
+        state.result?.styleDirective.hashes.push(payload);
       },
-      insertScriptHash(hash) {
-        state.result?.scriptHashes.push(hash);
+      insertScriptHash(payload) {
+        state.result?.scriptDirective.hashes.push(payload);
       }
     };
   }
@@ -690,32 +733,37 @@ class FetchState {
     this.#stripHtmlExtension();
   }
   /**
-   * Strips the pipeline's base from the request URL, prepends a forward
-   * slash, and decodes the pathname. Falls back to the raw (not decoded)
-   * pathname if `decodeURI` throws.
+   * Strips the pipeline's base from a normalized request pathname and prepends
+   * a forward slash.
    *
    * Mirrors `BaseApp.removeBase`, including the
    * `collapseDuplicateLeadingSlashes` fix that prevents middleware
    * authorization bypass when the URL starts with `//`.
    */
-  #computePathname(url) {
-    let pathname = collapseDuplicateLeadingSlashes(url.pathname);
+  #computePathname(normalizedPathname) {
+    let pathname = collapseDuplicateLeadingSlashes(normalizedPathname);
     const base = this.pipeline.manifest.base;
     if (pathname.startsWith(base)) {
       const baseWithoutTrailingSlash = removeTrailingForwardSlash(base);
       pathname = pathname.slice(baseWithoutTrailingSlash.length + 1);
     }
-    pathname = prependForwardSlash(pathname);
+    return prependForwardSlash(pathname);
+  }
+  /**
+   * Decodes and normalizes the public request pathname before deriving the
+   * separate pathname used for route matching.
+   */
+  #normalizePathname(pathname) {
     try {
-      return validateAndDecodePathname(pathname);
+      pathname = validateAndDecodePathname(pathname);
     } catch (e) {
       if (e instanceof MultiLevelEncodingError) {
         this.invalidEncoding = true;
-        return pathname;
+      } else {
+        this.pipeline.logger.error(null, e.toString());
       }
-      this.pipeline.logger.error(null, e.toString());
-      return pathname;
     }
+    return collapseDuplicateSlashes(pathname);
   }
   /**
    * Reads X-Forwarded-Proto, X-Forwarded-Host, and X-Forwarded-Port

package/dist/core/i18n/domain.d.ts

@@ -9,4 +9,4 @@ import type { AstroLogger } from '../logger/core.js';
  * mapped to a locale — in which case normal pathname routing applies.
  *
  */
-export declare function computePathnameFromDomain(request: Request, url: URL, i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], logger: AstroLogger): string | undefined;
+export declare function computePathnameFromDomain(request: Request, url: URL, i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], logger: AstroLogger, pathnameFromRequest?: string): string | undefined;

package/dist/core/i18n/domain.js

@@ -6,7 +6,7 @@ import {
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { normalizeTheLocale } from "../../i18n/path.js";
-function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logger) {
+function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logger, pathnameFromRequest) {
   let pathname = void 0;
   if (i18n && (i18n.strategy === "domains-prefix-always" || i18n.strategy === "domains-prefix-other-locales" || i18n.strategy === "domains-prefix-always-no-redirect")) {
     let host = request.headers.get("X-Forwarded-Host");
@@ -32,14 +32,13 @@ function computePathnameFromDomain(request, url, i18n, base, trailingSlash, logg
           }
         }
         if (locale) {
-          pathname = prependForwardSlash(
-            joinPaths(normalizeTheLocale(locale), removeBase(url.pathname, base))
-          );
+          const requestPathname = pathnameFromRequest ?? removeBase(url.pathname, base);
+          pathname = prependForwardSlash(joinPaths(normalizeTheLocale(locale), requestPathname));
           if (trailingSlash === "always") {
             pathname = appendForwardSlash(pathname);
           } else if (trailingSlash === "never") {
             pathname = removeTrailingForwardSlash(pathname);
-          } else if (url.pathname.endsWith("/")) {
+          } else if (requestPathname.endsWith("/")) {
             pathname = appendForwardSlash(pathname);
           }
         }

package/dist/core/logger/config.d.ts

@@ -2,5 +2,5 @@ export interface LoggerHandlerConfig {
     /** Serializable options used by the driver implementation */
     config?: Record<string, any> | undefined;
     /** URL or package import */
-    entrypoint: string;
+    entrypoint: string | URL;
 }

package/dist/core/logger/core.d.ts

@@ -1,8 +1,8 @@
-export interface AstroLoggerDestination<T = unknown> {
+export interface AstroLoggerDestination {
     /**
      * It receives a message and writes it into a destination
      */
-    write: (chunk: T) => void;
+    write: (chunk: AstroLoggerMessage) => void;
     /**
      * It dumps logs without closing the connection to the destination.
      * Method that can be used by specialized loggers.
@@ -31,7 +31,7 @@ export type AstroLoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
 declare const AstroLoggerLabels: readonly ["add", "build", "check", "config", "content", "crypto", "deprecated", "markdown", "router", "types", "vite", "watch", "middleware", "preferences", "redirects", "sync", "session", "toolbar", "assets", "env", "update", "adapter", "islands", "cache", "csp", "SKIP_FORMAT"];
 type AstroLoggerLabel = (typeof AstroLoggerLabels)[number];
 export interface AstroLogOptions {
-    destination: AstroLoggerDestination<AstroLoggerMessage>;
+    destination: AstroLoggerDestination;
     level: AstroLoggerLevel;
     /**
      * Optional configuration for the logger destination
@@ -78,7 +78,7 @@ export declare class AstroLogger {
     debug(label: AstroLoggerLabel, ...messages: any[]): void;
     level(): AstroLoggerLevel;
     forkIntegrationLogger(label: string): AstroIntegrationLogger;
-    setDestination(destination: AstroLoggerDestination<AstroLoggerMessage>): void;
+    setDestination(destination: AstroLoggerDestination): void;
     /**
      * It calls the `close` function of the provided destination, if it exists.
      */

package/dist/core/logger/impls/console.d.ts

@@ -1,4 +1,4 @@
-import { type AstroLoggerMessage, type AstroLoggerDestination, type AstroLoggerLevel, AstroLogger } from '../core.js';
+import { type AstroLoggerDestination, type AstroLoggerLevel, AstroLogger } from '../core.js';
 import type { NodeHandlerConfig } from './node.js';
 export type ConsoleHandlerConfig = {
     level?: AstroLoggerLevel;
@@ -6,4 +6,4 @@ export type ConsoleHandlerConfig = {
 export declare function createConsoleLogger({ level }: {
     level: AstroLoggerLevel;
 }): AstroLogger;
-export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination;

package/dist/core/logger/impls/json.d.ts

@@ -1,4 +1,4 @@
-import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel } from '../core.js';
 import type { AstroInlineConfig } from '../../../types/public/index.js';
 export type JsonHandlerConfig = {
     /**
@@ -11,5 +11,5 @@ export type JsonHandlerConfig = {
     level?: AstroLoggerLevel;
 };
 export declare const SGR_REGEX: RegExp;
-export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination;
 export declare function createJsonLoggerFromFlags(config: AstroInlineConfig): AstroLogger;

package/dist/core/logger/impls/json.js

@@ -8,24 +8,13 @@ function jsonLoggerDestination(config = {}) {
   const { pretty = false, level = "info" } = config;
   return {
     write(event) {
-      let dest = process.stderr;
-      if (levels[event.level] < levels["error"]) {
-        dest = process.stdout;
-      }
       if (!matchesLevel(event.level, level)) {
         return;
       }
-      let trailingLine = event.newLine ? "\n" : "";
+      const dest = levels[event.level] >= levels["error"] ? console.error : console.info;
       const message = event.message.replace(SGR_REGEX, "");
-      if (pretty) {
-        dest.write(
-          JSON.stringify({ message, label: event.label, level: event.level }, null, 2) + trailingLine
-        );
-      } else {
-        dest.write(
-          JSON.stringify({ message, label: event.label, level: event.level }) + trailingLine
-        );
-      }
+      const payload = pretty ? JSON.stringify({ message, label: event.label, level: event.level }, null, 2) : JSON.stringify({ message, label: event.label, level: event.level });
+      dest(payload);
     }
   };
 }

package/dist/core/logger/impls/node.d.ts

@@ -1,7 +1,7 @@
-import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel } from '../core.js';
 import type { AstroInlineConfig } from '../../../types/public/index.js';
 export type NodeHandlerConfig = {
     level?: AstroLoggerLevel;
 };
-export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination;
 export declare function createNodeLoggerFromFlags(inlineConfig: AstroInlineConfig): AstroLogger;

package/dist/core/logger/load.d.ts

@@ -1,7 +1,7 @@
-import { AstroLogger, type AstroLoggerLevel } from './core.js';
+import { AstroLogger, type AstroLoggerDestination } from './core.js';
 import type { LoggerHandlerConfig } from './config.js';
 import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
-export declare function loadLogger(config: LoggerHandlerConfig, level?: AstroLoggerLevel): Promise<AstroLogger>;
+export declare function loadLoggerDestination(config: LoggerHandlerConfig): Promise<AstroLoggerDestination>;
 /**
  * It attempts to load a logger from the entrypoint.
  * If not provided, it creates a new logger instance on the fly.

package/dist/core/logger/load.js

@@ -5,27 +5,22 @@ import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls
 import { default as consoleLoggerCreator } from "./impls/console.js";
 import { default as jsonLoggerCreator } from "./impls/json.js";
 import { default as composeLoggerCreator } from "./impls/compose.js";
-async function loadLogger(config, level = "info") {
+function normalizeEntrypoint(entrypoint) {
+  return entrypoint instanceof URL ? entrypoint.href : entrypoint;
+}
+async function loadLoggerDestination(config) {
   let cause = void 0;
+  const entrypoint = normalizeEntrypoint(config.entrypoint);
   try {
     switch (config.entrypoint) {
       case "astro/logger/node": {
-        return new AstroLogger({
-          destination: nodeLoggerCreator(config.config),
-          level
-        });
+        return nodeLoggerCreator(config.config);
       }
       case "astro/logger/console": {
-        return new AstroLogger({
-          destination: consoleLoggerCreator(config.config),
-          level
-        });
+        return consoleLoggerCreator(config.config);
       }
       case "astro/logger/json": {
-        return new AstroLogger({
-          destination: jsonLoggerCreator(config.config),
-          level
-        });
+        return jsonLoggerCreator(config.config);
       }
       case "astro/logger/compose": {
         let destinations = [];
@@ -35,26 +30,20 @@ async function loadLogger(config, level = "info") {
             loggers.map(async (loggerConfig) => {
               const logger = await import(
                 /* @vite-ignore */
-                loggerConfig.entrypoint
+                normalizeEntrypoint(loggerConfig.entrypoint)
               );
               return logger.default(loggerConfig.config);
             })
           );
         }
-        return new AstroLogger({
-          destination: composeLoggerCreator(destinations),
-          level
-        });
+        return composeLoggerCreator(destinations);
       }
       default: {
-        const nodeLogger = await import(
+        const logger = await import(
           /* @vite-ignore */
-          config.entrypoint
+          entrypoint
         );
-        return new AstroLogger({
-          destination: nodeLogger.default(config.config),
-          level
-        });
+        return logger.default(config.config);
       }
     }
   } catch (e) {
@@ -64,7 +53,7 @@ async function loadLogger(config, level = "info") {
   }
   const error = new AstroError({
     ...UnableToLoadLogger,
-    message: UnableToLoadLogger.message(config.entrypoint)
+    message: UnableToLoadLogger.message(entrypoint)
   });
   if (cause) {
     error.cause = cause;
@@ -75,7 +64,10 @@ async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   if (inlineAstroConfig._logger) return inlineAstroConfig._logger;
   try {
     if (astroConfig.logger) {
-      return await loadLogger(astroConfig.logger, inlineAstroConfig.logLevel);
+      return new AstroLogger({
+        destination: await loadLoggerDestination(astroConfig.logger),
+        level: inlineAstroConfig.logLevel ?? "info"
+      });
     } else {
       return createNodeLoggerFromFlags(inlineAstroConfig);
     }
@@ -84,6 +76,6 @@ async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   }
 }
 export {
-  loadLogger,
+  loadLoggerDestination,
   loadOrCreateNodeLogger
 };

package/dist/core/messages/runtime.d.ts

@@ -58,3 +58,11 @@ export declare function printHelp({ commandName, headline, usage, tables, descri
     description?: string;
 }): void;
 export declare function warnIfCspWithShiki(config: AstroConfig, logger: AstroLogger): void;
+/**
+ * Warns when a `scriptDirective`/`styleDirective` defines `default`-kind resources alongside
+ * `element`/`attribute`-kind entries. Because the more specific directive (`*-src-elem`/`*-src-attr`)
+ * overrides the generic one for its scope and browsers do not fall back, the generic resources will
+ * not apply there. Astro's generated hashes are folded automatically, so this only concerns
+ * user-provided resources.
+ */
+export declare function warnIfCspResourceFallbackShadowing(config: AstroConfig, logger: AstroLogger): void;

package/dist/core/messages/runtime.js

@@ -1,4 +1,5 @@
 import colors from "piccolore";
+import { partitionByKind } from "../csp/runtime.js";
 import { getDocsForError, renderErrorMarkdown } from "../errors/dev/runtime.js";
 import {
   AstroError,
@@ -269,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.0.9"}`
+        `v${"7.1.1"}`
       )} ${headline}`
     );
   }
@@ -304,6 +305,37 @@ function warnIfCspWithShiki(config, logger) {
     );
   }
 }
+function warnIfCspResourceFallbackShadowing(config, logger) {
+  const csp = config.security.csp;
+  if (typeof csp !== "object") return;
+  const families = [
+    { name: "script", directive: csp.scriptDirective },
+    { name: "style", directive: csp.styleDirective }
+  ];
+  for (const { name, directive } of families) {
+    const sources = partitionByKind({
+      resources: directive?.resources ?? [],
+      hashes: directive?.hashes ?? []
+    });
+    if (sources.default.resources.length === 0) continue;
+    const shadowed = [];
+    if (sources.element.resources.length > 0 || sources.element.hashes.length > 0) {
+      shadowed.push(`\`${name}-src-elem\``);
+    }
+    if (sources.attribute.resources.length > 0 || sources.attribute.hashes.length > 0) {
+      shadowed.push(`\`${name}-src-attr\``);
+    }
+    if (shadowed.length === 0) continue;
+    logger.warn(
+      "csp",
+      `\`security.csp.${name}Directive\` defines \`${name}-src\` resources (${sources.default.resources.join(
+        " "
+      )}) as well as ${shadowed.join(" and ")} resources or hashes. Because ${shadowed.join(
+        " and "
+      )} override \`${name}-src\` for their scope (browsers do not fall back), those \`${name}-src\` resources will not apply there. Add them to the corresponding \`kind\` if needed.`
+    );
+  }
+}
 export {
   actionRequired,
   cancelled,
@@ -327,5 +359,6 @@ export {
   telemetryEnabled,
   telemetryNotice,
   telemetryReset,
+  warnIfCspResourceFallbackShadowing,
   warnIfCspWithShiki
 };

package/dist/core/render/paginate.js

@@ -4,11 +4,12 @@ import { getRouteGenerator } from "../routing/generator.js";
 function generatePaginateFunction(routeMatch, base, trailingSlash) {
   return function paginateUtility(data, args = {}) {
     const generate = getRouteGenerator(routeMatch.segments, trailingSlash);
-    let { pageSize: _pageSize, params: _params, props: _props } = args;
+    let { pageSize: _pageSize, params: _params, props: _props, format: _format } = args;
     const pageSize = _pageSize || 10;
     const paramName = "page";
     const additionalParams = _params || {};
     const additionalProps = _props || {};
+    const formatUrl = _format || ((url) => url);
     let includesFirstPageNumber;
     if (routeMatch.params.includes(`...${paramName}`)) {
       includesFirstPageNumber = false;
@@ -29,23 +30,27 @@ function generatePaginateFunction(routeMatch, base, trailingSlash) {
         ...additionalParams,
         [paramName]: includesFirstPageNumber || pageNum > 1 ? String(pageNum) : void 0
       };
-      const current = addRouteBase(generate({ ...params }), base);
-      const next = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(pageNum + 1) }), base);
-      const prev = pageNum === 1 ? void 0 : addRouteBase(
-        generate({
-          ...params,
-          page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
-        }),
-        base
+      const current = formatUrl(addRouteBase(generate({ ...params }), base));
+      const next = pageNum === lastPage ? void 0 : formatUrl(addRouteBase(generate({ ...params, page: String(pageNum + 1) }), base));
+      const prev = pageNum === 1 ? void 0 : formatUrl(
+        addRouteBase(
+          generate({
+            ...params,
+            page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
+          }),
+          base
+        )
       );
-      const first = pageNum === 1 ? void 0 : addRouteBase(
-        generate({
-          ...params,
-          page: includesFirstPageNumber ? "1" : void 0
-        }),
-        base
+      const first = pageNum === 1 ? void 0 : formatUrl(
+        addRouteBase(
+          generate({
+            ...params,
+            page: includesFirstPageNumber ? "1" : void 0
+          }),
+          base
+        )
       );
-      const last = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(lastPage) }), base);
+      const last = pageNum === lastPage ? void 0 : formatUrl(addRouteBase(generate({ ...params, page: String(lastPage) }), base));
       return {
         params,
         props: {

package/dist/core/sync/index.js

@@ -6,7 +6,7 @@ import colors from "piccolore";
 import { createServer } from "vite";
 import { syncFonts } from "../../assets/fonts/sync.js";
 import { CONTENT_TYPES_FILE } from "../../content/consts.js";
-import { getDataStoreFile } from "../../content/content-layer.js";
+import { getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
 import { createContentTypesGenerator } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
@@ -59,11 +59,21 @@ async function clearContentLayerCache({
   fs = fsMod,
   isDev
 }) {
-  const dataStore = getDataStoreFile(settings, isDev);
-  if (fs.existsSync(dataStore)) {
-    logger.debug("content", "clearing data store");
-    await fs.promises.rm(dataStore, { force: true });
-    logger.warn("content", "data store cleared (force)");
+  if (settings.config.experimental.collectionStorage === "chunked") {
+    const dataStore = getDataStoreDir(settings, isDev);
+    if (fs.existsSync(dataStore)) {
+      logger.debug("content", "clearing data store");
+      await fs.promises.rm(dataStore, { force: true, recursive: true });
+      await fs.promises.mkdir(dataStore, { recursive: true });
+      logger.warn("content", "data store cleared (force)");
+    }
+  } else {
+    const dataStore = getDataStoreFile(settings, isDev);
+    if (fs.existsSync(dataStore)) {
+      logger.debug("content", "clearing data store");
+      await fs.promises.rm(dataStore, { force: true });
+      logger.warn("content", "data store cleared (force)");
+    }
   }
 }
 async function syncInternal({
@@ -88,8 +98,13 @@ async function syncInternal({
       settings.timer.start("Sync content layer");
       let store;
       try {
-        const dataStoreFile = getDataStoreFile(settings, isDev);
-        store = await MutableDataStore.fromFile(dataStoreFile);
+        if (settings.config.experimental.collectionStorage === "chunked") {
+          const dataStoreDir = getDataStoreDir(settings, isDev);
+          store = await MutableDataStore.fromDir(dataStoreDir);
+        } else {
+          const dataStoreFile = getDataStoreFile(settings, isDev);
+          store = await MutableDataStore.fromFile(dataStoreFile);
+        }
       } catch (err) {
         logger.error("content", err.message);
       }