mikser-io 6.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Almero Digital Marketing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+<p align="center">
+  <img src="mikser-lockup-stacked.svg" alt="mikser" width="198" />
+</p>
+
+# Mikser Documentation
+
+Mikser is a precision content engine for Node.js — built around a strict lifecycle, a composable plugin system, and zero compromise on output control. Every document, asset, and template flows through the same deterministic pipeline: import → process → render → finalize. Plugins hook in at any phase; nothing runs outside the cycle. The result is a system that scales from a single markdown blog to a multi-language, multi-format publishing platform — without ever losing sight of what it produced and why.
+
+## Documentation Index
+
+| Document | Audience | Description |
+|----------|----------|-------------|
+| [Getting Started](./documentation/getting-started.md) | Users | Installation, first project, basic usage |
+| [Configuration](./documentation/configuration.md) | Users | All CLI options and config file reference |
+| [Lifecycle](./documentation/lifecycle.md) | Users & Developers | Complete lifecycle phases and hook system |
+| [Plugins](./documentation/plugins.md) | Users & Developers | Built-in plugins, writing custom plugins |
+| [Entities](./documentation/entities.md) | Users & Developers | Entity model, operations, journal, catalog |
+| [Rendering](./documentation/rendering.md) | Users & Developers | Render pipeline, render plugins, render modes |
+| [Watch Mode](./documentation/watch-mode.md) | Users | File watching, scheduled tasks, incremental builds |
+| [Architecture](./documentation/architecture.md) | Developers | System design, module structure, extension points |
+| [API Reference](./documentation/api-reference.md) | Developers | Complete public API reference |
+
+## Quick Start
+
+```bash
+npm install mikser-io
+```
+
+```js
+// mikser.config.js
+export default {
+  plugins: ['documents', 'layouts'],
+  layouts: {
+    cleanUrls: true
+  }
+}
+```
+
+```bash
+npx mikser
+```
+
+## Core Concepts
+
+- **Lifecycle** — Processing runs through fixed phases: initialize → load → import → process → persist → render → finalize. Plugins hook into any phase.
+- **Entities** — Everything is an entity (document, file, layout, asset). Entities flow through the journal and are tracked in the catalog.
+- **Plugins** — Functionality is delivered via plugins. Built-in plugins handle common sources (documents, files, layouts, assets). Custom plugins can be added to any project.
+- **Runtime Singleton** — A plain module-level object holds all global state and coordinates the lifecycle. The ES module cache guarantees every importer gets the same instance.
+- **Watch Mode** — In watch mode, file changes trigger incremental re-processing without restarting.

package/app.js

@@ -0,0 +1,7 @@
+import { setup } from "./index.js"
+
+async function main() {
+    const mikser = await setup()
+    await mikser.start()
+}
+main()

package/index.js

@@ -0,0 +1,11 @@
+export { default as runtime } from './src/runtime.js'
+export * as constants from './src/constants.js'
+export * from './src/utils.js'
+export * from './src/journal.js'
+export * from './src/lifecycle.js'
+export * from './src/catalog.js'
+export * from './src/config.js'
+export * from './src/plugins.js'
+export * from './src/manager.js'
+export * from './src/tracking.js'
+export * from './src/engine.js'

