@stati/core 1.27.1 → 1.27.2

package/dist/core/build.js

@@ -273,7 +273,7 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
         const shouldRebuild = options.force ||
             config.isg?.enabled === false ||
             !(await pathExists(outputPath)) ||
-            (await shouldRebuildPage(page, existingEntry, config, buildTime, renderInputsHash));
+            (await shouldRebuildPage(page, existingEntry, config, pages, buildTime, renderInputsHash));
         const shouldRebuildTime = performance.now() - shouldRebuildStart;
         totalShouldRebuildTime += shouldRebuildTime;
         if (!shouldRebuild) {
@@ -357,10 +357,10 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
             if (!options.skipCacheUpdate) {
                 const cacheEntryStart = performance.now();
                 if (existingEntry) {
-                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime, false, renderInputsHash);
+                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, pages, buildTime, false, renderInputsHash);
                 }
                 else {
-                    manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime, renderInputsHash);
+                    manifest.entries[cacheKey] = await createCacheEntry(page, config, pages, buildTime, renderInputsHash);
                 }
                 totalCacheEntryTime += performance.now() - cacheEntryStart;
             }
@@ -393,11 +393,11 @@ async function processPagesWithCache(pages, manifest, config, outDir, md, eta, n
             for (const { cacheKey, page, existingEntry, renderInputsHash } of pendingCacheUpdates) {
                 if (existingEntry) {
                     // Fast update: reuse existing deps, just update hashes and timestamp
-                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, buildTime, true, // fastUpdate = true in dev mode
+                    manifest.entries[cacheKey] = await updateCacheEntry(existingEntry, page, config, pages, buildTime, true, // fastUpdate = true in dev mode
                     renderInputsHash);
                 }
                 else {
-                    manifest.entries[cacheKey] = await createCacheEntry(page, config, buildTime, renderInputsHash);
+                    manifest.entries[cacheKey] = await createCacheEntry(page, config, pages, buildTime, renderInputsHash);
                 }
             }
             totalCacheEntryTime = performance.now() - cacheEntryStart;

package/dist/core/isg/builder.d.ts

@@ -7,34 +7,36 @@ import type { PageModel, CacheEntry, StatiConfig } from '../../types/index.js';
  * @param page - The page model to check
  * @param entry - Existing cache entry, or undefined if not cached
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param now - Current date/time
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
  * @returns True if the page should be rebuilt
  *
  * @example
  * ```typescript
- * const shouldRebuild = await shouldRebuildPage(page, cacheEntry, config, new Date());
+ * const shouldRebuild = await shouldRebuildPage(page, cacheEntry, config, pages, new Date());
  * if (shouldRebuild) {
  *   console.log('Page needs rebuilding');
  * }
  * ```
  */
-export declare function shouldRebuildPage(page: PageModel, entry: CacheEntry | undefined, config: StatiConfig, now: Date, renderInputsHash?: string): Promise<boolean>;
+export declare function shouldRebuildPage(page: PageModel, entry: CacheEntry | undefined, config: StatiConfig, allPages: PageModel[], now: Date, renderInputsHash?: string): Promise<boolean>;
 /**
  * Creates a new cache entry for a page after it has been rendered.
  *
  * @param page - The page model
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param renderedAt - When the page was rendered
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
  * @returns New cache entry
  *
  * @example
  * ```typescript
- * const entry = await createCacheEntry(page, config, new Date());
+ * const entry = await createCacheEntry(page, config, pages, new Date());
  * ```
  */
-export declare function createCacheEntry(page: PageModel, config: StatiConfig, renderedAt: Date, renderInputsHash?: string): Promise<CacheEntry>;
+export declare function createCacheEntry(page: PageModel, config: StatiConfig, allPages: PageModel[], renderedAt: Date, renderInputsHash?: string): Promise<CacheEntry>;
 /**
  * Updates an existing cache entry with new information after rebuilding.
  * In dev mode, this is optimized to reuse the existing deps array since
@@ -43,6 +45,7 @@ export declare function createCacheEntry(page: PageModel, config: StatiConfig, r
  * @param entry - Existing cache entry
  * @param page - The page model
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param renderedAt - When the page was rendered
  * @param fastUpdate - If true, skip expensive dep tracking (dev mode optimization)
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
@@ -50,8 +53,8 @@ export declare function createCacheEntry(page: PageModel, config: StatiConfig, r
  *
  * @example
  * ```typescript
- * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date());
+ * const updatedEntry = await updateCacheEntry(existingEntry, page, config, pages, new Date());
  * ```
  */
-export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, renderedAt: Date, fastUpdate?: boolean, renderInputsHash?: string): Promise<CacheEntry>;
+export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, allPages: PageModel[], renderedAt: Date, fastUpdate?: boolean, renderInputsHash?: string): Promise<CacheEntry>;
 //# sourceMappingURL=builder.d.ts.map

