@slybridges/kiss 0.10.1 → 0.11.0

package/.claude/settings.local.json

@@ -2,9 +2,53 @@
   "permissions": {
     "allow": [
       "Bash(npx eslint:*)",
-      "Bash(grep:*)"
+      "Bash(grep:*)",
+      "Bash(node:*)",
+      "Bash(npm test:*)",
+      "Read(//private/tmp/**)",
+      "Bash(tee:*)",
+      "Bash(git checkout:*)",
+      "Bash(awk:*)",
+      "Bash(npm run test:coverage:*)",
+      "WebSearch",
+      "Bash(cat:*)",
+      "Bash(npx kiss build)",
+      "Bash(timeout 30 npm test:*)",
+      "Bash(chmod:*)",
+      "Bash(bash run-incremental-tests.sh:*)",
+      "Bash(wait)",
+      "Bash(timeout 10 node:*)",
+      "Bash(VERBOSITY=info node test/integration/incremental-runner.js:*)",
+      "Bash(npx kiss build:*)",
+      "Bash(VERBOSITY=error node test/integration/incremental-runner.js:*)",
+      "Bash(VERBOSITY=error node test/utils/incremental-runner.js:*)",
+      "Bash(VERBOSITY=error node test-utils/incremental-runner.js:*)",
+      "Bash(find:*)",
+      "Bash(VERBOSITY=info node:*)",
+      "Bash(npx prettier --write test-utils/ test/)",
+      "Bash(npm run validate:*)",
+      "Bash(npx prettier:*)",
+      "Bash(npm run lint:*)",
+      "Bash(npm run format:check:*)",
+      "Bash(npm run format:*)",
+      "Bash(gh pr view:*)",
+      "Bash(gh pr:*)",
+      "Bash(npm audit:*)",
+      "Bash(npm ls:*)",
+      "Bash(npm view:*)",
+      "WebFetch(domain:github.com)",
+      "Bash(npm info:*)",
+      "Bash(npm pack:*)",
+      "Bash(npm install:*)",
+      "Bash(gh issue view:*)",
+      "Bash(git -C /Users/sly/projects/kiss log --oneline -30)",
+      "Bash(git -C /Users/sly/projects/kiss diff package.json .github/workflows/ci.yml CLAUDE.md)",
+      "WebFetch(domain:www.npmjs.com)",
+      "Bash(npx @11ty/eleventy-dev-server:*)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:vite.dev)"
     ],
     "deny": [],
     "ask": []
   }
-}
+}

package/.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    # Run on all pull requests, regardless of the target branch
+    branches:
+      - "*"
+
+jobs:
+  test:
+    name: Test on Node.js ${{ matrix.node-version }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x, 22.x, 24.x]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linter
+        run: npm run lint
+
+      - name: Check code formatting
+        run: npm run format:check
+
+      - name: Run tests
+        run: npm test
+
+      - name: Run tests with coverage
+        if: matrix.node-version == '20.x'
+        run: npm run test:coverage

package/.prettierrc

@@ -1,3 +1,3 @@
 {
   "semi": false
-}
+}

package/CLAUDE.md

@@ -4,124 +4,163 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-KISS (Keep It Simple and Static) is a low-tech static site generator built with Node.js. It transforms markdown, HTML, JSON, and JavaScript content into static websites using Nunjucks templates.
+kiss (Keep It Simple and Static) is a low-tech static site generator built with Node.js. It transforms markdown, HTML, JSON, and JavaScript content into static websites using Nunjucks templates. Always refer to it as "kiss" (lowercase), not "KISS".
 
-## Development Commands
+## Commands
 
-### Build the site
 ```bash
-npx kiss build
-# Production build:
-NODE_ENV=production npx kiss build
+# Testing
+npm test                           # Run all tests (unit + integration)
+node --test test/unit/             # Run only unit tests
+node --test test/integration/      # Run only integration tests
+node --test test/unit/build.test.js  # Run a single test file
+npm run test:watch                 # Watch mode
+npm run test:coverage              # Coverage report
+
+# Code quality
+npm run lint                       # ESLint
+npm run format                     # Prettier (auto-fix)
+npm run validate                   # Both lint + format check
+
+# Build & dev
+npx kiss build                     # Full build
+NODE_ENV=production npx kiss build # Production build
+npx kiss start                     # Dev server with watch + auto-reload
+npx kiss watch --incremental       # Watch with incremental builds
+npx kiss build --verbosity=info    # Verbose logging (log|info|success|warn|error)
 ```
 