package/mikser-lockup-stacked.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="396" height="330" viewBox="0 0 396 330" role="img" aria-label="mikser">
+  <title>mikser</title>
+  <g transform="translate(98 20)" style="isolation:isolate">
+    <g style="mix-blend-mode:multiply">
+      <circle cx="100" cy="72" r="46" fill="#0A0907"></circle>
+      <circle cx="124.249" cy="114" r="46" fill="#0A0907" opacity="0.85"></circle>
+      <circle cx="75.751" cy="114" r="46" fill="#FF3F00"></circle>
+    </g>
+  </g>
+  <g transform="translate(13 310.32)">
+    <path d="M75.46-55.77L75.46-55.77Q82.83-55.77 86.68-51.92Q90.53-48.07 90.53-40.70L90.53-40.70L90.53 0L74.47 0L74.47-35.64Q74.36-39.05 73.04-40.54Q71.72-42.02 68.42-42.02L68.42-42.02Q66.55-42.02 64.73-41.52Q62.92-41.03 60.61-39.82L60.61-39.82Q58.85-38.83 56.43-37.40L56.43-37.40L56.43 0L40.81 0L40.81-35.64Q40.81-39.16 39.33-40.59Q37.84-42.02 34.76-42.02L34.76-42.02Q32.89-42.02 31.07-41.52Q29.26-41.03 26.95-39.82L26.95-39.82Q25.19-38.94 22.88-37.62L22.88-37.62L22.88 0L6.71 0L6.71-54.34L19.58-54.34L20.79-46.09Q25.85-50.82 30.58-53.24L30.58-53.24Q35.64-55.77 41.58-55.77L41.58-55.77Q48.84-55.77 52.69-52.03L52.69-52.03Q54.67-49.94 55.66-46.86L55.66-46.86Q60.17-50.93 64.57-53.24L64.57-53.24Q69.63-55.77 75.46-55.77ZM101.86-54.34L117.92-54.34L117.92 0L101.86 0L101.86-54.34ZM106.37-78.32L113.41-78.32Q118.25-78.32 118.25-73.48L118.25-73.48L118.25-67.54Q118.25-62.70 113.41-62.70L113.41-62.70L106.37-62.70Q101.53-62.70 101.53-67.54L101.53-67.54L101.53-73.48Q101.53-78.32 106.37-78.32L106.37-78.32ZM163.90-54.34L182.05-54.34L167.86-35.42Q166.87-33.88 165.33-32.45Q163.79-31.02 162.80-30.36L162.80-30.36L162.80-30.03Q163.79-29.37 165.33-27.66Q166.87-25.96 167.86-24.20L167.86-24.20L183.92 0L165.77 0L150.37-25.30L145.09-25.30Q145.20-24.53 145.31-23.65L145.31-23.65Q145.75-20.02 145.75-17.05L145.75-17.05L145.75 0L129.58 0L129.58-77L145.75-77L145.86-45.21Q145.86-41.36 145.42-37.73L145.42-37.73Q145.31-36.41 145.09-35.20L145.09-35.20L150.48-35.20L163.90-54.34ZM209.44-55.77L209.44-55.77Q213.40-55.77 218.02-55.49Q222.64-55.22 227.04-54.78Q231.44-54.34 234.85-53.68L234.85-53.68L233.75-43.56Q228.47-43.67 223.14-43.78Q217.80-43.89 212.74-43.89L212.74-43.89Q208.45-43.89 206.14-43.73Q203.83-43.56 202.90-42.73Q201.96-41.91 201.96-39.82L201.96-39.82Q201.96-37.29 203.61-36.47Q205.26-35.64 209.11-34.65L209.11-34.65L223.30-31.24Q230.12-29.48 233.42-26.02Q236.72-22.55 236.72-15.62L236.72-15.62Q236.72-8.80 234.19-5.17Q231.66-1.54 226.16-0.17Q220.66 1.21 211.97 1.21L211.97 1.21Q208.56 1.21 201.85 0.88Q195.14 0.55 187.22-0.77L187.22-0.77L188.21-10.89Q190.30-10.78 193.33-10.72Q196.35-10.67 199.98-10.67L199.98-10.67L207.24-10.67Q212.96-10.67 215.93-10.95Q218.90-11.22 220.00-12.21Q221.10-13.20 221.10-15.18L221.10-15.18Q221.10-17.71 219.23-18.54Q217.36-19.36 213.29-20.46L213.29-20.46L199.54-23.87Q194.26-25.30 191.40-27.50Q188.54-29.70 187.39-32.84Q186.23-35.97 186.23-40.37L186.23-40.37Q186.23-45.98 188.54-49.39Q190.85-52.80 195.91-54.29Q200.97-55.77 209.44-55.77ZM270.71-55.77L270.71-55.77Q284.46-55.77 290.46-51.09Q296.45-46.42 296.45-37.18L296.45-37.18Q296.56-29.81 292.71-26.07Q288.86-22.33 279.40-22.33L279.40-22.33L260.04-22.33Q260.37-19.80 260.92-18.15L260.92-18.15Q262.13-14.41 265.05-12.98Q267.96-11.55 273.13-11.55L273.13-11.55Q276.87-11.55 282.43-11.82Q287.98-12.10 293.59-12.76L293.59-12.76L295.13-2.75Q291.94-1.21 287.87-0.33Q283.80 0.55 279.51 0.94Q275.22 1.32 271.26 1.32L271.26 1.32Q260.92 1.32 254.65-1.71Q248.38-4.73 245.58-11Q242.77-17.27 242.77-27.06L242.77-27.06Q242.77-37.73 245.58-44Q248.38-50.27 254.54-53.02Q260.70-55.77 270.71-55.77ZM259.71-31.46L259.71-31.46L275.00-31.46Q278.63-31.46 279.68-33.05Q280.72-34.65 280.72-37.51L280.72-37.51Q280.72-41.36 278.58-42.84Q276.43-44.33 271.26-44.33L271.26-44.33Q266.75-44.44 264.22-43.17Q261.69-41.91 260.70-38.50L260.70-38.50Q259.93-35.86 259.71-31.46ZM304.92-54.34L317.57-54.34L319.11-46.09Q324.39-50.71 329.89-53.13L329.89-53.13Q335.72-55.77 341.22-55.77L341.22-55.77L344.08-55.77L342.54-40.81L338.03-40.81Q334.18-40.81 330.00-39.71L330.00-39.71Q326.37-38.72 321.09-36.85L321.09-36.85L321.09 0L304.92 0L304.92-54.34Z" fill="#0A0907"></path>
+    <path d="M354.31-16.72L358.49-16.72Q361.68-16.72 362.94-15.46Q364.21-14.19 364.21-11L364.21-11L364.21-5.72Q364.21-2.53 362.94-1.26Q361.68 0 358.49 0L358.49 0L354.31 0Q351.12 0 349.86-1.26Q348.59-2.53 348.59-5.72L348.59-5.72L348.59-11Q348.59-14.19 349.86-15.46Q351.12-16.72 354.31-16.72L354.31-16.72Z" fill="#FF3F00"></path>
+  </g>
+</svg>

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "mikser-io",
+  "version": "6.0.0",
+  "description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --no-warnings app.js --working-folder test"
+  },
+  "bin": {
+    "mikser": "app.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/almero-digital-marketing/mikser-io.git"
+  },
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "await-semaphore": "^0.1.3",
+    "axios": "^1.16.0",
+    "chokidar": "^5.0.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^14.0.3",
+    "deepdash": "^5.3.9",
+    "escape-string-regexp": "^5.0.0",
+    "execa": "^9.6.1",
+    "front-matter": "^4.0.2",
+    "globby": "^16.2.0",
+    "handlebars": "^4.7.9",
+    "handlebars-helpers": "^0.10.0",
+    "hasha": "^7.0.0",
+    "is-url": "^1.2.4",
+    "knex": "^3.2.10",
+    "line-reader": "^0.4.0",
+    "lodash": "^4.18.1",
+    "lowdb": "^7.0.1",
+    "minimatch": "^10.2.5",
+    "node-cron": "^4.2.1",
+    "p-map": "^7.0.4",
+    "p-queue": "^9.2.0",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "piscina": "^5.1.4",
+    "sqlite3": "^6.0.1",
+    "truncate-stream": "^1.0.2",
+    "yaml": "^2.8.4"
+  },
+  "optionalDependencies": {
+    "puppeteer": "^24.43.0",
+    "express": "^4.21.0"
+  },
+  "devDependencies": {
+    "fluent-ffmpeg": "^2.1.3",
+    "sharp": "^0.34.5"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "bugs": {
+    "url": "https://github.com/almero-digital-marketing/mikser-io/issues"
+  },
+  "homepage": "https://github.com/almero-digital-marketing/mikser-io#readme"
+}

