@stati/core 1.29.2 → 2.0.0

package/dist/core/eta-plugin.js

@@ -0,0 +1,143 @@
+/**
+ * Stati's Eta plugin. Eta compiles every template with functions of its own: `include()`,
+ * `includeAsync()`, `layout()`, `block()` and `blockAsync()`. They resolve names their own way,
+ * skip validation and the template index, and a template reached through Eta's `layout()`
+ * inherits its child's `stati`. Stati templates compose with `stati.include()` and
+ * `stati.layout()`, so the plugin replaces Eta's functions in each compiled template with ones
+ * that report the Stati call to use.
+ * @module core/eta-plugin
+ */
+import { isDevelopment } from '../env.js';
+import { TemplateUsageError } from './utils/index.js';
+import { getRenderScope } from './template-render.js';
+/**
+ * Eta's declaration of its `layout()` function. The plugin checks for it: when Eta generates
+ * different code, creating the engine fails instead of templates silently getting Eta's
+ * functions back.
+ */
+export const ETA_LAYOUT_DECLARATION = 'function layout(path, data) {\n  __eta.layout = path;\n  __eta.layoutData = data;\n}';
+/** Eta's template functions that Stati replaces, and the code that declares each one. */
+const ETA_FUNCTIONS = [
+    { name: 'include', declaration: 'let include = ' },
+    { name: 'includeAsync', declaration: 'let includeAsync = ' },
+    { name: 'layout', declaration: ETA_LAYOUT_DECLARATION },
+    { name: 'block', declaration: 'function block(' },
+    { name: 'blockAsync', declaration: 'async function blockAsync(' },
+];
+/** Marks the start of the template's own code in the compiled function. */
+const BODY_START = '/*@stati:template-body@*/';
+/** Property of the engine through which compiled templates report a blocked call. */
+const BLOCKED_CALL_HANDLER = '__statiBlockedEtaCall';
+/**
+ * Creates the plugin. The replacements go at the start of the template's code rather than
+ * next to Eta's declarations, because with `debug` on Eta declares `block()` inside a `try`
+ * block, where a replacement made outside it would be shadowed. The template's code then runs
+ * in a block of its own, so it can still declare names such as `block` or `output`, which
+ * would otherwise clash with Eta's declarations.
+ */
+export function createStatiEtaPlugin() {
+    return {
+        processAST(ast) {
+            const lineNo = ast.reduce((line, node) => typeof node === 'object' && node.lineNo !== undefined ? node.lineNo : line, 1);
+            const start = { t: 'e', val: BODY_START, lineNo: 1 };
+            const end = { t: 'e', val: '}', lineNo };
+            return [start, ...ast, end];
+        },
+        processFnString(fnString) {
+            if (!fnString.includes(ETA_LAYOUT_DECLARATION) || !fnString.includes(BODY_START)) {
+                throw new Error("Stati could not find Eta's layout() function in a compiled template, so it cannot block Eta's own include(), layout() and block(). This Eta version is not supported; install the version @stati/core depends on.");
+            }
+            // The names are the identifiers listed in ETA_FUNCTIONS, so they need no escaping
+            const replacements = ETA_FUNCTIONS.filter(({ declaration }) => fnString.includes(declaration))
+                .map(({ name }) => `${name} = (...__statiArgs) => this.${BLOCKED_CALL_HANDLER}('${name}', __statiArgs, options && options.filepath);`)
+                .join(' ');
+            // With debug on, Eta marks each tag's line with `__eta.line=N` and no semicolon, so a tag
+            // that starts with `(`, `[` or a template literal would continue that statement
+            return fnString
+                .replace(BODY_START, `${replacements} {`)
+                .replace(/__eta\.line=(\d+)\n/g, '__eta.line=$1;\n');
+        },
+    };
+}
+/**
+ * Installs the handler that the replaced functions call, and compiles an empty template so
+ * that an Eta version the plugin does not match fails here rather than on the first page.
+ *
+ * @throws {Error} When Eta's generated code lacks the declarations the plugin replaces
+ */
+export function installEtaPlugin(eta) {
+    eta[BLOCKED_CALL_HANDLER] = handleBlockedCall;
+    eta.compileToString('', { async: false });
+}
+/**
+ * The Stati call to suggest for a name passed to one of Eta's functions. It keeps Eta's
+ * resolution: a name without a leading `/`, `./` or `../` is relative to the calling template.
+ */
+function suggestedName(name) {
+    if (typeof name !== 'string') {
+        return 'path';
+    }
+    let path = name.replace(/\\/g, '/');
+    if (path.endsWith('.eta')) {
+        path = path.slice(0, -'.eta'.length);
+    }
+    if (!path.startsWith('/') && !path.startsWith('./') && !path.startsWith('../')) {
+        path = `./${path}`;
+    }
+    // Escaped for the single-quoted string of the suggested call
+    return path.replace(/[\\']/g, '\\$&');
+}
+/**
+ * The message for a blocked call, and the replacement to suggest.
+ */
+export function describeBlockedCall(name, args) {
+    const withData = args.length > 1 && args[1] !== undefined;
+    const target = suggestedName(args[0]);
+    switch (name) {
+        case 'include':
+        case 'includeAsync': {
+            const suggestion = `stati.include('${target}'${withData ? ', data' : ''})`;
+            const sync = name === 'includeAsync'
+                ? '; templates rendered by stati.include() render synchronously'
+                : '';
+            return {
+                message: `Eta's ${name}() is not available in Stati templates. Use ${suggestion} instead${sync}.`,
+                suggestion: `Use ${suggestion}`,
+            };
+        }
+        case 'layout': {
+            const suggestion = `stati.layout('${target}'${withData ? ', data' : ''})`;
+            return {
+                message: `Eta's layout() is not available in Stati templates. Use ${suggestion} instead; the data arrives as stati.props.`,
+                suggestion: `Use ${suggestion}`,
+            };
+        }
+        case 'block':
+        case 'blockAsync':
+            return {
+                message: `Eta's ${name}() is not available in Stati templates. Pass the content to the layout as a prop instead, such as stati.layout('base', { sidebar: html }).`,
+                suggestion: 'Pass the content to the layout as a prop',
+            };
+    }
+}
+/**
+ * Called by a compiled template for one of Eta's blocked functions. Development throws, so the
+ * error overlay points at the call; production logs the error and the call renders nothing.
+ */
+function handleBlockedCall(name, args, filepath) {
+    const { message, suggestion } = describeBlockedCall(name, args);
+    if (isDevelopment()) {
+        throw new TemplateUsageError(message, [suggestion]);
+    }
+    const scope = getRenderScope();
+    const where = filepath ? `${scope ? scope.displayPath(filepath) : filepath}: ` : '';
+    const page = scope ? ` (page ${scope.page.url})` : '';
+    const text = `${where}${message}${page}`;
+    if (scope) {
+        scope.logger.error(text);
+    }
+    else {
+        console.error(text);
+    }
+    return '';
+}

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

@@ -1,8 +1,10 @@
-import type { PageModel, CacheEntry, StatiConfig } from '../../types/index.js';
+import type { PageModel, CacheEntry, StatiConfig, TemplateLookup } from '../../types/index.js';
 import type { PageReads } from '../collections.js';
+import { TemplateIndex } from '../template-index.js';
 /**
- * What a render discovered: the source images a page displays (`assetDeps`), the generated
- * images it references (`images`) and the shared data it read (`reads`).
+ * What a render discovered: the templates it used (`templates`, `templateLookups`), the source
+ * images a page displays (`assetDeps`), the generated images it references (`images`) and the
+ * shared data it read (`reads`).
  */
 export interface RenderedAssets {
     /** Absolute paths of files whose content affects the page, such as source images */
@@ -11,6 +13,10 @@ export interface RenderedAssets {
     images: readonly string[];
     /** Whether the render read the collection and the navigation tree */
     reads?: PageReads | undefined;
+    /** Template files the render used, absolute POSIX paths, the page's layout first */
+    templates?: readonly string[] | undefined;
+    /** Template names the render looked up, with what each resolved to */
+    templateLookups?: readonly TemplateLookup[] | undefined;
 }
 /**
  * Whether a cache entry records what its page read while rendering. Entries written before
@@ -22,10 +28,23 @@ export interface RenderedAssets {
  * @returns True when `readsCollection` and `readsNav` are both recorded
  */
 export declare function hasRecordedReads(entry: CacheEntry): boolean;
+/**
+ * Whether a cache entry's templates and name lookups were recorded while its page rendered.
+ * An entry without them cannot tell when a template change affects its page, so the page is
+ * rebuilt once to record them.
+ *
+ * @param entry - The cache entry
+ * @returns True when `templatesRecorded` is set
+ */
+export declare function hasRecordedTemplates(entry: CacheEntry): boolean;
 /**
  * Determines if a page should be rebuilt based on ISG logic.
- * Checks content changes, dependency changes, TTL expiration, and freeze status.
- * Handles edge cases like missing dates, corrupted cache entries, and dependency errors.
+ * Checks content changes, the templates the last render recorded, the page's layout, TTL
+ * expiration, and freeze status. Handles edge cases like missing dates and corrupted entries.
+ *
+ * A cached page is stale when a template it rendered changed or no longer exists, when its
+ * layout would now be a different file, or when a template name it looked up would now
+ * resolve differently (checked against the template index, without reading files).
  *
  * @param page - The page model to check
  * @param entry - Existing cache entry, or undefined if not cached
@@ -33,6 +52,7 @@ export declare function hasRecordedReads(entry: CacheEntry): boolean;
  * @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
+ * @param templateIndex - The build's template index; read from the source directory when omitted
  * @returns True if the page should be rebuilt
  *
  * @example
@@ -43,43 +63,41 @@ export declare function hasRecordedReads(entry: CacheEntry): boolean;
  * }
  * ```
  */
-export declare function shouldRebuildPage(page: PageModel, entry: CacheEntry | undefined, config: StatiConfig, allPages: PageModel[], now: Date, renderInputsHash?: string): Promise<boolean>;
+export declare function shouldRebuildPage(page: PageModel, entry: CacheEntry | undefined, config: StatiConfig, allPages: PageModel[], now: Date, renderInputsHash?: string, templateIndex?: TemplateIndex): Promise<boolean>;
 /**
- * Creates a new cache entry for a page after it has been rendered.
+ * Creates a new cache entry for a page after it has been rendered, with the templates and name
+ * lookups the render recorded (`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
- * @param rendered - Files the render discovered, such as images
+ * @param rendered - What the render used: templates, lookups, images and shared data. Without
+ *   recorded templates the entry is not marked `templatesRecorded` and the page rebuilds next time.
  * @returns New cache entry
  *
  * @example
  * ```typescript
- * const entry = await createCacheEntry(page, config, pages, new Date());
+ * const entry = await createCacheEntry(page, config, new Date(), renderInputsHash, rendered);
  * ```
  */
-export declare function createCacheEntry(page: PageModel, config: StatiConfig, allPages: PageModel[], renderedAt: Date, renderInputsHash?: string, rendered?: RenderedAssets): Promise<CacheEntry>;
+export declare function createCacheEntry(page: PageModel, config: StatiConfig, renderedAt: Date, renderInputsHash?: string, rendered?: RenderedAssets): 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
- * template structure rarely changes between incremental rebuilds.
+ * Updates an existing cache entry after its page rendered again: a new entry from this
+ * render, keeping the original publish date when the page no longer sets one.
  *
  * @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
- * @param rendered - Files the render discovered, such as images
+ * @param rendered - What the render used: templates, lookups, images and shared data
  * @returns Updated cache entry
  *
  * @example
  * ```typescript
- * const updatedEntry = await updateCacheEntry(existingEntry, page, config, pages, new Date());
+ * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date(), hash, rendered);
  * ```
  */
-export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, allPages: PageModel[], renderedAt: Date, fastUpdate?: boolean, renderInputsHash?: string, rendered?: RenderedAssets): Promise<CacheEntry>;
+export declare function updateCacheEntry(entry: CacheEntry, page: PageModel, config: StatiConfig, renderedAt: Date, renderInputsHash?: string, rendered?: RenderedAssets): 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;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAsFnD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,oFAAoF;IACpF,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,kFAAkF;IAClF,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,qEAAqE;IACrE,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE3D;AAuDD;;;;;;;;;;;;;;;;;;;;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,CAuKlB;AAED;;;;;;;;;;;;;;;GAeG;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,EACzB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,UAAU,CAAC,CAmFrB;AAkDD;;;;;;;;;;;;;;;;;;;GAmBG;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,EACzB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,UAAU,CAAC,CAiErB"}
+{"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,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD,OAAO,EAAE,aAAa,EAAwB,MAAM,sBAAsB,CAAC;AA+E3E;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,oFAAoF;IACpF,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,kFAAkF;IAClF,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,qEAAqE;IACrE,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,oFAAoF;IACpF,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IAC1C,sEAAsE;IACtE,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS,CAAC;CACzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE3D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE/D;AAuDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;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,EACzB,aAAa,CAAC,EAAE,aAAa,GAC5B,OAAO,CAAC,OAAO,CAAC,CA+JlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,EAChB,gBAAgB,CAAC,EAAE,MAAM,EACzB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,UAAU,CAAC,CA0ErB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,EAChB,gBAAgB,CAAC,EAAE,MAAM,EACzB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,UAAU,CAAC,CASrB"}

package/dist/core/isg/builder.js

@@ -1,9 +1,9 @@
 import { computeContentHash, computeFileHash, computeBinaryFileHash, computeInputsHash, } from './hash.js';
-import { trackTemplateDependencies, resolveLayoutDependency } from './deps.js';
+import { resolveLayoutDependency } from './deps.js';
 import { computeEffectiveTTL, computeNextRebuildAt, isPageFrozen } from './ttl.js';
 import { validatePageISGOverrides, extractNumericOverride } from './validation.js';
-import { getFrontMatterDate } from '../utils/index.js';
-import { performance } from 'node:perf_hooks';
+import { getFrontMatterDate, normalizePathForComparison, resolveSrcDir } from '../utils/index.js';
+import { TemplateIndex, isTemplateLookupList } from '../template-index.js';
 /**
  * Determines the output path for a page.
  */
@@ -60,11 +60,14 @@ function isValidCacheEntry(entry) {
             return false;
         }
     }
-    for (const flag of [entry.readsCollection, entry.readsNav]) {
+    for (const flag of [entry.readsCollection, entry.readsNav, entry.templatesRecorded]) {
         if (flag !== undefined && typeof flag !== 'boolean') {
             return false;
         }
     }
+    if (entry.templateLookups !== undefined && !isTemplateLookupList(entry.templateLookups)) {
+        return false;
+    }
     return true;
 }
 /**
@@ -79,6 +82,17 @@ function isValidCacheEntry(entry) {
 export function hasRecordedReads(entry) {
     return typeof entry.readsCollection === 'boolean' && typeof entry.readsNav === 'boolean';
 }
+/**
+ * Whether a cache entry's templates and name lookups were recorded while its page rendered.
+ * An entry without them cannot tell when a template change affects its page, so the page is
+ * rebuilt once to record them.
+ *
+ * @param entry - The cache entry
+ * @returns True when `templatesRecorded` is set
+ */
+export function hasRecordedTemplates(entry) {
+    return entry.templatesRecorded === true;
+}
 /**
  * Tags a page's cache entry carries for `stati invalidate "tag:…"`: its front matter tags,
  * plus the key and label of a generated page, so `tag:css` also refreshes `/tags/css`.
@@ -125,8 +139,12 @@ function withRenderedAssets(entry, rendered) {
 }
 /**
  * Determines if a page should be rebuilt based on ISG logic.
- * Checks content changes, dependency changes, TTL expiration, and freeze status.
- * Handles edge cases like missing dates, corrupted cache entries, and dependency errors.
+ * Checks content changes, the templates the last render recorded, the page's layout, TTL
+ * expiration, and freeze status. Handles edge cases like missing dates and corrupted entries.
+ *
+ * A cached page is stale when a template it rendered changed or no longer exists, when its
+ * layout would now be a different file, or when a template name it looked up would now
+ * resolve differently (checked against the template index, without reading files).
  *
  * @param page - The page model to check
  * @param entry - Existing cache entry, or undefined if not cached
@@ -134,6 +152,7 @@ function withRenderedAssets(entry, rendered) {
  * @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
+ * @param templateIndex - The build's template index; read from the source directory when omitted
  * @returns True if the page should be rebuilt
  *
  * @example
@@ -144,7 +163,7 @@ function withRenderedAssets(entry, rendered) {
  * }
  * ```
  */
-export async function shouldRebuildPage(page, entry, config, allPages, now, renderInputsHash) {
+export async function shouldRebuildPage(page, entry, config, allPages, now, renderInputsHash, templateIndex) {
     if (config.isg?.enabled === false) {
         return true;
     }
@@ -158,46 +177,37 @@ export async function shouldRebuildPage(page, entry, config, allPages, now, rend
             console.warn(`Invalid cache entry for ${page.url}, forcing rebuild`);
             return true;
         }
-        // Check if inputs (content + dependencies) have changed
-        const currentContentHash = computeContentHash(page.content, page.frontMatter);
-        // Track dependencies with error handling
-        let deps;
-        try {
-            deps = await trackTemplateDependencies(page, config, allPages);
+        // Entries from before templates were recorded while rendering rebuild once to record them
+        if (!hasRecordedTemplates(entry)) {
+            return true;
         }
-        catch (error) {
-            if (error instanceof Error && error.name === 'CircularDependencyError') {
-                console.error(`Circular dependency detected for ${page.url}: ${error.message}`);
-                throw error; // Re-throw circular dependency errors as they're fatal
-            }
-            // For other dependency errors, log warning and assume dependencies changed
-            console.warn(`Failed to track dependencies for ${page.url}: ${error instanceof Error ? error.message : String(error)}`);
-            console.warn('Assuming dependencies changed, forcing rebuild');
+        const index = templateIndex ?? (await TemplateIndex.load(resolveSrcDir(config)));
+        // The page can switch layouts without a template file changing, for example when a
+        // collection gains its first child page. deps[0] is the layout. A page without a layout
+        // renders Stati's fallback HTML; it always rebuilds, so a new layout.eta takes effect.
+        // Compared in normalized form: the drive letter's case follows the shell that ran the build.
+        const layout = resolveLayoutDependency(page, allPages, index);
+        const recordedLayout = entry.deps[0];
+        if (layout === null ||
+            recordedLayout === undefined ||
+            normalizePathForComparison(layout) !== normalizePathForComparison(recordedLayout)) {
             return true;
         }
-        // Compute hashes for all dependencies with error handling
+        // A name the page looked up would now find another template, such as a section override
+        // added at the same path, or a file that stati.include.has() did not find
+        if (index.lookupsChanged(entry.templateLookups)) {
+            return true;
+        }
+        // Check if inputs (content + dependencies) have changed
+        const currentContentHash = computeContentHash(page.content, page.frontMatter);
+        // Hash every template the page rendered; one that no longer exists rebuilds the page
         const depsHashes = [];
-        let dependencyErrors = 0;
-        for (const dep of deps) {
-            try {
-                const depHash = await computeFileHash(dep);
-                if (depHash) {
-                    depsHashes.push(depHash);
-                }
-                else {
-                    dependencyErrors++;
-                    console.warn(`Missing dependency file: ${dep} (used by ${page.url})`);
-                }
-            }
-            catch (error) {
-                dependencyErrors++;
-                console.warn(`Failed to hash dependency ${dep}: ${error instanceof Error ? error.message : String(error)}`);
+        for (const dep of entry.deps) {
+            const depHash = await computeFileHash(dep);
+            if (!depHash) {
+                return true;
             }
-        }
-        // If we had dependency errors, force rebuild to be safe
-        if (dependencyErrors > 0) {
-            console.warn(`${dependencyErrors} dependency errors for ${page.url}, forcing rebuild`);
-            return true;
+            depsHashes.push(depHash);
         }
         // Files found during the last render, such as images, are hashed by content
         depsHashes.push(...(await hashAssetDeps(entry.assetDeps)));
@@ -276,37 +286,28 @@ export async function shouldRebuildPage(page, entry, config, allPages, now, rend
     }
 }
 /**
- * Creates a new cache entry for a page after it has been rendered.
+ * Creates a new cache entry for a page after it has been rendered, with the templates and name
+ * lookups the render recorded (`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
- * @param rendered - Files the render discovered, such as images
+ * @param rendered - What the render used: templates, lookups, images and shared data. Without
+ *   recorded templates the entry is not marked `templatesRecorded` and the page rebuilds next time.
  * @returns New cache entry
  *
  * @example
  * ```typescript
- * const entry = await createCacheEntry(page, config, pages, new Date());
+ * const entry = await createCacheEntry(page, config, new Date(), renderInputsHash, rendered);
  * ```
  */
-export async function createCacheEntry(page, config, allPages, renderedAt, renderInputsHash, rendered) {
-    const timings = {};
-    let start = performance.now();
+export async function createCacheEntry(page, config, renderedAt, renderInputsHash, rendered) {
     // Validate page-level ISG overrides first
     validatePageISGOverrides(page.frontMatter, page.sourcePath);
-    timings.validate = performance.now() - start;
-    // Compute content hash
-    start = performance.now();
     const contentHash = computeContentHash(page.content, page.frontMatter);
-    timings.contentHash = performance.now() - start;
-    // Track all template dependencies
-    start = performance.now();
-    const deps = await trackTemplateDependencies(page, config, allPages);
-    timings.trackDeps = performance.now() - start;
-    // Compute hashes for all dependencies
-    start = performance.now();
+    // The templates the render used, the layout first
+    const deps = [...(rendered?.templates ?? [])];
     const depsHashes = [];
     for (const dep of deps) {
         const depHash = await computeFileHash(dep);
@@ -315,7 +316,6 @@ export async function createCacheEntry(page, config, allPages, renderedAt, rende
         }
     }
     depsHashes.push(...(await hashAssetDeps(rendered?.assetDeps)));
-    timings.depsHashes = performance.now() - start;
     const inputsHash = computeInputsHash(contentHash, depsHashes, renderInputsHash);
     // Extract tags from front matter
     const tags = getCacheTags(page);
@@ -343,6 +343,10 @@ export async function createCacheEntry(page, config, allPages, renderedAt, rende
         path: outputPath,
         inputsHash,
         deps,
+        ...(rendered?.templates && {
+            templateLookups: [...(rendered.templateLookups ?? [])],
+            templatesRecorded: true,
+        }),
         tags,
         renderedAt: renderedAt.toISOString(),
         ttlSeconds,
@@ -357,111 +361,24 @@ export async function createCacheEntry(page, config, allPages, renderedAt, rende
     return withRenderedAssets(cacheEntry, rendered);
 }
 /**
- * Checks if the template structure has changed by comparing the layout file's
- * modification time against when the cache entry was last rendered.
- * This detects when new includes/extends have been added to templates.
- *
- * @param entry - The existing cache entry
- * @returns True if template structure may have changed, false if structure is unchanged
- */
-async function hasTemplateStructureChanged(entry) {
-    try {
-        // If the entry has a layout in its deps, check if that layout file has been modified
-        // since the last render. Layout files are typically the first dep or contain the
-        // includes/extends declarations.
-        if (entry.deps.length === 0) {
-            return false;
-        }
-        // Get the timestamp of the last render
-        const lastRendered = new Date(entry.renderedAt).getTime();
-        // Import stat from node:fs/promises at runtime to avoid circular dependency issues
-        const { stat } = await import('node:fs/promises');
-        // Check if any template files (layout or partials) have been modified
-        // We only need to check the first few deps (usually layout and immediate includes)
-        // as a heuristic to detect structural changes without expensive full tracking
-        const depsToCheck = entry.deps.slice(0, 3);
-        for (const depPath of depsToCheck) {
-            try {
-                const stats = await stat(depPath);
-                if (stats.mtimeMs > lastRendered) {
-                    // Template file was modified after last render - structure may have changed
-                    return true;
-                }
-            }
-            catch (_error) {
-                // If we can't stat the file, assume it might have changed
-                return true;
-            }
-        }
-        return false;
-    }
-    catch (_error) {
-        // On any error, be conservative and assume structure changed
-        return true;
-    }
-}
-/**
- * Updates an existing cache entry with new information after rebuilding.
- * In dev mode, this is optimized to reuse the existing deps array since
- * template structure rarely changes between incremental rebuilds.
+ * Updates an existing cache entry after its page rendered again: a new entry from this
+ * render, keeping the original publish date when the page no longer sets one.
  *
  * @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
- * @param rendered - Files the render discovered, such as images
+ * @param rendered - What the render used: templates, lookups, images and shared data
  * @returns Updated cache entry
  *
  * @example
  * ```typescript
- * const updatedEntry = await updateCacheEntry(existingEntry, page, config, pages, new Date());
+ * const updatedEntry = await updateCacheEntry(existingEntry, page, config, new Date(), hash, rendered);
  * ```
  */
-export async function updateCacheEntry(entry, page, config, allPages, renderedAt, fastUpdate = false, renderInputsHash, rendered) {
-    // 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);
-        // 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
-            // Just update the content hash and timestamp, keep existing deps
-            const contentHash = computeContentHash(page.content, page.frontMatter);
-            // Compute hashes for existing dependencies (fast - files are cached)
-            const depsHashes = [];
-            for (const dep of entry.deps) {
-                const depHash = await computeFileHash(dep);
-                if (depHash) {
-                    depsHashes.push(depHash);
-                }
-            }
-            // Asset deps come from this render, not from the previous entry
-            depsHashes.push(...(await hashAssetDeps(rendered?.assetDeps)));
-            const inputsHash = computeInputsHash(contentHash, depsHashes, renderInputsHash);
-            return withRenderedAssets({
-                ...entry,
-                inputsHash,
-                // Front matter tags, and a generated page's label, can change without a layout change
-                tags: getCacheTags(page),
-                renderedAt: renderedAt.toISOString(),
-            }, rendered);
-        }
-    }
-    // Full update - create new entry and preserve original publishedAt
-    const newEntry = await createCacheEntry(page, config, allPages, renderedAt, renderInputsHash, rendered);
+export async function updateCacheEntry(entry, page, config, renderedAt, renderInputsHash, rendered) {
+    const newEntry = await createCacheEntry(page, config, renderedAt, renderInputsHash, rendered);
     // Preserve original publishedAt if no new one is specified
     if (!newEntry.publishedAt && entry.publishedAt) {
         newEntry.publishedAt = entry.publishedAt;