-### Development server with auto-reload
-```bash
-npx kiss start
-# Launches build, watches for changes, and auto-reloads browser
-```
+## Code Quality Protocol
+
+Before completing ANY task, always run on modified files:
 
-### Watch mode only (no server)
 ```bash
-npx kiss watch
-# Use --incremental flag for experimental incremental builds
+npx eslint <files-or-dirs> && npx prettier --write <files-or-dirs> && npm test
 ```
 
-### Serve only (no watch)
-```bash
-npx kiss serve
+## Code Conventions
+
+- **No semicolons** (Prettier config: `{ "semi": false }`)
+- **CommonJS modules** (`require`/`module.exports`)
+- **Node.js 20+** required
+- Async/await for asynchronous operations
+- Lodash for utility functions, fast-glob for file system operations
+
+## Architecture
+
+### Build Pipeline (`src/build.js`)
+
+The `build(options, lastBuild, version)` function is the entire pipeline. The same function handles both full builds and incremental rebuilds via `buildFlags`. It returns `{ context, config }` which becomes `lastBuild` for the next incremental rebuild.
+
+**Stages in order:**
+
+1. **Config load** — `loadConfig()` deep-clones `defaultConfig` then calls user's `kiss.config.js` function
+2. **`computeBuildFlags`** — determines which stages to run (all for full build, subset for incremental)
+3. **`loadLibs` hooks** — sets up nunjucks, marked, slugify onto `config.libs.*`
+4. **`preLoad` hooks**
+5. **`loadContent`** — scans files via fast-glob, runs `baseLoader` then specific loader. Files sorted index-first, post-last for proper cascade order
+6. **`postLoad` hooks**
+7. **`computeAllPagesData`** — multi-round computation loop resolving `kissDependencies` (up to `maxComputingRounds`: 10)
+8. **`buildPageIndexes`** — builds 6 Maps for O(1) lookups, stored as `context._pageIndexes`
+9. **`computeDataViews`** — populates `context.collections`, `context.categories`, etc.
+10. **`applyTransforms`** — per-page (`PAGE` scope) and global (`CONTEXT` scope) transforms
+11. **`writeStaticSite`** — dispatches pages to writers by `_meta.outputType`
+12. **`postWrite` hooks**
+
+### Data Cascade (Critical to Understand)
+
+The data cascade is the most sophisticated part of the codebase.
+
+**How it works:** `initialPageData` (`src/data/initialPageData.js`) defines page field defaults as **functions** (the `computeX` functions), not plain values. When `baseLoader` merges parent data into a child page, children inherit unevaluated compute functions from parents. `computeAllPagesData` then resolves these in multiple rounds.
+
+**`kissDependencies` mechanism:** Compute functions declare inter-page dependencies as static properties:
+
+```js
+computePermalink.kissDependencies = ["slug", ["_meta.parent", "permalink"]]
 ```
 
-### Linting and formatting
-```bash
-npx eslint .
-npx prettier --write .
-# Note: Prettier config uses no semicolons
+- A string dep = field on the same page
+- An array dep like `["_meta.parent", "permalink"]` = follow `_meta.parent` as a page ID, check `permalink` on that page
+
+If dependencies are still unresolved (still functions), the compute is deferred to the next round. `computePermalink` returns itself when parent's permalink isn't ready yet.
+
+**`_no_cascade` convention:** A field named `foo_no_cascade` prevents `foo` from cascading to children. The `_no_cascade` variant replaces the normal key for that page only.
+
+**Cascade scoping:** `post.md`/`post.js` data sets data on the collection page but does NOT cascade to sibling pages. Only `index.*` file data cascades to children.
+
+### Config System
+
+**`kiss.config.js` is a function, not an object.** It receives a mutable `baseConfig` (deep-cloned from defaults) and returns it:
+
+```js
+module.exports = (config) => {
+  config.context.site.url = "https://example.com"
+  return config
+}
 ```
 
-## Architecture
+`config.addPlugin(fn, options)` calls `fn(config, options)` for plugin-style extension.
 
-### Build Pipeline
+**Namespaced options:** Loaders/transforms/writers declare a `namespace` string. Users override defaults via top-level config keys (e.g., `config.image.widths = [...]`).
 
-The build process (`src/build.js`) follows this lifecycle:
+### Hook System
 