package/src/catalog.js

@@ -0,0 +1,56 @@
+import runtime from './runtime.js'
+import { useLogger } from './engine.js'
+import { onLoaded, onPersist, onFinalized } from './lifecycle.js'
+import { useJournal } from './journal.js'
+import { OPERATION } from './constants.js'
+import { Low } from 'lowdb'
+import path from 'node:path'
+import { JSONFile } from 'lowdb/node'
+import _ from 'lodash'
+
+let catalog
+
+onLoaded(async () => {
+	const adapter = new JSONFile(path.join(runtime.options.runtimeFolder, `catalog.json`))
+	catalog = new Low(adapter, {
+		entities: [],
+	})
+	catalog.chain = _.chain(catalog).get('data')
+	runtime.catalog = catalog
+})
+
+onPersist(async () => {
+	const logger = useLogger()
+	for await (let { operation, entity } of useJournal('Catalog')) {
+		switch (operation) {
+			case OPERATION.CREATE:
+				logger.trace('Database %s %s: %s', entity.collection, operation, entity.id)
+				catalog.data.entities.push(entity)
+				break
+			case OPERATION.UPDATE:
+				logger.trace('Database %s %s: %s', entity.collection, operation, entity.id)
+				catalog.chain.get('entities').find({ id: entity.id }).assign(entity).value()
+				break
+			case OPERATION.DELETE:
+				logger.trace('Database %s %s: %s', entity.collection, operation, entity.id)
+				catalog.chain.get('entities').remove({ id: entity.id }).value()
+				break
+		}
+	}
+})
+
+onFinalized(async () => {
+	await catalog.write()
+})
+
+export async function findEntity(query) {
+	if (!query) return
+	return catalog.chain.get('entities').find(query).value()
+}
+
+export async function findEntities(query) {
+	if (!query) {
+		return catalog.chain.get('entities').value()
+	}
+	return catalog.chain.get('entities').filter(query).value()
+}

