honkit 6.1.5 → 6.1.6

package/lib/cli/__tests__/build-integration.test.d.ts

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

package/lib/cli/__tests__/build-integration.test.d.ts.map

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

package/lib/cli/__tests__/build-integration.test.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const bin_1 = require("../../bin");
+const internal_test_utils_1 = require("@honkit/internal-test-utils");
+/**
+ * Integration tests for honkit build output
+ *
+ * These tests use bin.run to execute the CLI and verify:
+ * 1. New files added to SUMMARY.md are correctly generated
+ * 2. Assets not in SUMMARY.md are copied correctly
+ * 3. Output structure matches expected snapshot
+ *
+ * This is a black-box test that only checks input (book files) and output (generated files).
+ */
+jest.setTimeout(60000);
+describe("build integration", () => {
+    let tempDir;
+    let outputDir;
+    beforeEach(() => {
+        tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "honkit-build-test-"));
+        outputDir = path_1.default.join(tempDir, "_book");
+    });
+    afterEach(() => {
+        if (tempDir && fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    function createBookStructure() {
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, "README.md"), `# Test Book
+
+Welcome to the test book.
+`);
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+`);
+    }
+    async function buildBook() {
+        await (0, bin_1.run)([process.argv[0], "honkit", "build", tempDir, outputDir, "--reload"]);
+    }
+    function getOutputFiles() {
+        if (!fs_1.default.existsSync(outputDir))
+            return [];
+        const files = [];
+        const walk = (dir, prefix = "") => {
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    walk(path_1.default.join(dir, entry.name), relativePath);
+                }
+                else {
+                    files.push(relativePath);
+                }
+            }
+        };
+        walk(outputDir);
+        return files.sort();
+    }
+    describe("build output with bin.run", () => {
+        it("should generate index.html for README.md", async () => {
+            createBookStructure();
+            await buildBook();
+            const files = getOutputFiles();
+            expect(files).toContain("index.html");
+        });
+        it("should generate chapter page when added to SUMMARY.md", async () => {
+            createBookStructure();
+            // Add chapter
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "chapter1.md"), `# Chapter 1
+
+This is chapter 1.
+`);
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+* [Chapter 1](chapter1.md)
+`);
+            await buildBook();
+            const files = getOutputFiles();
+            expect(files).toContain("index.html");
+            expect(files).toContain("chapter1.html");
+        });
+        it("should copy asset file not in SUMMARY.md", async () => {
+            createBookStructure();
+            // Add asset file (not in SUMMARY)
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "notes.md"), `# Notes
+
+These are my notes.
+`);
+            await buildBook();
+            const files = getOutputFiles();
+            expect(files).toContain("index.html");
+            expect(files).toContain("notes.md"); // Copied as asset
+        });
+        it("should match expected output structure", async () => {
+            createBookStructure();
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "chapter1.md"), `# Chapter 1
+
+Content of chapter 1.
+`);
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+* [Chapter 1](chapter1.md)
+`);
+            await buildBook();
+            const files = getOutputFiles();
+            // Filter out gitbook files and search index for cleaner snapshot
+            const relevantFiles = files.filter((f) => !f.startsWith("gitbook/") && !f.includes("search_index") && !f.includes("lunr"));
+            expect(relevantFiles).toMatchSnapshot("output-structure");
+        });
+        it("should generate correct HTML content", async () => {
+            createBookStructure();
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "chapter1.md"), `# Chapter 1
+
+Content of chapter 1.
+`);
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+* [Chapter 1](chapter1.md)
+`);
+            await buildBook();
+            // Use iterateDirectoryContents like snapshot-honkit.ts
+            const maskContent = (content) => {
+                return content
+                    .replace(/gitbook\.page\.hasChanged\(.*\);/g, "")
+                    .replace(/<meta name="generator" content="HonKit .*">/g, "")
+                    .replace(tempDir, "<TEMP_DIR>");
+            };
+            for await (const item of (0, internal_test_utils_1.iterateDirectoryContents)({
+                baseDir: outputDir,
+                allowExtensions: [".html"],
+                maskContent
+            })) {
+                // Only snapshot key pages, not all gitbook assets
+                if (item.filePath === "index.html" || item.filePath === "chapter1.html") {
+                    expect(item).toMatchSnapshot(item.filePath);
+                }
+            }
+        });
+    });
+});

