honkit 6.1.4 → 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/__tests__/watch.test.d.ts

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

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

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

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

@@ -0,0 +1,194 @@
+"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 watch_1 = __importDefault(require("../watch"));
+/**
+ * Normalize path separators to forward slashes for cross-platform comparison
+ */
+function normalizePath(filepath) {
+    return filepath.replace(/\\/g, "/");
+}
+describe("watch", () => {
+    // Increase timeout for file system operations (Windows may need more time)
+    jest.setTimeout(30000);
+    let tempDir;
+    let watchers = [];
+    beforeEach(() => {
+        tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "honkit-watch-test-"));
+    });
+    afterEach(async () => {
+        // Close all watchers
+        await Promise.all(watchers.map((w) => w.close()));
+        watchers = [];
+        // Cleanup temp directory
+        if (tempDir && fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    function createFile(relativePath, content = "# Test") {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    function modifyFile(relativePath, content) {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    /**
+     * Wait for watcher to be ready and stable
+     */
+    async function waitForReady(watcher) {
+        await new Promise((resolve) => {
+            watcher.on("ready", resolve);
+        });
+        // Give the watcher a moment to stabilize after ready event
+        // Windows needs more time for file system operations
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    /**
+     * Wait for a file change to be detected that matches the predicate
+     * Paths are normalized to forward slashes for cross-platform compatibility
+     */
+    function waitForChange(watcher, predicate, timeoutMs = 20000) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Timeout waiting for file change after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const handler = (_event, filepath) => {
+                const fullPath = normalizePath(path_1.default.resolve(tempDir, filepath));
+                if (predicate(fullPath)) {
+                    clearTimeout(timeout);
+                    watcher.off("all", handler);
+                    resolve(fullPath);
+                }
+            };
+            watcher.on("all", handler);
+        });
+    }
+    describe("issue #491 - custom output folder handling", () => {
+        it("should detect changes in custom output folder when not specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITHOUT specifying output folder
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify file in output folder and wait for detection
+            modifyFile("output/orphan.md", "# Modified");
+            const detected = await waitForChange(watcher, (f) => f.includes("output/orphan.md"));
+            expect(detected).toContain("output/orphan.md");
+        });
+        it("should NOT detect changes in custom output folder when specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITH output folder specified - it should be ignored
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: "output",
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files - output should be ignored, README should be detected
+            modifyFile("output/orphan.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change to be detected (proves watcher is working)
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify output folder change was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+        it("should handle absolute output folder paths", async () => {
+            createFile("README.md", "# README");
+            createFile("docs-output/file.md", "# File");
+            const detectedFiles = [];
+            const absoluteOutputPath = path_1.default.join(tempDir, "docs-output");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: absoluteOutputPath,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files
+            modifyFile("docs-output/file.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify docs-output was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("docs-output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+    });
+    describe("default _book folder", () => {
+        it("should NOT detect changes in _book folder", async () => {
+            createFile("file1.md", "# File 1");
+            createFile("file2.md", "# File 2");
+            createFile("_book/output.md", "# Output");
+            const detectedFiles = [];
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // First modify file1 to ensure watcher is working
+            modifyFile("file1.md", "# Modified File 1");
+            await waitForChange(watcher, (f) => f.includes("file1.md"));
+            // Now modify _book file (should be ignored)
+            modifyFile("_book/output.md", "# Modified");
+            // Modify file2 to confirm watcher still works
+            modifyFile("file2.md", "# Modified File 2");
+            await waitForChange(watcher, (f) => f.includes("file2.md"));
+            // Verify _book was NOT detected
+            const bookChanges = detectedFiles.filter((f) => f.includes("_book"));
+            expect(bookChanges).toHaveLength(0);
+        });
+    });
+    describe("source files", () => {
+        it("should detect changes to markdown files in source directory", async () => {
+            createFile("README.md", "# README");
+            createFile("orphan.md", "# Orphan - not in SUMMARY");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: () => { }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            modifyFile("orphan.md", "# Modified orphan");
+            const detected = await waitForChange(watcher, (f) => f.includes("orphan.md"));
+            expect(detected).toContain("orphan.md");
+        });
+    });
+});

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":";;;;;;;;;;;;;;;;;;;;;;;AA4IA,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", () => {
@@ -62,51 +72,57 @@ function startServer(args, kwargs) {
             return waitForCtrlC();
         }
         // update book immutably. does not use book again
-        return (0, watch_1.default)(book.getRoot(), (error, filepath) => {
-            if (error) {
-                console.error(error);
-                return;
-            }
-            // If the file does not exist in file system, show a warning and skip
-            // Probably, the file has been deleted
-            if (!fs_1.default.existsSync(filepath)) {
-                logger.warn.ok(`${filepath} does not exist in file system.`);
-                return;
-            }
-            // set livereload path
-            lrPath = filepath;
-            // TODO: use parse extension
-            // Incremental update for pages
-            if (lastOutput && filepath.endsWith(".md")) {
-                logger.warn.ok("Rebuild " + filepath);
-                const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
-                    incrementalChangeFileSet: immutable_1.default.Set([filepath])
-                });
-                return incrementalBuild({
-                    output: changedOutput,
-                    Generator
-                }).then(() => {
-                    if (lrPath && hasLiveReloading) {
-                        // trigger livereload
-                        lrServer.changed({
-                            body: {
-                                files: [lrPath]
-                            }
-                        });
-                    }
+        // Pass outputFolder to watch to prevent infinite rebuild loops
+        // https://github.com/honkit/honkit/issues/491
+        (0, watch_1.default)({
+            watchDir: book.getRoot(),
+            outputFolder,
+            callback: (error, filepath, eventType) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                // If the file does not exist in file system, show a warning and skip
+                // Probably, the file has been deleted
+                if (!fs_1.default.existsSync(filepath)) {
+                    logger.warn.ok(`${filepath} does not exist in file system.`);
+                    return;
+                }
+                // set livereload path
+                lrPath = filepath;
+                // 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])
+                    });
+                    return incrementalBuild({
+                        output: changedOutput,
+                        Generator
+                    }).then(() => {
+                        if (hasLiveReloading)
+                            triggerLiveReload();
+                    });
+                }
+                // 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,
+                    hasLiveReloading,
+                    Generator,
+                    reload
+                }).then((output) => {
+                    lastOutput = output;
+                    if (hasLiveReloading)
+                        triggerLiveReload();
                 });
             }
-            // Asciidoc files are not supported for incremental build
-            logger.info.ok("Rebuild " + filepath);
-            return generateBook({
-                book,
-                outputFolder,
-                hasLiveReloading,
-                Generator,
-                reload
-            }).then((output) => {
-                lastOutput = output;
-            });
         });
     });
 }

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,10 +1,30 @@
+import { FSWatcher } from "chokidar";
+export type WatchEventType = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+export interface WatchOptions {
+    /**
+     * Directory to watch
+     */
+    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, eventType?: WatchEventType) => void;
+    /**
+     * Output folder to ignore (in addition to _book and node_modules)
+     * This prevents infinite rebuild loops when using custom output folders
+     * @see https://github.com/honkit/honkit/issues/491
+     */
+    outputFolder?: string;
+}
 /**
- Watch a folder and resolve promise once a file is modified
-
- @param {string} dir
- @param callback
- @return {Promise}
+ * Watch a folder and call callback when a file is modified
+ *
+ * @param {WatchOptions} options
+ * @return {FSWatcher} The chokidar watcher instance
  */