package/src/config.js

@@ -0,0 +1,37 @@
+import runtime from './runtime.js'
+import { useLogger } from './engine.js'
+import { onLoad } from './lifecycle.js'
+import path from 'node:path'
+
+onLoad(async () => {
+	const logger = useLogger()
+	const configFile = path.resolve(runtime.options.config)
+	logger.info('Config: %s', configFile)
+	try {
+		const config = await import(configFile)
+		if (typeof config.default == 'function') {
+			runtime.config = await config.default(runtime)
+		} else if (typeof config.default == 'object') {
+			runtime.config = config.default
+		}
+	} catch (err) {
+		if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
+	}
+
+	const plugins = runtime.options.plugins.concat(runtime.config.plugins).filter((plugin) => plugin)
+	for (const plugin of plugins) {
+		if (!runtime.config[plugin]) {
+			try {
+				const pluginConfig = path.join(runtime.options.workingFolder, 'config', `${plugin}.config.js`)
+				const config = await import(pluginConfig)
+				if (typeof config.default == 'function') {
+					runtime.config[plugin] = await config.default(runtime)
+				} else if (typeof config.default == 'object') {
+					runtime.config[plugin] = config.default
+				}
+			} catch (err) {
+				if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
+			}
+		}
+	}
+})

package/src/constants.js

@@ -0,0 +1,20 @@
+export const OPERATION = {
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    RENDER: 'render',
+    POSTPROCESS: 'postprocess',
+}
+
+export const ACTION = {
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    TRIGGER: 'trigger',
+}
+
+export const TASKS = {
+    QUEUE: 'queue',
+    WORKER: 'worker',
+    POOL: 'pool',
+}

package/src/engine.js