package/dist/core/isg/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAqE/E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,IAAI,EACT,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,OAAO,CAAC,CAoKlB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC,CAqFrB;AAkDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,EAChB,UAAU,UAAQ,EAClB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC,CA4CrB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAqE/E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,EACrB,GAAG,EAAE,IAAI,EACT,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,OAAO,CAAC,CAoKlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,EACrB,UAAU,EAAE,IAAI,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC,CAqFrB;AAkDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,EACrB,UAAU,EAAE,IAAI,EAChB,UAAU,UAAQ,EAClB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC,CAmDrB"}

package/dist/core/isg/builder.js

@@ -1,5 +1,5 @@
 import { computeContentHash, computeFileHash, computeInputsHash } from './hash.js';
-import { trackTemplateDependencies } from './deps.js';
+import { trackTemplateDependencies, resolveLayoutDependency } from './deps.js';
 import { computeEffectiveTTL, computeNextRebuildAt, isPageFrozen } from './ttl.js';
 import { validatePageISGOverrides, extractNumericOverride } from './validation.js';
 import { getFrontMatterDate } from '../utils/index.js';
@@ -65,19 +65,20 @@ function isValidCacheEntry(entry) {
  * @param page - The page model to check
  * @param entry - Existing cache entry, or undefined if not cached
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param now - Current date/time
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
  * @returns True if the page should be rebuilt
  *
  * @example
  * ```typescript
- * const shouldRebuild = await shouldRebuildPage(page, cacheEntry, config, new Date());
+ * const shouldRebuild = await shouldRebuildPage(page, cacheEntry, config, pages, new Date());
  * if (shouldRebuild) {
  *   console.log('Page needs rebuilding');
  * }
  * ```
  */
-export async function shouldRebuildPage(page, entry, config, now, renderInputsHash) {
+export async function shouldRebuildPage(page, entry, config, allPages, now, renderInputsHash) {
     if (config.isg?.enabled === false) {
         return true;
     }
@@ -96,7 +97,7 @@ export async function shouldRebuildPage(page, entry, config, now, renderInputsHa
         // Track dependencies with error handling
         let deps;
         try {
-            deps = await trackTemplateDependencies(page, config);
+            deps = await trackTemplateDependencies(page, config, allPages);
         }
         catch (error) {
             if (error instanceof Error && error.name === 'CircularDependencyError') {
@@ -211,16 +212,17 @@ export async function shouldRebuildPage(page, entry, config, now, renderInputsHa
  *
  * @param page - The page model
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param renderedAt - When the page was rendered
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
  * @returns New cache entry
  *
  * @example
  * ```typescript
- * const entry = await createCacheEntry(page, config, new Date());
+ * const entry = await createCacheEntry(page, config, pages, new Date());
  * ```
  */
-export async function createCacheEntry(page, config, renderedAt, renderInputsHash) {
+export async function createCacheEntry(page, config, allPages, renderedAt, renderInputsHash) {
     const timings = {};
     let start = performance.now();
     // Validate page-level ISG overrides first
@@ -232,7 +234,7 @@ export async function createCacheEntry(page, config, renderedAt, renderInputsHas
     timings.contentHash = performance.now() - start;
     // Track all template dependencies
     start = performance.now();
-    const deps = await trackTemplateDependencies(page, config);
+    const deps = await trackTemplateDependencies(page, config, allPages);
     timings.trackDeps = performance.now() - start;
     // Compute hashes for all dependencies
     start = performance.now();
@@ -339,6 +341,7 @@ async function hasTemplateStructureChanged(entry) {
  * @param entry - Existing cache entry
  * @param page - The page model
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to resolve the same layout as rendering
  * @param renderedAt - When the page was rendered
  * @param fastUpdate - If true, skip expensive dep tracking (dev mode optimization)
  * @param renderInputsHash - Optional hash of asset URLs and injection settings
@@ -346,19 +349,24 @@ async function hasTemplateStructureChanged(entry) {
  *
  * @example
  * ```typescript
- * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date());
+ * const updatedEntry = await updateCacheEntry(existingEntry, page, config, pages, new Date());
  * ```
  */
-export async function updateCacheEntry(entry, page, config, renderedAt, fastUpdate = false, renderInputsHash) {
+export async function updateCacheEntry(entry, page, config, allPages, renderedAt, fastUpdate = false, renderInputsHash) {
     // In fast update mode (dev), reuse existing deps to avoid expensive tracking
     if (fastUpdate && entry.deps.length > 0) {
         // Detect if template structure has changed (new includes/extends added)
         // by checking if the layout file has been modified or if template content
         // contains different dependency patterns
         const structureChanged = await hasTemplateStructureChanged(entry);
-        if (structureChanged) {
-            // Template structure changed - fall through to full dependency tracking
-            // This ensures we pick up new includes/extends
+        // The page can also switch layouts without any template file changing, for example
+        // when a collection gains its first child page or a front matter layout is edited.
+        // deps[0] is always the layout, so compare it against the layout used now.
+        const layoutChanged = !structureChanged &&
+            (await resolveLayoutDependency(page, config, allPages)) !== entry.deps[0];
+        if (structureChanged || layoutChanged) {
+            // Template structure or layout changed - fall through to full dependency tracking
+            // This ensures we pick up new includes/extends and the newly selected layout
         }
         else {
             // Structure unchanged - safe to reuse existing deps
@@ -381,7 +389,7 @@ export async function updateCacheEntry(entry, page, config, renderedAt, fastUpda
         }
     }
     // Full update - create new entry and preserve original publishedAt
-    const newEntry = await createCacheEntry(page, config, renderedAt, renderInputsHash);
+    const newEntry = await createCacheEntry(page, config, allPages, renderedAt, renderInputsHash);
     // Preserve original publishedAt if no new one is specified
     if (!newEntry.publishedAt && entry.publishedAt) {
         newEntry.publishedAt = entry.publishedAt;

package/dist/core/isg/deps.d.ts

@@ -22,13 +22,14 @@ export declare class CircularDependencyError extends Error {
  *
  * @param page - The page model to track dependencies for
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
  * @returns Array of absolute paths to actually-used template files (POSIX format)
  * @throws {CircularDependencyError} When circular dependencies are detected in templates
  *
  * @example
  * ```typescript
  * try {
- *   const deps = await trackTemplateDependencies(page, config);
+ *   const deps = await trackTemplateDependencies(page, config, allPages);
  *   console.log(`Page depends on ${deps.length} template files`);
  * } catch (error) {
  *   if (error instanceof CircularDependencyError) {
@@ -37,7 +38,18 @@ export declare class CircularDependencyError extends Error {
  * }
  * ```
  */
-export declare function trackTemplateDependencies(page: PageModel, config: StatiConfig): Promise<string[]>;
+export declare function trackTemplateDependencies(page: PageModel, config: StatiConfig, allPages: PageModel[]): Promise<string[]>;
+/**
+ * Resolves the layout a page renders with, in the form stored as the first entry of its
+ * cache dependencies. Uses the same lookup as rendering, so callers can tell whether the
+ * page's layout has changed since its dependencies were recorded.
+ *
+ * @param page - The page model to resolve the layout for
+ * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
+ * @returns Absolute path to the layout file (POSIX format), or null if no layout applies
+ */
+export declare function resolveLayoutDependency(page: PageModel, config: StatiConfig, allPages: PageModel[]): Promise<string | null>;
 /**
  * Resolves a template name to its file path.
  * Used for explicit layout specifications in front matter.

package/dist/core/isg/deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAenE;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CA+CnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAenE;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAAC,MAAM,EAAE,CAAC,CAuCnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAexB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}

package/dist/core/isg/deps.js

@@ -42,13 +42,14 @@ export class CircularDependencyError extends Error {
  *
  * @param page - The page model to track dependencies for
  * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
  * @returns Array of absolute paths to actually-used template files (POSIX format)
  * @throws {CircularDependencyError} When circular dependencies are detected in templates
  *
  * @example
  * ```typescript
  * try {
- *   const deps = await trackTemplateDependencies(page, config);
+ *   const deps = await trackTemplateDependencies(page, config, allPages);
  *   console.log(`Page depends on ${deps.length} template files`);
  * } catch (error) {
  *   if (error instanceof CircularDependencyError) {
@@ -57,7 +58,7 @@ export class CircularDependencyError extends Error {
  * }
  * ```
  */
-export async function trackTemplateDependencies(page, config) {
+export async function trackTemplateDependencies(page, config, allPages) {
     // Early return if required config values are missing
     if (!config.srcDir) {
         console.warn('Config srcDir is missing, cannot track template dependencies');
@@ -65,16 +66,13 @@ export async function trackTemplateDependencies(page, config) {
     }
     const deps = [];
     const srcDir = resolveSrcDir(config);
-    const relativePath = relative(srcDir, page.sourcePath);
     // Track dependencies with circular detection
     // The visited set will contain all templates that are actually used (not just accessible)
     const visited = new Set();
     const currentPath = new Set();
     // 1. Find the layout file that will be used for this page
-    const layoutPath = await discoverLayout(relativePath, config, page.frontMatter.layout, isCollectionIndexPage(page));
-    if (layoutPath) {
-        // Normalize to POSIX format for consistent manifest output across platforms
-        const absoluteLayoutPath = posix.join(srcDir.replace(/\\/g, '/'), layoutPath);
+    const absoluteLayoutPath = await resolveLayoutDependency(page, config, allPages);
+    if (absoluteLayoutPath) {
         deps.push(absoluteLayoutPath);
         // Recursively traverse the template dependency tree
         // This populates 'visited' with all actually-used templates (not just accessible ones)
@@ -93,6 +91,25 @@ export async function trackTemplateDependencies(page, config) {
     }
     return deps;
 }
+/**
+ * Resolves the layout a page renders with, in the form stored as the first entry of its
+ * cache dependencies. Uses the same lookup as rendering, so callers can tell whether the
+ * page's layout has changed since its dependencies were recorded.
+ *
+ * @param page - The page model to resolve the layout for
+ * @param config - Stati configuration
+ * @param allPages - All pages in the site, used to detect collection index pages the same way rendering does
+ * @returns Absolute path to the layout file (POSIX format), or null if no layout applies
+ */
+export async function resolveLayoutDependency(page, config, allPages) {
+    if (!config.srcDir) {
+        return null;
+    }
+    const srcDir = resolveSrcDir(config);
+    const layoutPath = await discoverLayout(relative(srcDir, page.sourcePath), config, page.frontMatter.layout, isCollectionIndexPage(page, allPages));
+    // Normalize to POSIX format for consistent manifest output across platforms
+    return layoutPath ? posix.join(srcDir.replace(/\\/g, '/'), layoutPath) : null;
+}
 /**
  * Resolves a template name to its file path.
  * Used for explicit layout specifications in front matter.

package/dist/core/utils/template-discovery.utils.d.ts

@@ -1,17 +1,19 @@
 import type { StatiConfig, PageModel } from '../../types/index.js';
-/**
- * Shared template discovery utilities.
- * Extracted from templates.ts and isg/deps.ts to eliminate duplication.
- */
 /**
  * Determines if the given page is a collection index page.
  * A collection index page is one whose URL matches a directory path that contains other pages.
  *
+ * Rendering and ISG dependency tracking must both call this with the same page list,
+ * otherwise they can pick different layouts for the same page.
+ *
+ * Page URLs are read once per `allPages` array, at the first call; see
+ * `directoryPrefixCache` for when changes to the pages are picked up.
+ *
  * @param page - The page to check
- * @param allPages - All pages in the site (optional for simplified check)
+ * @param allPages - All pages in the site (treated as unchanging after the first call)
  * @returns True if the page is a collection index page
  */
-export declare function isCollectionIndexPage(page: PageModel, allPages?: PageModel[]): boolean;
+export declare function isCollectionIndexPage(page: PageModel, allPages: PageModel[]): boolean;
 /**
  * Discovers layout files by searching up the directory hierarchy.
  * Supports both explicit layout specification and automatic discovery.

package/dist/core/utils/template-discovery.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-discovery.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-discovery.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAInE;;;GAGG;AAEH;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,OAAO,CAkBtF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBhE"}
+{"version":3,"file":"template-discovery.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-discovery.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAoDnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAUrF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBhE"}

package/dist/core/utils/template-discovery.utils.js

@@ -3,15 +3,51 @@ import { pathExists } from './fs.utils.js';
 import { LAYOUT_TEMPLATE } from '../../constants.js';
 import { resolveSrcDir } from './paths.utils.js';
 /**
- * Shared template discovery utilities.
- * Extracted from templates.ts and isg/deps.ts to eliminate duplication.
+ * Directory prefix index per page list, so a build computes it once instead of
+ * scanning every page for every page.
+ *
+ * The index is a snapshot of the page URLs taken at the first lookup for a given array,
+ * and every later lookup for that array reuses it. In a build the first lookup happens
+ * in the render loop, after the `beforeAll` hook, so URL changes made there are included.
+ * Changes made to the same array or its pages after that are not seen; a fresh build
+ * loads a new array and gets a new snapshot. Taking one snapshot keeps rendering and
+ * ISG dependency tracking in agreement for the whole build.
  */
+const directoryPrefixCache = new WeakMap();
+function getDirectoryPrefixIndex(allPages) {
+    const cached = directoryPrefixCache.get(allPages);
+    if (cached) {
+        return cached;
+    }
+    const index = new Map();
+    for (const { url } of allPages) {
+        // Every prefix ending at a '/' is a directory this URL lives in (or is, for trailing-slash URLs)
+        for (let i = url.indexOf('/'); i !== -1; i = url.indexOf('/', i + 1)) {
+            const prefix = url.slice(0, i + 1);
+            const existing = index.get(prefix);
+            if (existing === undefined) {
+                index.set(prefix, url);
+            }
+            else if (existing !== null && existing !== url) {
+                index.set(prefix, null);
+            }
+        }
+    }
+    directoryPrefixCache.set(allPages, index);
+    return index;
+}
 /**
  * Determines if the given page is a collection index page.
  * A collection index page is one whose URL matches a directory path that contains other pages.
  *
+ * Rendering and ISG dependency tracking must both call this with the same page list,
+ * otherwise they can pick different layouts for the same page.
+ *
+ * Page URLs are read once per `allPages` array, at the first call; see
+ * `directoryPrefixCache` for when changes to the pages are picked up.
+ *
  * @param page - The page to check
- * @param allPages - All pages in the site (optional for simplified check)
+ * @param allPages - All pages in the site (treated as unchanging after the first call)
  * @returns True if the page is a collection index page
  */
 export function isCollectionIndexPage(page, allPages) {
@@ -19,15 +55,10 @@ export function isCollectionIndexPage(page, allPages) {
     if (page.url === '/') {
         return true;
     }
-    // If we have all pages, do a proper check
-    if (allPages) {
-        // Check if this page's URL is a directory path that contains other pages
-        const pageUrlAsDir = page.url.endsWith('/') ? page.url : page.url + '/';
-        return allPages.some((otherPage) => otherPage.url !== page.url && otherPage.url.startsWith(pageUrlAsDir));
-    }
-    // Simplified version when we don't have all pages
-    // Assume any page ending in /index or at root is a collection page
-    return page.url.endsWith('/index') || page.slug === 'index';
+    // The page is an index when a different page's URL lives under this page's URL as a directory
+    const pageUrlAsDir = page.url.endsWith('/') ? page.url : page.url + '/';
+    const containingUrl = getDirectoryPrefixIndex(allPages).get(pageUrlAsDir);
+    return containingUrl === null || (containingUrl !== undefined && containingUrl !== page.url);
 }
 /**
  * Discovers layout files by searching up the directory hierarchy.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stati/core",
-  "version": "1.27.1",
+  "version": "1.27.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",