package/lib/cli/__tests__/getOutputFolder.test.d.ts

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

package/lib/cli/__tests__/getOutputFolder.test.d.ts.map

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

package/lib/cli/__tests__/getOutputFolder.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const getOutputFolder_1 = __importDefault(require("../getOutputFolder"));
+describe("getOutputFolder", () => {
+    // Use platform-appropriate absolute paths for testing
+    const bookRoot = path_1.default.resolve("/book/root");
+    const absoluteOutput = path_1.default.resolve("/absolute/output");
+    describe("relative output path", () => {
+        it("should resolve relative to book root", () => {
+            const result = (0, getOutputFolder_1.default)([bookRoot, "./output"]);
+            expect(result).toBe(path_1.default.join(bookRoot, "output"));
+        });
+        it("should resolve relative path without ./ prefix", () => {
+            const result = (0, getOutputFolder_1.default)([bookRoot, "dist"]);
+            expect(result).toBe(path_1.default.join(bookRoot, "dist"));
+        });
+    });
+    describe("absolute output path", () => {
+        it("should preserve absolute path as-is", () => {
+            const result = (0, getOutputFolder_1.default)([bookRoot, absoluteOutput]);
+            expect(result).toBe(absoluteOutput);
+        });
+    });
+    describe("default output folder", () => {
+        it("should use _book in book root when no output specified", () => {
+            const result = (0, getOutputFolder_1.default)([bookRoot]);
+            expect(result).toBe(path_1.default.join(bookRoot, "_book"));
+        });
+        it("should use _book in cwd when no args", () => {
+            const result = (0, getOutputFolder_1.default)([]);
+            expect(result).toBe(path_1.default.join(process.cwd(), "_book"));
+        });
+    });
+});

package/lib/cli/__tests__/serve-integration.test.d.ts

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

package/lib/cli/__tests__/serve-integration.test.d.ts.map

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