-declare function watch(dir: any, callback: any): void;
+declare function watch(options: WatchOptions): FSWatcher;
 export default watch;
 //# sourceMappingURL=watch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,iBAAS,KAAK,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,QAwB3B;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

@@ -7,31 +7,45 @@ const path_1 = __importDefault(require("path"));
 const chokidar_1 = __importDefault(require("chokidar"));
 const parsers_1 = __importDefault(require("../parsers"));
 /**
- Watch a folder and resolve promise once a file is modified
-
- @param {string} dir
- @param callback
- @return {Promise}
+ * Watch a folder and call callback when a file is modified
+ *
+ * @param {WatchOptions} options
+ * @return {FSWatcher} The chokidar watcher instance
  */
-function watch(dir, callback) {
-    dir = path_1.default.resolve(dir);
+function watch(options) {
+    const { callback, outputFolder } = options;
+    const dir = path_1.default.resolve(options.watchDir);
     const toWatch = ["book.json", "book.js", "_layouts/**"];
     // Watch all parsable files
     parsers_1.default.extensions.forEach((ext) => {
         toWatch.push(`**/*${ext}`);
     });
+    // Build ignored patterns
+    // Always ignore _book and node_modules
+    // https://github.com/honkit/honkit/issues/269
+    const ignored = ["_book/**", "node_modules/**"];
+    // If a custom output folder is specified, ignore it too
+    // This prevents infinite rebuild loops when output folder is inside the watched directory
+    // https://github.com/honkit/honkit/issues/491
+    if (outputFolder) {
+        // Convert to forward slashes for glob pattern (Windows compatibility)
+        const outputRelative = path_1.default.relative(dir, path_1.default.resolve(dir, outputFolder)).replace(/\\/g, "/");
+        // Only add to ignored if the output folder is inside the watched directory
+        if (outputRelative && !outputRelative.startsWith("..") && !path_1.default.isAbsolute(outputRelative)) {
+            ignored.push(`${outputRelative}/**`);
+        }
+    }
     const watcher = chokidar_1.default.watch(toWatch, {
         cwd: dir,
-        // prevent infinity loop
-        // https://github.com/honkit/honkit/issues/269
-        ignored: ["_book/**", "node_modules/**"],
+        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);
     });
+    return watcher;
 }
 exports.default = watch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honkit",
-  "version": "6.1.4",
+  "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.4",
-    "@honkit/honkit-plugin-fontsettings": "6.1.4",
-    "@honkit/honkit-plugin-theme-default": "6.1.4",
-    "@honkit/honkit-plugin-highlight": "6.1.4",
-    "@honkit/html": "6.1.4",
-    "@honkit/markdown-legacy": "6.1.4"
+    "@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.4"
+    "@honkit/internal-test-utils": "6.1.6"
   },
   "scripts": {
     "build": "tsc -p .",