-1. **Config Loading**: Loads `kiss.config.js` with defaults from `src/config/defaultConfig.js`
-2. **Content Loading**: Scans `content/` directory recursively, loading files via loaders
-3. **Data Cascade**: Parent data cascades to children, with dynamic computations at each level
-4. **Content Transformation**: Applies transforms (Nunjucks, @attributes, images)
-5. **Data Views**: Computes derived data (collections, categories, site metadata)
-6. **Writing**: Outputs HTML, optimized images, RSS, sitemap, and JSON context
+Hooks are arrays on `config.hooks` (`loadLibs`, `preLoad`, `postLoad`, `postWrite`). A hook entry can be:
 
-### Content Organization
+- A plain function: `(options, config, data, buildFlags) => data`
+- An object: `{ action: "run"|"copy"|"exec", handler?, from?, to?, command? }`
 
-- Content lives in `content/` directory
-- Folder structure maps to URL structure
-- Index files (`index.js/md/html`) provide data cascade to children
-- Single files or directories with `post.md/html` become pages
+Object hooks can have an `incrementalRebuild` function for conditional execution during incremental builds.
 
-### Key Data Flow
+### @attribute System
 
-Pages have a data structure with:
-- User content fields (title, description, created, etc.)
-- Computed fields via dynamic functions (permalink, URL, image optimization)
-- `_meta` object with internal metadata (id, parent, children, paths)
-- `_html` populated by content transformers
+`@attributes` in page data strings are resolved by `atAttributesContentTransform`:
 
-### Dynamic Computations
+- `@file:/path` — resolves to permalink of the page loaded from that content file
+- `@permalink:/url/` — validates a permalink exists
+- `@id:some-id` — resolves by page ID + language
+- `@data:site.url` — resolves a lodash path into `context`
 
-Located in `src/data/`, these functions run during data cascade to compute values:
-- `computePermalink`: Generates URL path from file location
-- `computeTitle`: Auto-generates from filename if not provided
-- `computeImage`: Handles responsive image generation
-- `computeDescription`: Extracts from content if not provided
+**Performance-critical:** The transform uses a JSON string serialization trick (serialize page to JSON, regex match all `@attribute:value` patterns, batch replace). The comments explicitly warn against refactoring to use helper functions due to measured 40% overhead at ~1M+ calls per build. The transform bypasses `lookupHelpers` and uses `context._pageIndexes` Maps directly.
 
-### Content Loaders
+### Page Indexing (`src/indexing/`)
 
-Located in `src/loaders/`:
-- `markdownLoader`: Processes .md files with front-matter
-- `jsLoader`: Executes .js files that export data
-- `jsonLoader`: Loads .json data files
-- `textLoader`: Loads .html and other text files
-- `staticLoader`: Copies static assets as-is
+Six Maps built in a single pass after `computeAllPagesData`: `byPermalink`, `byInputPath`, `byIdAndLang`, `byDerivative`, `byParentPermalink`, `byInputSource`. Lookup helpers have O(n) fallbacks for when indexes aren't yet built (during data cascade phase).
 
-### Content Transforms
+### Incremental Build
 
-Located in `src/transforms/`:
-- `nunjucksContentTransform`: Processes Nunjucks templates in content
-- `atAttributesContentTransform`: Handles @attribute syntax for dynamic data insertion
-- `imageContextTransform`: Optimizes and creates responsive images
+`computeBuildFlags` branches on file type:
 
-### Writers
+- Content file change → reload content + recompute + transform + write
+- Template file change → skip content reload, re-run transforms + write
+- Config file change → full rebuild
+- `unlink`/`unlinkDir` → full rebuild
 