@@ -0,0 +1,317 @@
+import pino from 'pino'
+import path from 'node:path'
+import { Command } from 'commander'
+import { rm, lstat, realpath, mkdir, writeFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import _ from 'lodash'
+import Piscina from 'piscina'
+import runtime from './runtime.js'
+import { onInitialize, onInitialized, onRender, onCancel, onCancelled, onFinalized, onLoaded, onAfterRender, onBeforePostprocess, onPostprocess, postprocessEntities } from './lifecycle.js'
+import { useJournal, updateEntry } from './journal.js'
+import { globby } from 'globby'
+import { OPERATION, TASKS } from './constants.js'
+import { changeExtension } from './utils.js'
+import render from './render.js'
+import postprocess, { loadPlugin as loadPostPlugin } from './postprocess.js'
+import map from 'p-map'
+import Queue from 'p-queue'
+import packageInfo from '../package.json' with { type: 'json' }
+
+export async function setup(options) {
+    runtime.options.threads = options?.threads !== undefined ? options.threads : 4
+    runtime.engine = {
+        logger: options?.logger || pino({
+            transport: {
+                target: 'pino-pretty'
+            },
+        }),
+        commander: new Command(),
+        renderWorkers: new Piscina({
+            filename: new URL('./render.js', import.meta.url).href,
+            maxThreads: runtime.options.threads
+        }),
+        queue: new Queue({ concurrency: 1 })
+    }
+    runtime.state = {}
+
+    onInitialize(async () => {
+        runtime.engine.commander?.version(packageInfo.version)
+            .option('-i --working-folder <folder>', 'set mikser working folder', './')
+            .option('-p --plugins [plugins...]', 'list of mikser plugins to load', [])
+            .option('-c --config <file>', 'set mikser mikser.config.js location', './mikser.config.js')
+            .option('-m --mode <mode>', 'set mikser runtime mode', 'development')
+            .option('-r --clear', 'clear current state before execution', false)
+            .option('-o --output-folder <folder>', 'set mikser output folder relative to working folder', 'out')
+            .option('-w --watch', 'watch entities for changes', false)
+            .option('-d --debug', 'display debug statements')
+            .option('-t --trace', 'display trace statements')
+            .option('-e --runtime-folder <folder>', 'set mikser runtime folder relative to working folder', 'runtime')
+
+        Object.assign(runtime.options, options || runtime.engine.commander.parse(process.argv).opts())
+        runtime.options.info = true
+        if (runtime.options.debug) {
+            runtime.engine.logger.level = 'debug'
+            runtime.options.info = false
+        }
+        if (runtime.options.trace) {
+            runtime.engine.logger.level = 'trace'
+            runtime.options.debug = false
+            runtime.options.info = false
+        }
+        runtime.engine.logger.notice = runtime.engine.logger.info
+    })
+
+    onInitialized(async () => {
+        const logger = useLogger()
+
+        runtime.options.workingFolder = path.resolve(runtime.options.workingFolder)
+        process.chdir(runtime.options.workingFolder)
+
+        runtime.options.runtimeFolder = path.join(runtime.options.workingFolder, runtime.options.runtimeFolder || 'runtime')
+        runtime.options.outputFolder = path.join(runtime.options.workingFolder, runtime.options.outputFolder || 'out')
+
+        logger.info('Working folder: %s', runtime.options.workingFolder)
+        logger.info('Output folder: %s', runtime.options.outputFolder)
+
+        if (runtime.options.clear) {
+            try {
+                logger.info('Clearing folders')
+                await rm(runtime.options.outputFolder, { recursive: true })
+                await rm(runtime.options.runtimeFolder, { recursive: true })
+            } catch (err) {
+                if (err.code != 'ENOENT')
+                    throw err
+            }
+        }
+        await mkdir(runtime.options.runtimeFolder, { recursive: true })
+    })
+
+    onLoaded(async () => {
+        const logger = useLogger()
+        logger.debug(runtime.options, 'Mikser options')
+    })
+
+    onRender(async (signal) => {
+        const logger = useLogger()
+        const renderJobs = new Set()
+        await map(useJournal('Rendering', [OPERATION.RENDER], signal), async entry => {
+            const { id, entity, options, context } = entry
+            const jobId = entity.id + ':' + entity.destination
+            if (!renderJobs.has(jobId) && !options.ignore) {
+                renderJobs.add(jobId)
+                const renderOptions = {
+                    entity,
+                    options: {
+                        tasks: TASKS.POOL,
+                        ...runtime.options,
+                        ...options,
+                    },
+                    config: _.pickBy(runtime.config, (value, key) => _.startsWith(key, 'render-')),
+                    context,
+                    state: runtime.state
+                }
+                try {
+                    let result
+                    switch (renderOptions.options.tasks) {
+                        case TASKS.POOL:
+                            renderOptions.logger = logger
+                            renderOptions.signal = signal
+                            if (!signal.aborted) {
+                                result = await render(renderOptions)
+                            }
+                            break
+                        case TASKS.QUEUE:
+                            renderOptions.logger = logger
+                            renderOptions.signal = signal
+                            if (!signal.aborted) {
+                                result = await runtime.engine.queue.add(() => render(renderOptions), { signal })
+                            }
+                            break
+                        case TASKS.WORKER:
+                            const mc = new MessageChannel();
+                            mc.port2.onmessage = event => {
+                                const message = JSON.parse(event.data)
+                                if (message.command == 'logger') {
+                                    runtime.engine.logger[message.data.log](...message.data.args)
+                                }
+                            }
+                            mc.port2.unref()
+                            renderOptions.port = mc.port1
+                            result = await runtime.engine.renderWorkers.run(
+                                renderOptions,
+                                { signal, transferList: [mc.port1] }
+                            )
+                            break
+                    }
+                    if (!signal.aborted) {
+                        entry.output = {
+                            success: true,
+                            result,
+                        }
+                        await runtime.complete(entry)
+                        await updateEntry({ id, output: entry.output })
+                    }
+
+                    logger.debug('Rendered: [%s] %s → %s', options.renderer, entity.name || entity.id, entity.destination)
+                } catch (err) {
+                    if (!signal.aborted) {
+                        await updateEntry({ id, output: { success: false } })
+                        logger.error('Render error: %s %s', entity.id, err.message)
+                    }
+                    logger.debug('Render canceled')
+                }
+            } else {
+                await updateEntry({ id, output: { success: true } })
+            }
+        }, {
+            concurrency: runtime.options.threads,
+            signal
+        })
+        renderJobs.size && logger.info('Rendered: %d', renderJobs.size)
+    })
+
+    onAfterRender(async () => {
+        const results = new Map()
+        for await (let { output, entity } of useJournal('Output', [OPERATION.RENDER])) {
+            if (output?.success) {
+                const jobId = entity.id + ':' + entity.destination
+                results.set(jobId, entity)
+            }
+        }
+        const renderOutput = path.join(runtime.options.runtimeFolder, `render-details.json`)
+        await writeFile(renderOutput, JSON.stringify(Array.from(results.values())), 'utf8')
+    })
+
+    onBeforePostprocess(async (signal) => {
+        const tasks = []
+        for await (const { entity, options, context, output } of useJournal('Queuing postprocess', [OPERATION.RENDER], signal)) {
+            if (output?.success && options.postprocessor) {
+                tasks.push({
+                    entity: {
+                        ...entity,
+                        origin: entity.destination,
+                        destination: changeExtension(entity.destination, options.postprocessor)
+                    },
+                    options: { postprocessor: options.postprocessor, tasks: options.tasks },
+                    context
+                })
+            }
+        }
+        if (tasks.length) await postprocessEntities(tasks)
+    })
+
+    onPostprocess(async (signal) => {
+        const logger = useLogger()
+        const config = _.pickBy(runtime.config, (value, key) => _.startsWith(key, 'post-'))
+
+        const postPlugins = {}
+        for (const pluginName of runtime.options.plugins.filter(p => p.startsWith('post-'))) {
+            const plugin = await loadPostPlugin(pluginName, runtime.options.workingFolder)
+            if (plugin) {
+                postPlugins[pluginName] = plugin
+                if (plugin.setup) await plugin.setup({ options: runtime.options, config: config[pluginName], state: runtime.state, logger })
+            }
+        }
+
+        const postprocessJobs = new Set()
+        try {
+            await map(useJournal('Postprocessing', [OPERATION.POSTPROCESS], signal), async entry => {
+                const { id, entity, options, context } = entry
+                const jobId = entity.id + ':' + entity.destination
+                if (!postprocessJobs.has(jobId) && !options.ignore) {
+                    postprocessJobs.add(jobId)
+                    const postprocessOptions = {
+                        entity,
+                        options: {
+                            tasks: TASKS.POOL,
+                            ...runtime.options,
+                            ...options,
+                        },
+                        config,
+                        context,
+                        state: runtime.state
+                    }
+                    try {
+                        let result
+                        switch (postprocessOptions.options.tasks) {
+                            case TASKS.POOL:
+                                postprocessOptions.logger = logger
+                                postprocessOptions.signal = signal
+                                if (!signal.aborted) {
+                                    result = await postprocess(postprocessOptions)
+                                }
+                                break
+                            case TASKS.QUEUE:
+                                postprocessOptions.logger = logger
+                                postprocessOptions.signal = signal
+                                if (!signal.aborted) {
+                                    result = await runtime.engine.queue.add(() => postprocess(postprocessOptions), { signal })
+                                }
+                                break
+                        }
+                        if (!signal.aborted) {
+                            entry.output = { success: true }
+                            if (result) entry.output.result = result
+                            await runtime.complete(entry)
+                            await updateEntry({ id, output: entry.output })
+                        }
+                        logger.debug('Postprocessed: [%s] %s → %s', options.postprocessor, entity.name || entity.id, entity.destination)
+                    } catch (err) {
+                        if (!signal.aborted) {
+                            await updateEntry({ id, output: { success: false } })
+                            logger.error('Postprocess error: %s %s', entity.id, err.message)
+                        }
+                        logger.debug('Postprocess canceled')
+                    }
+                } else {
+                    await updateEntry({ id, output: { success: true } })
+                }
+            }, {
+                concurrency: runtime.options.threads,
+                signal
+            })
+            postprocessJobs.size && logger.info('Postprocessed: %d', postprocessJobs.size)
+        } finally {
+            for (const [pluginName, plugin] of Object.entries(postPlugins)) {
+                if (plugin.teardown) await plugin.teardown({ options: runtime.options, config: config[pluginName], state: runtime.state, logger })
+            }
+        }
+    })
+
+    onCancel(async () => {
+        if (runtime.engine.renderWorkers.queueSize) {
+            await new Promise(resolve => {
+                runtime.engine.renderWorkers.once('drain', resolve)
+            })
+        }
+    })
+
+    onFinalized(async () => {
+        const logger = useLogger()
+
+        const paths = await globby('**/*', { cwd: runtime.options.outputFolder, followSymbolicLinks: false })
+        for (let relativePath of paths) {
+            let source = path.join(runtime.options.outputFolder, relativePath)
+            const linkStat = await lstat(source)
+            if (linkStat.isSymbolicLink()) {
+                const destination = await realpath(source)
+                if (!existsSync(destination)) {
+                    await unlink(source)
+                }
+            }
+        }
+        logger.notice('Mikser completed')
+    })
+
+    onCancelled(async () => {
+        const logger = useLogger()
+        logger.notice('Mikser restarted')
+    })
+
+    console.info('Mikser: %s', packageInfo.version)
+    return runtime
+}
+
+export function useLogger() {
+    return runtime.engine.logger
+}