@stati/core 1.29.2 → 2.0.1

package/dist/core/dev.js

@@ -6,11 +6,12 @@ import { build } from './build.js';
 import { invalidate } from './invalidate.js';
 import { loadConfig } from '../config/loader.js';
 import { clearTemplateEngineCache } from './templates.js';
+import { startTemplateIndexSession, endTemplateIndexSession, getCachedTemplateIndex, toTemplateFile, } from './template-index.js';
 import { clearMarkdownProcessorCache } from './markdown.js';
-import { loadCacheManifest, saveCacheManifest, DevServerLockManager } from './isg/index.js';
-import { resolveDevPaths, resolveCacheDir, resolvePrettyUrl, resolveRequestFile, resolveNotFoundPage, getMimeType, parseRequestPath, createErrorOverlay, parseErrorDetails, TemplateError, createFallbackLogger, mergeServerOptions, createTypeScriptWatcher, isEnabledEnvFlag, refreshCssOutputWatcher, normalizePathForComparison, assertPortAvailable, toPortUnavailableError, } from './utils/index.js';
+import { loadCacheManifest, saveCacheManifest, hasRecordedTemplates, DevServerLockManager, } from './isg/index.js';
+import { resolveDevPaths, resolveCacheDir, resolvePrettyUrl, resolveRequestFile, resolveNotFoundPage, getMimeType, parseRequestPath, createErrorOverlay, parseErrorDetails, TemplateError, FrontMatterError, createFallbackLogger, mergeServerOptions, createTypeScriptWatcher, isEnabledEnvFlag, refreshCssOutputWatcher, normalizePathForComparison, assertPortAvailable, toPortUnavailableError, } from './utils/index.js';
 import { setEnv, getEnv } from '../env.js';
-import { DEFAULT_DEV_PORT, DEFAULT_DEV_HOST, TEMPLATE_EXTENSION, DEFAULT_OUT_DIR, } from '../constants.js';
+import { DEFAULT_DEV_PORT, DEFAULT_DEV_HOST, DEFAULT_OUT_DIR } from '../constants.js';
 /**
  * Loads and validates configuration for the dev server.
  */