-Located in `src/writers/`:
-- `htmlWriter`: Renders pages using Nunjucks templates
-- `imageWriter`: Generates optimized image variants with Sharp
-- `rssContextWriter`: Creates RSS feed
-- `sitemapContextWriter`: Generates sitemap.xml
-- `jsonContextWriter`: Dumps full site context for debugging
+`buildPageIds` computes the impacted page set: ascendants + page + descendants (except for `post.*` files which don't include descendants).
 
-## Configuration
+## Testing
 
-Main config file is `kiss.config.js`. Key settings:
+- Uses **Node.js built-in `node:test`** framework with `node:assert` (no Jest/Mocha/Vitest)
+- Unit tests in `test/unit/` mirror `src/` structure exactly
+- Integration tests in `test/integration/` use fixture site at `test/integration/repo/`
+- Private `build.js` functions are tested via `build.private.test.js` using `module.exports._functionName` exports
 
-- `context.site`: Site-wide metadata (url, title, description)
-- `dirs`: Directory paths (content, public, theme, templates)
-- `hooks`: Extensibility points for custom loaders, transforms, writers
-- `defaults`: Default values and behaviors
-- `dataViews`: Functions to compute derived data
+### Test Utilities (`test-utils/helpers.js`)
 
-## Template System
+Key helpers: `createMockConfig(overrides)`, `createMockPage(overrides)`, `createMockContext(overrides)`, `mockGlobalLogger()`/`restoreGlobalLogger()`, `createCapturingLogger()`, `mockProcessExit()`, `mockProcessArgv(args)`, `clearRequireCache(pathPattern)`, `waitFor(conditionFn, timeoutMs, checkIntervalMs)`, `waitForProcessExit(childProcess, timeoutMs)`, `createTempDir()`/`cleanupTempDir(dir)`, `copyFixtureToTemp(fixturePath)`, `createTestFile(dir, filePath, content)`/`createTestFiles(dir, files)`, `assertFileExists(filePath)`/`assertFileContent(filePath, expected)`, `stripAnsi(string)`.
 
-Uses Nunjucks templates in `theme/templates/`:
-- Templates have access to full page data and site context
-- Default templates: `default.njk`, `collection.njk`, `post.njk`
-- Custom filters loaded via `src/libs/loadNunjucksFilters.js`
+### Incremental Tests
 
-## Important Conventions
+`test/integration/incremental.test.js` spawns `test-utils/incremental-runner.js` as a child process (produces TAP output). This indirection exists because chokidar/vite pending timers prevent `node:test` from exiting cleanly when run inline.
 
-- Code style: No semicolons (per Prettier config)
-- Node.js 20+ required
-- Uses CommonJS modules (require/module.exports)
-- Async/await for asynchronous operations
-- Lodash for utility functions
-- Fast-glob for file system operations
+**When modifying incremental tests:**
+
+- ALWAYS include `incremental: true` in the initial build
+- Template changes need 250-500ms delay for chokidar detection
+- Debug with: `VERBOSITY=info node test-utils/incremental-runner.js`
+
+## Debugging
+
+- `npx kiss build --verbosity=log` for maximum output
+- `jsonContextWriter` outputs `sitedata.json` in public dir with full site data
+- For intermittent test failures: check test isolation, shared state, and file watcher timing

package/README.md

@@ -102,9 +102,9 @@ NODE_ENV=production npx kiss build
 
 kiss codebase is small and easy to navigate:
 
-- start with `config/defaultConfig.js` to get an understanding of how you can configure your project.
-- then, head over `build.js` `build()` method to understand the lifecycle of a build.
-- finally, head over to `data/initialPageData.js` and scroll down to the bottom to read about the default page metadata and dynamic computations
+- start with `src/config/defaultConfig.js` to get an understanding of how you can configure your project.
+- then, head over to `src/build.js` `build()` method to understand the lifecycle of a build.
+- finally, head over to `src/data/initialPageData.js` and scroll down to the bottom to read about the default page metadata and dynamic computations
 
 Alternatively check out [kiss-starter](https://github.com/slybridges/kiss-starter) for a real life minimal example.
 

package/TODO.md

@@ -1,5 +1,8 @@
-TODO
-- review code
-- try to get read of findBy duplication in atAttributesContentTransform.js
-- test deployment on cloudflare pages
-- test batch writes
+Road to v1.0
+
+✅ Add full test suite (test on all current sites)
+
+- Update README with test info (including coverage?)
+- Bump all deps to latest (or remove if possible)
+- 5 moderate npm audit vulns remain (ajv ReDoS in eslint). Track https://github.com/eslint/eslint/issues/20508 for ajv v8 upgrade
+- Add documentation site

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@slybridges/kiss",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Keep It Simple and Static site generator",
   "main": "src/index.js",
   "bin": {
     "kiss": "src/cli.js"
   },
   "scripts": {
-    "build": "node src/index.js"
+    "build": "node src/index.js",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "validate": "npm run lint && npm run format:check",
+    "test": "node --test",
+    "test:watch": "node --test --watch",
+    "test:coverage": "node --experimental-test-coverage --test"
   },
   "author": "Sylvestre Dupont",
   "license": "MIT",
   "dependencies": {
-    "browser-sync": "^3.0.4",
     "chalk": "^4.1.2",
     "cheerio": "^1.1.0",
     "chokidar": "^3.6.0",
@@ -29,8 +35,9 @@
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@eslint/js": "^9.30.1",
-    "eslint": "^9.30.1",
+    "@eslint/js": "^10.0.0",
+    "vite": "^7.3.1",
+    "eslint": "^10.0.0",
     "eslint-config-prettier": "^10.1.5",
     "globals": "^15.15.0",
     "prettier": "^3.6.2"

package/src/build.js

@@ -19,10 +19,14 @@ const { setGlobalLogger } = require("./logger")
 const hasOwnProperty = Object.prototype.hasOwnProperty
 
 const build = async (options = {}, lastBuild = {}, version = 0) => {
-  console.time("Build time")
-
   const { configFile, unsafeBuild, verbosity, watchMode } = options
 
+  // Only show build time for verbose logging levels
+  const showBuildTime = ["log", "info"].includes(verbosity)
+  if (showBuildTime) {
+    console.time("Build time")
+  }
+
   setGlobalLogger(verbosity)
 
   let { config } = lastBuild
@@ -152,7 +156,9 @@ const build = async (options = {}, lastBuild = {}, version = 0) => {
         )
       } else {
         global.logger.info("Exiting build with errors.")
-        console.timeEnd("Build time")
+        if (showBuildTime) {
+          console.timeEnd("Build time")
+        }
         process.exit(1)
       }
     }
@@ -161,7 +167,9 @@ const build = async (options = {}, lastBuild = {}, version = 0) => {
   } else {
     global.logger.success(`Build completed!`)
   }
-  console.timeEnd("Build time")
+  if (showBuildTime) {
+    console.timeEnd("Build time")
+  }
 
   return { context, config }
 }
@@ -684,9 +692,10 @@ const getOptions = (config, namespace, options) => {
 
 const loadContent = async (config, context, buildFlags) => {
   const { incremental, buildPageIds } = buildFlags
-  let pages = context.pages
-  let files = []
   const isIncrementalBuild = incremental && buildPageIds?.length > 0
+  // For incremental builds, reuse existing pages. For full rebuilds, start fresh.
+  let pages = isIncrementalBuild ? context.pages : {}
+  let files = []
 
   if (isIncrementalBuild) {
     // incremental build: one content file changed
@@ -795,6 +804,29 @@ const loadContent = async (config, context, buildFlags) => {
       page = await handler(file.path, options, page, context, config)
       // relative @attributes to absolute
       page = relativeToAbsoluteAttributes(page, options, config)
+
+      // Update cascadeData after content is loaded
+      // Only index files contribute to cascadeData (data that children inherit)
+      // Post files override the page but don't cascade to children
+      const inputPathObject = path.parse(file.path)
+      const isIndexFile = inputPathObject.base.startsWith("index.")
+      const isPostFile = inputPathObject.base.startsWith("post.")
+
+      if (isIndexFile) {
+        // Index files set cascadeData - this is what children will inherit
+        // eslint-disable-next-line no-unused-vars
+        const { _meta, ...cascadeableData } = page
+        page._meta.cascadeData = cascadeableData
+      } else if (isPostFile) {
+        // Post files don't contribute to cascade - preserve existing cascadeData
+        if (pages[page._meta.id]?._meta?.cascadeData) {
+          page._meta.cascadeData = pages[page._meta.id]._meta.cascadeData
+        }
+      } else if (pages[page._meta.id]?._meta?.cascadeData) {
+        // Other files preserve cascadeData from previous version
+        page._meta.cascadeData = pages[page._meta.id]._meta.cascadeData
+      }
+
       pages[page._meta.id] = page
       global.logger.log(`- [${handler.name}] loaded '${file.path}'`)
     } catch (err) {
@@ -1009,3 +1041,31 @@ const writeStaticSite = async (context, config, buildFlags) => {
     }),
   )
 }
+
+/** Private functions - exported for testing only **/
+
+// The following functions are internal implementation details and should not be
+// used by external code. They are exported with a leading underscore only to
+// enable comprehensive unit testing. These exports may change without notice.
+
+module.exports._applyTransforms = applyTransforms
+module.exports._computeBuildFlags = computeBuildFlags
+module.exports._computeBuildPageIDs = computeBuildPageIDs
+module.exports._computeIncrementalHookBuildFlag =
+  computeIncrementalHookBuildFlag
+module.exports._computeDataViews = computeDataViews
+module.exports._computePageData = computePageData
+module.exports._computeAllPagesData = computeAllPagesData
+module.exports._countPendingDependencies = countPendingDependencies
+module.exports._directoryCollectionLoader = directoryCollectionLoader
+module.exports._isComputableValue = isComputableValue
+module.exports._findMatchingLoaderId = findMatchingLoaderId
+module.exports._getFiles = getFiles
+module.exports._getOptions = getOptions
+module.exports._loadContent = loadContent
+module.exports._runConfigHooks = runConfigHooks
+module.exports._runCopyHook = runCopyHook
+module.exports._runExecHook = runExecHook
+module.exports._sortFiles = sortFiles
+module.exports._runHandlerHook = runHandlerHook
+module.exports._writeStaticSite = writeStaticSite

package/src/cli.js

@@ -32,4 +32,5 @@ yargs(hideBin(process.argv))
     default: false,
     describe: "Performs incremental builds on watch (experimental)",
   })