package/lib/cli/__tests__/serve-integration.test.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+/**
+ * Integration tests for honkit serve rebuild behavior
+ *
+ * These tests verify that:
+ * 1. SUMMARY.md changes trigger full rebuild and generate new pages
+ * 2. New file additions are detected and processed
+ *
+ * This is a black-box test that starts serve, modifies files, and checks output.
+ */
+jest.setTimeout(60000);
+describe("serve integration", () => {
+    let tempDir;
+    let outputDir;
+    let serveProcess = null;
+    beforeEach(() => {
+        tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "honkit-serve-test-"));
+        outputDir = path_1.default.join(tempDir, "_book");
+    });
+    afterEach(async () => {
+        // Kill serve process
+        if (serveProcess && !serveProcess.killed) {
+            serveProcess.kill("SIGKILL");
+            await new Promise((resolve) => {
+                serveProcess?.on("exit", resolve);
+                setTimeout(resolve, 1000);
+            });
+        }
+        serveProcess = null;
+        // Cleanup temp directory
+        if (tempDir && fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    function createBookStructure() {
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, "README.md"), `# Test Book
+
+Welcome to the test book.
+`);
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+`);
+    }
+    function getOutputFiles() {
+        if (!fs_1.default.existsSync(outputDir))
+            return [];
+        const files = [];
+        const walk = (dir, prefix = "") => {
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    walk(path_1.default.join(dir, entry.name), relativePath);
+                }
+                else {
+                    files.push(relativePath);
+                }
+            }
+        };
+        walk(outputDir);
+        return files.sort();
+    }
+    function startServe() {
+        return new Promise((resolve, reject) => {
+            const binPath = path_1.default.resolve(__dirname, "../../../bin/honkit.js");
+            // Use port 0 to let OS assign an available port
+            serveProcess = (0, child_process_1.spawn)(process.execPath, [binPath, "serve", tempDir, outputDir, "--port", "0", "--lrport", "0"], {
+                stdio: ["pipe", "pipe", "pipe"],
+                env: { ...process.env }
+            });
+            let started = false;
+            const checkStarted = (output) => {
+                if (output.includes("Serving book on") && !started) {
+                    started = true;
+                    // Wait a bit for initial build to complete
+                    setTimeout(resolve, 1000);
+                }
+            };
+            serveProcess.stdout?.on("data", (data) => {
+                checkStarted(data.toString());
+            });
+            serveProcess.stderr?.on("data", (data) => {
+                // HonKit outputs to stderr for info/warn
+                checkStarted(data.toString());
+            });
+            serveProcess.on("error", reject);
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (!started) {
+                    reject(new Error("Timeout waiting for serve to start"));
+                }
+            }, 10000);
+        });
+    }
+    function waitForFile(filePath, timeoutMs = 15000) {
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const check = () => {
+                if (fs_1.default.existsSync(filePath)) {
+                    resolve();
+                }
+                else if (Date.now() - startTime > timeoutMs) {
+                    reject(new Error(`Timeout waiting for file: ${filePath}`));
+                }
+                else {
+                    setTimeout(check, 200);
+                }
+            };
+            check();
+        });
+    }
+    describe("file watching and rebuild", () => {
+        it("should generate new page when SUMMARY.md is updated during serve", async () => {
+            createBookStructure();
+            await startServe();
+            // Verify initial build - only index.html
+            expect(getOutputFiles()).toContain("index.html");
+            expect(getOutputFiles()).not.toContain("chapter1.html");
+            // Add chapter1.md
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "chapter1.md"), `# Chapter 1
+
+This is chapter 1.
+`);
+            // Update SUMMARY.md to include chapter1
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "SUMMARY.md"), `# Summary
+
+* [Introduction](README.md)
+* [Chapter 1](chapter1.md)
+`);
+            // Wait for rebuild
+            await waitForFile(path_1.default.join(outputDir, "chapter1.html"));
+            // Verify chapter1.html was generated
+            expect(getOutputFiles()).toContain("chapter1.html");
+        });
+        it("should copy new asset file when added during serve", async () => {
+            createBookStructure();
+            await startServe();
+            // Verify initial state
+            expect(getOutputFiles()).not.toContain("notes.md");
+            // Add new asset file (not in SUMMARY.md)
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, "notes.md"), `# Notes
+
+These are my notes.
+`);
+            // Wait for the asset to be copied
+            await waitForFile(path_1.default.join(outputDir, "notes.md"));
+            // Verify asset was copied
+            expect(getOutputFiles()).toContain("notes.md");
+        });
+    });
+});

package/lib/cli/__tests__/shouldFullRebuild.test.d.ts

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

package/lib/cli/__tests__/shouldFullRebuild.test.d.ts.map

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

package/lib/cli/__tests__/shouldFullRebuild.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shouldFullRebuild_1 = require("../shouldFullRebuild");
+describe("shouldFullRebuild", () => {
+    describe("structure files (change event)", () => {
+        it("should return true for SUMMARY.md change", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/SUMMARY.md", "change")).toBe(true);
+        });
+        it("should return true for SUMMARY.md (case insensitive)", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/summary.md", "change")).toBe(true);
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/Summary.md", "change")).toBe(true);
+        });
+        it("should return true for GLOSSARY.md change", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/GLOSSARY.md", "change")).toBe(true);
+        });
+        it("should return true for book.json change", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/book.json", "change")).toBe(true);
+        });
+        it("should return true for book.js change", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/book.js", "change")).toBe(true);
+        });
+    });
+    describe("new file additions (add event)", () => {
+        it("should return true for any new file", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/newfile.md", "add")).toBe(true);
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/image.png", "add")).toBe(true);
+        });
+        it("should return true for new structure files", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/SUMMARY.md", "add")).toBe(true);
+        });
+    });
+    describe("file deletions (unlink event)", () => {
+        it("should return true for any deleted file", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/deleted.md", "unlink")).toBe(true);
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/image.png", "unlink")).toBe(true);
+        });
+        it("should return true for deleted structure files", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/SUMMARY.md", "unlink")).toBe(true);
+        });
+    });
+    describe("content files (change event)", () => {
+        it("should return false for regular markdown file changes", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/README.md", "change")).toBe(false);
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/chapter1.md", "change")).toBe(false);
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/docs/page.md", "change")).toBe(false);
+        });
+        it("should return false for files with SUMMARY in path but different name", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/SUMMARY/page.md", "change")).toBe(false);
+        });
+    });
+    describe("without eventType (backwards compatibility)", () => {
+        it("should return true for structure files", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/SUMMARY.md")).toBe(true);
+        });
+        it("should return false for regular files", () => {
+            expect((0, shouldFullRebuild_1.shouldFullRebuild)("/path/to/book/README.md")).toBe(false);
+        });
+    });
+});
+describe("isStructureFile", () => {
+    it("should identify SUMMARY.md as structure file", () => {
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/SUMMARY.md")).toBe(true);
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/summary.md")).toBe(true);
+    });
+    it("should identify GLOSSARY.md as structure file", () => {
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/GLOSSARY.md")).toBe(true);
+    });
+    it("should identify book.json as structure file", () => {
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/book.json")).toBe(true);
+    });
+    it("should identify book.js as structure file", () => {
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/book.js")).toBe(true);
+    });
+    it("should NOT identify regular files as structure files", () => {
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/README.md")).toBe(false);
+        expect((0, shouldFullRebuild_1.isStructureFile)("/path/to/chapter.md")).toBe(false);
+    });
+});

package/lib/cli/getOutputFolder.d.ts

@@ -4,6 +4,6 @@
  @param {Array} args
  @return {string}
  */
-declare function getOutputFolder(args: any): string;
+declare function getOutputFolder(args: any): any;
 export default getOutputFolder;
 //# sourceMappingURL=getOutputFolder.d.ts.map

package/lib/cli/getOutputFolder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOutputFolder.d.ts","sourceRoot":"","sources":["../../src/cli/getOutputFolder.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,iBAAS,eAAe,CAAC,IAAI,KAAA,UAM5B;AAED,eAAe,eAAe,CAAC"}
+{"version":3,"file":"getOutputFolder.d.ts","sourceRoot":"","sources":["../../src/cli/getOutputFolder.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,iBAAS,eAAe,CAAC,IAAI,KAAA,OAa5B;AAED,eAAe,eAAe,CAAC"}

package/lib/cli/getOutputFolder.js

@@ -13,7 +13,14 @@ const path_1 = __importDefault(require("path"));
 function getOutputFolder(args) {
     const bookRoot = path_1.default.resolve(args[0] || process.cwd());
     const defaultOutputRoot = path_1.default.join(bookRoot, "_book");
-    const outputFolder = args[1] ? path_1.default.resolve(process.cwd(), args[1]) : defaultOutputRoot;
+    // Fix: Resolve relative output folder paths against the book root (not process.cwd()).
+    // Absolute paths are preserved as-is. This ensures the output folder is correctly ignored
+    // by the file watcher. See: https://github.com/honkit/honkit/issues/491
+    const outputFolder = args[1]
+        ? path_1.default.isAbsolute(args[1])
+            ? args[1]
+            : path_1.default.resolve(bookRoot, args[1])
+        : defaultOutputRoot;
     return outputFolder;
 }
 exports.default = getOutputFolder;

package/lib/cli/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkJA,wBA6DE"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8JA,wBA6DE"}

package/lib/cli/serve.js

@@ -15,9 +15,19 @@ const getBook_1 = __importDefault(require("./getBook"));
 const getOutputFolder_1 = __importDefault(require("./getOutputFolder"));
 const server_1 = __importDefault(require("./server"));
 const watch_1 = __importDefault(require("./watch"));
+const shouldFullRebuild_1 = require("./shouldFullRebuild");
 const page_cache_1 = require("../output/page-cache");
 const fs_1 = __importDefault(require("fs"));
 let server, lrServer, lrPath;
+function triggerLiveReload() {
+    if (lrPath) {
+        lrServer.changed({
+            body: {
+                files: [lrPath]
+            }
+        });
+    }
+}
 function waitForCtrlC() {
     const d = promise_1.default.defer();
     process.on("SIGINT", () => {
@@ -67,7 +77,7 @@ function startServer(args, kwargs) {
         (0, watch_1.default)({
             watchDir: book.getRoot(),
             outputFolder,
-            callback: (error, filepath) => {
+            callback: (error, filepath, eventType) => {
                 if (error) {
                     console.error(error);
                     return;
@@ -80,9 +90,12 @@ function startServer(args, kwargs) {
                 }
                 // set livereload path
                 lrPath = filepath;
-                // TODO: use parse extension
-                // Incremental update for pages
-                if (lastOutput && filepath.endsWith(".md")) {
+                // Full rebuild is required for:
+                // 1. Structure files (SUMMARY.md, GLOSSARY.md, book.json, book.js)
+                // 2. New file additions (to update asset list and page structure)
+                const needsFullRebuild = (0, shouldFullRebuild_1.shouldFullRebuild)(filepath, eventType);
+                // Incremental update for existing pages (only for .md files that don't require full rebuild)
+                if (lastOutput && filepath.endsWith(".md") && !needsFullRebuild) {
                     logger.warn.ok("Rebuild " + filepath);
                     const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
                         incrementalChangeFileSet: immutable_1.default.Set([filepath])
@@ -91,18 +104,13 @@ function startServer(args, kwargs) {
                         output: changedOutput,
                         Generator
                     }).then(() => {
-                        if (lrPath && hasLiveReloading) {
-                            // trigger livereload
-                            lrServer.changed({
-                                body: {
-                                    files: [lrPath]
-                                }
-                            });
-                        }
+                        if (hasLiveReloading)
+                            triggerLiveReload();
                     });
                 }
-                // Asciidoc files are not supported for incremental build
-                logger.info.ok("Rebuild " + filepath);
+                // Full rebuild for structure changes, new files, or non-markdown files
+                const reason = needsFullRebuild ? " (full rebuild)" : "";
+                logger.info.ok("Rebuild " + filepath + reason);
                 return generateBook({
                     book,
                     outputFolder,
@@ -111,6 +119,8 @@ function startServer(args, kwargs) {
                     reload
                 }).then((output) => {
                     lastOutput = output;
+                    if (hasLiveReloading)
+                        triggerLiveReload();
                 });
             }
         });

package/lib/cli/shouldFullRebuild.d.ts

@@ -0,0 +1,26 @@
+import type { WatchEventType } from "./watch";
+/**
+ * Determine if a file change requires a full rebuild based on the file path
+ *
+ * Full rebuild is needed when:
+ * - SUMMARY.md is changed (book structure changed)
+ * - GLOSSARY.md is changed (glossary definitions changed)
+ * - book.json or book.js is changed (configuration changed)
+ *
+ * @param filepath - The absolute path of the changed file
+ * @returns true if full rebuild is needed, false for incremental build
+ */
+export declare function isStructureFile(filepath: string): boolean;
+/**
+ * Determine if a file change requires a full rebuild
+ *
+ * Full rebuild is needed when:
+ * - Structure files are changed (SUMMARY.md, GLOSSARY.md, book.json, book.js)
+ * - Files are added or removed (to update asset list and page structure)
+ *
+ * @param filepath - The absolute path of the changed file
+ * @param eventType - The type of file change event
+ * @returns true if full rebuild is needed, false for incremental build
+ */
+export declare function shouldFullRebuild(filepath: string, eventType?: WatchEventType): boolean;
+//# sourceMappingURL=shouldFullRebuild.d.ts.map

package/lib/cli/shouldFullRebuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldFullRebuild.d.ts","sourceRoot":"","sources":["../../src/cli/shouldFullRebuild.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,cAAc,GAAG,OAAO,CAQvF"}

package/lib/cli/shouldFullRebuild.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStructureFile = isStructureFile;
+exports.shouldFullRebuild = shouldFullRebuild;
+const path_1 = __importDefault(require("path"));
+/**
+ * Determine if a file change requires a full rebuild based on the file path
+ *
+ * Full rebuild is needed when:
+ * - SUMMARY.md is changed (book structure changed)
+ * - GLOSSARY.md is changed (glossary definitions changed)
+ * - book.json or book.js is changed (configuration changed)
+ *
+ * @param filepath - The absolute path of the changed file
+ * @returns true if full rebuild is needed, false for incremental build
+ */
+function isStructureFile(filepath) {
+    const filename = path_1.default.basename(filepath);
+    const lowerFilename = filename.toLowerCase();
+    // Structure files that require full rebuild
+    const structureFiles = ["summary.md", "glossary.md", "book.json", "book.js"];
+    return structureFiles.includes(lowerFilename);
+}
+/**
+ * Determine if a file change requires a full rebuild
+ *
+ * Full rebuild is needed when:
+ * - Structure files are changed (SUMMARY.md, GLOSSARY.md, book.json, book.js)
+ * - Files are added or removed (to update asset list and page structure)
+ *
+ * @param filepath - The absolute path of the changed file
+ * @param eventType - The type of file change event
+ * @returns true if full rebuild is needed, false for incremental build
+ */
+function shouldFullRebuild(filepath, eventType) {
+    // File additions or deletions always require full rebuild
+    if (eventType === "add" || eventType === "unlink") {
+        return true;
+    }
+    // Structure files require full rebuild
+    return isStructureFile(filepath);
+}

package/lib/cli/watch.d.ts

@@ -1,4 +1,5 @@
 import { FSWatcher } from "chokidar";
+export type WatchEventType = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
 export interface WatchOptions {
     /**
      * Directory to watch
@@ -6,8 +7,11 @@ export interface WatchOptions {
     watchDir: string;
     /**
      * Callback when a file is modified
+     * @param error - Error if any
+     * @param filepath - Absolute path of the changed file
+     * @param eventType - Type of change: "add", "change", "unlink", etc.
      */
-    callback: (error: Error | null, filepath?: string) => void;
+    callback: (error: Error | null, filepath?: string, eventType?: WatchEventType) => void;
     /**
      * Output folder to ignore (in addition to _book and node_modules)
      * This prevents infinite rebuild loops when using custom output folders

package/lib/cli/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AACA,OAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,iBAAS,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CA0C/C;AAED,eAAe,KAAK,CAAC"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AACA,OAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;AAElF,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACvF;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,iBAAS,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CA0C/C;AAED,eAAe,KAAK,CAAC"}

package/lib/cli/watch.js

@@ -40,8 +40,8 @@ function watch(options) {
         ignored: ignored,
         ignoreInitial: true
     });
-    watcher.on("all", (e, filepath) => {
-        callback(null, path_1.default.resolve(dir, filepath));
+    watcher.on("all", (eventType, filepath) => {
+        callback(null, path_1.default.resolve(dir, filepath), eventType);
     });
     watcher.on("error", (err) => {
         callback(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honkit",
-  "version": "6.1.5",
+  "version": "6.1.6",
   "description": "HonKit is building beautiful books using Markdown.",
   "keywords": [
     "git",
@@ -74,12 +74,12 @@
     "tiny-lr": "^1.1.1",
     "tmp": "0.2.4",
     "urijs": "^1.19.11",
-    "@honkit/asciidoc": "6.1.5",
-    "@honkit/honkit-plugin-fontsettings": "6.1.5",
-    "@honkit/honkit-plugin-highlight": "6.1.5",
-    "@honkit/honkit-plugin-theme-default": "6.1.5",
-    "@honkit/markdown-legacy": "6.1.5",
-    "@honkit/html": "6.1.5"
+    "@honkit/honkit-plugin-highlight": "6.1.6",
+    "@honkit/honkit-plugin-fontsettings": "6.1.6",
+    "@honkit/html": "6.1.6",
+    "@honkit/markdown-legacy": "6.1.6",
+    "@honkit/asciidoc": "6.1.6",
+    "@honkit/honkit-plugin-theme-default": "6.1.6"
   },
   "devDependencies": {
     "@relmify/jest-serializer-strip-ansi": "^1.0.2",
@@ -90,7 +90,7 @@
     "jest-mock-process": "^2.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.2",
-    "@honkit/internal-test-utils": "6.1.5"
+    "@honkit/internal-test-utils": "6.1.6"
   },
   "scripts": {
     "build": "tsc -p .",