@@ -67,6 +68,7 @@ async function performInitialBuild(configPath, logger, onError) {
  * @param eventType - The type of change: 'add', 'change', or 'unlink'
  * @param configPath - Optional path to the stati config file
  * @param staticDir - The static assets directory path
+ * @param srcDir - The source directory path, whose `.eta` files are templates
  * @param logger - Logger instance for output
  * @param wsServer - WebSocket server for live reload notifications
  * @param isBuildingRef - Mutable reference tracking whether a build is currently in progress
@@ -75,9 +77,11 @@ async function performInitialBuild(configPath, logger, onError) {
  *   ensuring each file is only processed once with its most recent event type.
  * @param onError - Optional callback invoked when build errors occur
  * @param onBuildEnd - Optional callback invoked after each build attempt finishes (success or failure)
+ * @param hasBuildError - Whether the last build failed, so a template change rebuilds even when
+ *   no recorded page uses the template
  * @param batchedChanges - Array of changes to process in a single batch (used for pending queue processing)
  */
-async function performIncrementalRebuild(changedPath, eventType, configPath, staticDir, logger, wsServer, isBuildingRef, pendingChangesRef, onError, onBuildEnd, batchedChanges = []) {
+async function performIncrementalRebuild(changedPath, eventType, configPath, staticDir, srcDir, logger, wsServer, isBuildingRef, pendingChangesRef, onError, onBuildEnd, hasBuildError, batchedChanges = []) {
     // If a build is in progress, queue this change for processing after the current build
     if (isBuildingRef.value) {
         pendingChangesRef.changes.set(changedPath, eventType);
@@ -121,45 +125,51 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
     const getRelativePath = (path) => path.replace(process.cwd(), '').replace(/\\/g, '/').replace(/^\//, '');
     // Track template change result for better output
     let templateChangeResult = null;
+    // Templates are .eta files in the source directory; other files are content or static assets
+    const isTemplate = (path) => toTemplateFile(srcDir, path) !== null;
+    const templateChanges = allChanges.filter((change) => isTemplate(change.path));
+    const otherChanges = allChanges.filter((change) => !isTemplate(change.path));
     try {
-        // Check if the changed file is a template/partial
-        if (changedPath.endsWith(TEMPLATE_EXTENSION) || changedPath.includes('_partials')) {
-            // Use progress-enabled logger for template changes (rebuilds multiple pages)
-            const devLogger = createDevLogger(true);
-            templateChangeResult = await handleTemplateChange(changedPath, configPath, devLogger);
+        let rebuild = 'none';
+        if (templateChanges.length > 0) {
+            templateChangeResult = await markTemplateChanges(templateChanges, srcDir, hasBuildError?.() ?? false);
+            rebuild = templateChangeResult.rebuild;
         }
-        else if (changedPath.endsWith('.md')) {
-            const devLogger = createDevLogger(false);
-            await handleMarkdownChange(changedPath, configPath, devLogger);
+        // Markdown and static files: ISG decides what re-renders, such as the pages that list a
+        // changed page through a collection; the build also removes a deleted page's output
+        if (otherChanges.length > 0 && rebuild === 'none') {
+            rebuild = 'incremental';
         }
-        else {
-            // Static file changed - use normal rebuild
-            const devLogger = createDevLogger(false);
+        if (rebuild !== 'none') {
             await build({
-                logger: devLogger,
-                force: false,
+                // Progress output for template changes, which can rebuild many pages
+                logger: createDevLogger(templateChanges.length > 0),
+                force: rebuild === 'full',
                 clean: false,
+                // Template changes don't affect static assets
+                ...(otherChanges.length === 0 && { skipAssetCopy: true }),
                 ...(configPath && { configPath }),
             });
-        }
-        // Clear any previous errors on successful build
-        if (onError) {
-            onError(null);
-        }
-        // Notify all connected clients to reload
-        if (wsServer) {
-            wsServer.clients.forEach((client) => {
-                const ws = client;
-                if (ws.readyState === 1) {
-                    // WebSocket.OPEN
-                    ws.send(JSON.stringify({ type: 'reload' }));
-                }
-            });
+            // Clear any previous errors on successful build
+            if (onError) {
+                onError(null);
+            }
+            // Notify all connected clients to reload
+            if (wsServer) {
+                wsServer.clients.forEach((client) => {
+                    const ws = client;
+                    if (ws.readyState === 1) {
+                        // WebSocket.OPEN
+                        ws.send(JSON.stringify({ type: 'reload' }));
+                    }
+                });
+            }
         }
         const duration = Date.now() - startTime;
         // Log rebuild result with affected page info for template changes
         for (const change of allChanges) {
             const relativePath = getRelativePath(change.path);
+            const template = templateChanges.includes(change);
             let action;
             if (change.eventType === 'unlink') {
                 action = 'deleted';
@@ -167,17 +177,30 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
             else if (isStaticAsset(change.path)) {
                 action = 'copied';
             }
+            else if (template) {
+                action = change.eventType === 'add' ? 'added' : 'changed';
+            }
             else {
                 action = 'rebuilt';
             }
+            logger.info?.(`▸ ${relativePath} ${action}`);
             // For template changes, include affected page count
-            if (templateChangeResult && templateChangeResult.affectedPages > 0) {
+            if (template && templateChangeResult && rebuild !== 'none') {
                 const { affectedPages, totalPages } = templateChangeResult;
-                logger.info?.(`▸ ${relativePath} ${action}`);
-                logger.info?.(`   ${affectedPages}/${totalPages} pages rebuilt in ${duration}ms`);
+                if (templateChangeResult.rebuild === 'full') {
+                    logger.info?.(`   All pages rebuilt in ${duration}ms`);
+                }
+                else if (affectedPages > 0) {
+                    logger.info?.(`   ${affectedPages}/${totalPages} pages rebuilt in ${duration}ms`);
+                }
+                else {
+                    logger.info?.(`   Done in ${duration}ms`);
+                }
+            }
+            else if (template) {
+                logger.info?.(change.eventType === 'unlink' ? '   No page used it' : '   No page uses it');
             }
             else {
-                logger.info?.(`▸ ${relativePath} ${action}`);
                 logger.info?.(`   Done in ${duration}ms`);
             }
         }
@@ -206,127 +229,119 @@ async function performIncrementalRebuild(changedPath, eventType, configPath, sta
             // Get all pending changes - the build will process all of them at once
             const pendingChanges = Array.from(pendingChangesRef.changes.entries()).map(([path, evtType]) => ({ path, eventType: evtType }));
             pendingChangesRef.changes.clear();
-            // Trigger another rebuild with all batched changes
-            // The build() call will copy all static assets and rebuild all affected pages
+            // Trigger another rebuild with all batched changes: every template change in the batch
+            // updates the template index and marks its pages, then one build runs
             const [first, ...remaining] = pendingChanges;
             if (first) {
-                void performIncrementalRebuild(first.path, first.eventType, configPath, staticDir, logger, wsServer, isBuildingRef, pendingChangesRef, onError, onBuildEnd, remaining);
+                void performIncrementalRebuild(first.path, first.eventType, configPath, staticDir, srcDir, logger, wsServer, isBuildingRef, pendingChangesRef, onError, onBuildEnd, hasBuildError, remaining);
             }
         }
     }
 }
 /**
- * Handles template/partial file changes by invalidating affected pages.
- * Uses proper path normalization to ensure reliable matching between
- * file watcher paths and cached dependency paths.
+ * Applies template changes before a rebuild. Pages record the templates they rendered and the
+ * names they looked up, so for each changed `.eta` file:
+ * - change: the pages that rendered it rebuild; when none did, no page uses it.
+ * - add: the template index learns the file, and the pages whose lookups now find it rebuild,
+ *   such as the pages a new section override applies to.
+ * - unlink: the index forgets the file, and the pages that rendered or found it rebuild.
+ *
+ * Affected entries are marked stale in the saved manifest. Entries without recorded templates
+ * cannot say which pages use a file, so they get a forced full build.
  *
- * @returns Object with affected and total page counts
+ * @param lastBuildFailed - Whether the previous build failed; then a build runs even when no
+ *   recorded page uses the file, so the error clears once the template that broke it is fixed
  */
-async function handleTemplateChange(templatePath, configPath, logger) {
-    const cacheDir = resolveCacheDir();
+async function markTemplateChanges(changes, srcDir, lastBuildFailed) {
+    // Drop the cached Eta engine so the changed templates are recompiled on the next build.
+    // Markdown-only edits keep reusing it.
+    clearTemplateEngineCache();
+    // Keep the template index that dev builds reuse in step with the files
+    const index = getCachedTemplateIndex(srcDir);
+    for (const change of changes) {
+        const file = toTemplateFile(srcDir, change.path);
+        if (index && file) {
+            if (change.eventType === 'add') {
+                index.add(file);
+            }
+            else if (change.eventType === 'unlink') {
+                index.remove(file);
+            }
+        }
+    }
     try {
-        // Drop the cached Eta engine so the changed template (and any compiled partials)
-        // are recompiled on the next build. This keeps rebuilds correct while still
-        // reusing the engine across the common markdown-only edit path.
-        clearTemplateEngineCache();
-        // Load existing cache manifest
+        const cacheDir = resolveCacheDir();
         const cacheManifest = await loadCacheManifest(cacheDir);
         if (!cacheManifest) {
-            // No cache exists, perform full rebuild
-            await build({
-                logger,
-                force: false,
-                clean: false,
-                ...(configPath && { configPath }),
-            });
-            return { affectedPages: 0, totalPages: 0 };
+            return { affectedPages: 0, totalPages: 0, rebuild: 'incremental' };
         }
-        // Normalize the changed template path to absolute POSIX format for reliable comparison
-        // This handles cases where the watcher provides relative paths, Windows paths, or different
-        // path representations than what's stored in the cache manifest
-        // NOTE: Only used for string comparison, never for file system operations
-        const normalizedTemplatePath = normalizePathForComparison(templatePath);
-        // Get total page count from manifest
-        const totalPages = Object.keys(cacheManifest.entries).length;
-        // Find pages that depend on this template
-        let affectedPagesCount = 0;
-        for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
-            // Check if any of the page's dependencies match the changed template
-            const hasMatchingDep = entry.deps.some((dep) => {
-                // Normalize the cached dependency path to the same format for comparison only
-                const normalizedDep = normalizePathForComparison(dep);
-                // Direct path comparison - both paths are now in consistent format
-                return normalizedDep === normalizedTemplatePath;
-            });
-            if (hasMatchingDep) {
-                affectedPagesCount++;
-                // Mark entry as stale by invalidating its inputsHash
-                // This forces a rebuild while preserving deps for fast update optimization
-                cacheManifest.entries[pagePath] = {
-                    ...entry,
-                    inputsHash: 'STALE', // Forces rebuild in shouldRebuildPage
-                };
+        const entries = Object.entries(cacheManifest.entries);
+        const totalPages = entries.length;
+        if (entries.some(([, entry]) => !hasRecordedTemplates(entry))) {
+            return { affectedPages: totalPages, totalPages, rebuild: 'full' };
+        }
+        // Normalized for comparison only: watcher paths and manifest paths can differ in form
+        const changedFiles = new Set(changes.map((change) => normalizePathForComparison(change.path)));
+        const filesAddedOrRemoved = changes.some((change) => change.eventType !== 'change');
+        let affectedPages = 0;
+        for (const [pagePath, entry] of entries) {
+            const renderedChangedFile = entry.deps.some((dep) => changedFiles.has(normalizePathForComparison(dep)));
+            const lookupsChanged = filesAddedOrRemoved && index !== null && index.lookupsChanged(entry.templateLookups);
+            if (renderedChangedFile || lookupsChanged) {
+                affectedPages++;
+                // Forces a rebuild in shouldRebuildPage
+                cacheManifest.entries[pagePath] = { ...entry, inputsHash: 'STALE' };
             }
         }
-        if (affectedPagesCount > 0) {
-            // Save updated cache manifest
+        if (affectedPages > 0) {
             await saveCacheManifest(cacheDir, cacheManifest);
-            // Perform incremental rebuild (only affected pages will be rebuilt)
-            // skipManifestSave: true because we already saved the manifest above
-            // skipAssetCopy: true because template changes don't affect static assets
-            await build({
-                logger,
-                force: false,
-                clean: false,
-                skipManifestSave: true,
-                skipAssetCopy: true,
-                ...(configPath && { configPath }),
-            });
-            return { affectedPages: affectedPagesCount, totalPages };
+            return { affectedPages, totalPages, rebuild: 'incremental' };
         }
-        else {
-            // If no affected pages were found but a template changed,
-            // force a full rebuild to ensure changes are reflected
-            // This can happen if dependency tracking missed something
-            await build({
-                logger,
-                force: true,
-                clean: false,
-                ...(configPath && { configPath }),
-            });
-            return { affectedPages: totalPages, totalPages };
+        // Before the session has an index, the build's own checks find the pages a new or deleted
+        // file affects
+        if ((filesAddedOrRemoved && index === null) || lastBuildFailed) {
+            return { affectedPages: 0, totalPages, rebuild: 'incremental' };
         }
+        return { affectedPages: 0, totalPages, rebuild: 'none' };
     }
-    catch (_error) {
-        try {
-            // Fallback to full rebuild
-            await build({
-                logger,
-                force: false,
-                clean: false,
-                ...(configPath && { configPath }),
-            });
-        }
-        catch (fallbackError) {
-            throw fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
-        }
-        // Return zeros on error fallback
-        return { affectedPages: 0, totalPages: 0 };
+    catch {
+        // Let the build's own checks decide
+        return { affectedPages: 0, totalPages: 0, rebuild: 'incremental' };
     }
 }
 /**
- * Handles markdown file changes (added, edited or deleted pages) with an incremental build.
- * ISG decides what re-renders: the changed page, the pages that list it through a collection,
- * and the pages that read the navigation when the change altered it. A deleted page's output
- * is removed by the build.
+ * The error overlay's details for a failed build: template errors point at the template and
+ * front matter errors at the Markdown file; other errors are classified by their message.
  */
-async function handleMarkdownChange(_markdownPath, configPath, logger) {
-    await build({
-        logger,
-        force: false,
-        clean: false,
-        ...(configPath && { configPath }),
-    });
+async function describeBuildError(error) {
+    if (error instanceof TemplateError) {
+        return error.toErrorDetails();
+    }
+    if (error instanceof FrontMatterError) {
+        // The file and line are the Markdown file's, not a stack frame's
+        const { line: _line, column: _column, ...details } = parseErrorDetails(error, 'markdown', error.filePath);
+        return {
+            ...details,
+            ...(error.line !== undefined && { line: error.line }),
+            ...(error.column !== undefined && { column: error.column }),
+        };
+    }
+    const message = error.message.toLowerCase();
+    const name = error.name ? error.name.toLowerCase() : '';
+    const errorType = message.includes('template') ||
+        message.includes('eta') ||
+        message.includes('layout') ||
+        name.includes('template')
+        ? 'template'
+        : message.includes('front-matter') ||
+            message.includes('yaml') ||
+            name.includes('yaml') ||
+            name.includes('yamlexception')
+            ? 'markdown'
+            : message.includes('config') || name.includes('config')
+                ? 'config'
+                : 'build';
+    return parseErrorDetails(error, errorType);
 }
 export async function createDevServer(options = {}) {
     const logger = options.logger ?? createFallbackLogger();
@@ -356,6 +371,7 @@ export async function createDevServer(options = {}) {
     const setLastBuildError = (error) => {
         lastBuildError = error;
     };
+    const hasLastBuildError = () => lastBuildError !== null;
     let watcher = null;
     let cssWatcher = null;
     let tsWatchers = [];
@@ -405,31 +421,7 @@ export async function createDevServer(options = {}) {
         // If there's a build error, show error overlay for HTML requests
         if (errorToShow &&
             (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.'))) {
-            let errorDetails;
-            // Use enhanced error details for TemplateError instances
-            if (errorToShow instanceof TemplateError) {
-                errorDetails = await errorToShow.toErrorDetails();
-            }
-            else {
-                // Determine error type based on error message
-                const message = errorToShow.message.toLowerCase();
-                const name = errorToShow.name ? errorToShow.name.toLowerCase() : '';
-                const errorType = message.includes('template') ||
-                    message.includes('eta') ||
-                    message.includes('layout') ||
-                    name.includes('template')
-                    ? 'template'
-                    : message.includes('front-matter') ||
-                        message.includes('yaml') ||
-                        name.includes('yaml') ||
-                        name.includes('yamlexception')
-                        ? 'markdown'
-                        : message.includes('config') || name.includes('config')
-                            ? 'config'
-                            : 'build';
-                errorDetails = parseErrorDetails(errorToShow, errorType);
-            }
-            const errorHtml = createErrorOverlay(errorDetails, requestPath);
+            const errorHtml = createErrorOverlay(await describeBuildError(errorToShow), requestPath);
             return {
                 content: errorHtml,
                 mimeType: 'text/html',
@@ -448,41 +440,6 @@ export async function createDevServer(options = {}) {
         // Use the shared pretty URL resolver
         const { filePath, found } = await resolvePrettyUrl(outDir, requestPath, requestFile);
         if (!found || !filePath) {
-            // If we have a build error and this is an HTML request, show error overlay instead of 404
-            const errorToShow = lastBuildError;
-            if (errorToShow &&
-                (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.'))) {
-                // Use enhanced error details for TemplateError instances
-                let errorDetails;
-                if (errorToShow instanceof TemplateError) {
-                    errorDetails = await errorToShow.toErrorDetails();
-                }
-                else {
-                    // Determine error type based on error message
-                    const message = errorToShow.message.toLowerCase();
-                    const name = errorToShow.name ? errorToShow.name.toLowerCase() : '';
-                    const errorType = message.includes('template') ||
-                        message.includes('eta') ||
-                        message.includes('layout') ||
-                        name.includes('template')
-                        ? 'template'
-                        : message.includes('front-matter') ||
-                            message.includes('yaml') ||
-                            name.includes('yaml') ||
-                            name.includes('yamlexception')
-                            ? 'markdown'
-                            : message.includes('config') || name.includes('config')
-                                ? 'config'
-                                : 'build';
-                    errorDetails = parseErrorDetails(errorToShow, errorType);
-                }
-                const errorHtml = createErrorOverlay(errorDetails, requestPath);
-                return {
-                    content: errorHtml,
-                    mimeType: 'text/html',
-                    statusCode: 500,
-                };
-            }
             // Serve the site's 404 page, as static hosts do, with live reload so it updates on edits
             const notFoundPage = await resolveNotFoundPage(outDir);
             if (notFoundPage) {
@@ -582,7 +539,8 @@ export async function createDevServer(options = {}) {
                     console.log();
                 }
             }
-            // Perform initial build
+            // Rebuilds reuse one template index, which the file watcher keeps current
+            startTemplateIndexSession(srcDir);
             await performInitialBuild(configPath, logger, setLastBuildError);
             // Create HTTP server
             httpServer = createServer(async (req, res) => {
@@ -687,13 +645,13 @@ export async function createDevServer(options = {}) {
                 }
             }
             watcher.on('change', (path) => {
-                void performIncrementalRebuild(path, 'change', configPath, staticDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher);
+                void performIncrementalRebuild(path, 'change', configPath, staticDir, srcDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher, hasLastBuildError);
             });
             watcher.on('add', (path) => {
-                void performIncrementalRebuild(path, 'add', configPath, staticDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher);
+                void performIncrementalRebuild(path, 'add', configPath, staticDir, srcDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher, hasLastBuildError);
             });
             watcher.on('unlink', (path) => {
-                void performIncrementalRebuild(path, 'unlink', configPath, staticDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher);
+                void performIncrementalRebuild(path, 'unlink', configPath, staticDir, srcDir, logger, disableWsReload ? null : wsServer, isBuildingRef, pendingChangesRef, setLastBuildError, disableCssWatcher ? undefined : refreshCssWatcher, hasLastBuildError);
             });
             logger.success?.(`Dev server running at ${url}`);
             logger.info?.(`\nServing:`);
@@ -757,6 +715,7 @@ export async function createDevServer(options = {}) {
             }
             // Release cached dev-session engines so they can be garbage collected
             clearTemplateEngineCache();
+            endTemplateIndexSession(srcDir);
             clearMarkdownProcessorCache();
             logger.info?.('Dev server stopped');
         },

package/dist/core/eta-plugin.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 type { Eta, EtaConfig } from 'eta';
+type EtaPlugin = EtaConfig['plugins'][number];
+/**
+ * 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 declare 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. */
+declare const ETA_FUNCTIONS: readonly [{
+    readonly name: "include";
+    readonly declaration: "let include = ";
+}, {
+    readonly name: "includeAsync";
+    readonly declaration: "let includeAsync = ";
+}, {
+    readonly name: "layout";
+    readonly declaration: "function layout(path, data) {\n  __eta.layout = path;\n  __eta.layoutData = data;\n}";
+}, {
+    readonly name: "block";
+    readonly declaration: "function block(";
+}, {
+    readonly name: "blockAsync";
+    readonly declaration: "async function blockAsync(";
+}];
+/** One of Eta's template functions that Stati blocks. */
+export type BlockedEtaFunction = (typeof ETA_FUNCTIONS)[number]['name'];
+/**
+ * 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 declare function createStatiEtaPlugin(): EtaPlugin;
+/**
+ * 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 declare function installEtaPlugin(eta: Eta): void;
+/**
+ * The message for a blocked call, and the replacement to suggest.
+ */
+export declare function describeBlockedCall(name: BlockedEtaFunction, args: readonly unknown[]): {
+    message: string;
+    suggestion: string;
+};
+export {};
+//# sourceMappingURL=eta-plugin.d.ts.map

package/dist/core/eta-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eta-plugin.d.ts","sourceRoot":"","sources":["../../src/core/eta-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAK1C,KAAK,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAG9C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,yFACqD,CAAC;AAEzF,yFAAyF;AACzF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;EAMT,CAAC;AAEX,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAUxE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,SAAS,CAgChD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAG/C;AAqBD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CA8BzC"}