+  .strict()
   .demandCommand(1, "Enter a command").argv

package/src/config/loadConfig.js

@@ -11,12 +11,18 @@ const loadConfig = (options = {}) => {
   setGlobalLogger(options.verbosity) // loadConfig is called in devServer outside of dev
   const relativeConfigFile = path.relative(__dirname, configFile)
   let configFunc
+  let config
   try {
     configFunc = require(relativeConfigFile)
+    if (typeof configFunc !== "function") {
+      throw new TypeError(
+        `Config file must export a function, got ${typeof configFunc}`,
+      )
+    }
+    config = configFunc(baseConfig)
   } catch (e) {
-    throw new Error(`Error loading '${configFile}': ${e}`)
+    throw new Error(`Error loading '${configFile}': ${e}`, { cause: e })
   }
-  let config = configFunc(baseConfig)
   if (configFile !== baseConfig.configFile) {
     config.configFile = configFile
   }

package/src/data/computeCreated.js

@@ -2,7 +2,12 @@ const computeCreated = ({ _meta }, config, { pages }) => {
   // take the earliest created date of all descendants
   if (_meta.isCollection) {
     const earliest = _meta.descendants.reduce((earliest, pageId) => {
-      const created = pages[pageId][config.defaults.pagePublishedAttribute]
+      const page = pages[pageId]
+      if (!page) {
+        // page doesn't exist
+        return earliest
+      }
+      const created = page[config.defaults.pagePublishedAttribute]
       // assume an date is a valid Date object if it has a getMonth function
       if (!created || typeof created?.getMonth !== "function") {
         // invalid or net yet computed
@@ -14,7 +19,7 @@ const computeCreated = ({ _meta }, config, { pages }) => {
       return earliest
     }
   }
-
+  // fallback to own created date
   if (_meta.fileCreated) {
     return _meta.fileCreated
   }

package/src/data/computeImage.js

@@ -91,9 +91,11 @@ const getImagePermalink = (
     // external image, data URI or @attribute that will be resolved later
     return src
   }
-  const pageFound = getPageFromSource(src, page, pages, config)
+  const pageFound = getPageFromSource(src, page, pages, config, {
+    throwIfNotFound: false,
+  })
   if (!pageFound) {
-    // something went wrong
+    // image page not found, return the src as-is
     return src
   }
   return pageFound.permalink

package/src/data/computeLayout.js

@@ -1,11 +1,11 @@
 const computeLayout = ({ _meta }, config) => {
   if (_meta.isPost) {
-    return config.templates.post || "post.njk"
+    return config.templates?.post || "post.njk"
   }
   if (_meta.isCollection) {
-    return config.templates.collection || "collection.njk"
+    return config.templates?.collection || "collection.njk"
   }
-  return config.templates.default || "default.njk"
+  return config.templates?.default || "default.njk"
 }
 
 computeLayout.kissDependencies = ["_meta.isCollection", "_meta.isPost"]

package/src/data/computeModified.js

@@ -2,7 +2,12 @@ const computeModified = ({ _meta }, config, { pages }) => {
   // take the latest modified date of all descendants
   if (_meta.isCollection) {
     const latest = _meta.descendants.reduce((latest, pageId) => {
-      const modified = pages[pageId][config.defaults.pageUpdatedAttribute]
+      const page = pages[pageId]
+      if (!page) {
+        // page doesn't exist
+        return latest
+      }
+      const modified = page[config.defaults.pageUpdatedAttribute]
       // assume an date is a valid Date object if it has a getMonth function
       if (!modified || typeof modified?.getMonth !== "function") {
         // invalid or net yet computed
@@ -14,6 +19,7 @@ const computeModified = ({ _meta }, config, { pages }) => {
       return latest
     }
   }
+  // fallback to own modified date
   if (_meta.fileModified) {
     return _meta.fileModified
   }