@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/cli/upgrade.ts

@@ -1,15 +1,13 @@
-import { readdir } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import { setUpBoard } from './board-in-paseo'
 import type { PaseoPlugins } from './computer-adapters'
-import {
-    formatChecks,
-    hasProblem,
-    reason,
-    type DoctorCheck,
-} from './doctor-checks'
+import { reason, type DoctorCheck } from './doctor-checks'
 import { describeRun, goingRuns } from './going-runs'
+import type { ListProcesses } from './live-runs'
+import { resumeCommand } from './run-modes'
+import {
+    boardFingerprint,
+    finishUpgrade,
+    type UpgradeEnd,
+} from './upgrade-finish'
 
 import { LUCA_PACKAGE } from '../config/luca-version'
 
@@ -18,7 +16,11 @@ import { LUCA_PACKAGE } from '../config/luca-version'
  * never under a going run.
  *
  * 1. Refuses while any run is going (limit waits and stuck runs included)
- *    and lists them by spec and repo.
+ *    and lists them by spec and repo. A run is going when `ps` shows its
+ *    engine, or its engine is gone but the board will restart it; when `ps`
+ *    fails, every unfinished run is (see `goingRuns`). An unfinished run
+ *    nothing runs (such as a crash) doesn't stop it: upgrade says how to
+ *    resume it on the new version.
  * 2. Picks the version: `to` exactly when given, older ones included (the
  *    way back from a broken version). Without it, the installed version's
  *    channel: an alpha install gets the `alpha` tag, any other gets
@@ -28,10 +30,20 @@ import { LUCA_PACKAGE } from '../config/luca-version'
  * 4. Reloads the board in Paseo, keeping its settings, and rewrites its
  *    engine and Bun paths (see `setUpBoard`).
  * 5. Says when `/reload-skills` is needed: when the board's files changed.
- * 6. Ends with doctor's computer checks (see `computerChecks`).
+ * 6. Copies Luca's own skills (every one in the new install's `skills/`)
+ *    into `~/.claude/skills` (see `installLucaSkills`).
+ * 7. Ends with doctor's computer checks (see `computerChecks`).
+ *
+ * Steps 4-7 (`finishUpgrade`) run in the new install, not in this process
+ * (#529): this process runs the old version's code, which doesn't know
+ * what the new version's board setup, skills, and checks are. So after
+ * step 3 upgrade hands off to the new install's `luca upgrade --finish`,
+ * passes its exit code through, and doesn't run them itself. A new install
+ * that can't finish (a version from before #529, such as a downgrade's)
+ * gets them from this process, as before.
  *
- * npm's registry, Bun, Paseo, and the computer checks are adapters, so
- * tests use fakes.
+ * npm's registry, Bun, Paseo, `ps`, the new install, and the computer
+ * checks are adapters, so tests use fakes.
  */
 
 /** npm's registry lookups for `@alecsibilia/luca`. */
@@ -46,8 +58,28 @@ export type BunGlobal = {
     addGlobal: (args: { spec: string }) => Promise<void>
 }
 
-/** How upgrade ended; `message` is the last line it printed. */
-export type UpgradeEnd = { ok: boolean; message: string }
+export type { UpgradeEnd }
+
+/** How handing the last steps to the new install went. */
+export type HandOff =
+    /** The new install ran them; it exited with `exit_code`. */
+    | { handed_off: true; exit_code: number }
+    /** The new install can't run them, and `why` (one sentence, no period). */
+    | { handed_off: false; why: string }
+
+/** The newly installed Luca. */
+export type NewInstall = {
+    /**
+     * Runs `luca upgrade --finish` in the new install of `version`, which
+     * prints its own lines; or says why it can't. Throws when the new
+     * install couldn't be started.
+     */
+    finish: (args: {
+        version: string
+        /** The board folder's fingerprint before the install. */
+        board_before: string | null
+    }) => Promise<HandOff>
+}
 
 /** The first version of new Luca; without `--to`, nothing older is installed. */
 const FIRST_NEW_MAJOR = 14
@@ -115,74 +147,61 @@ export const channelTarget = ({
     return { ok: true, version }
 }
 
-/**
- * A fingerprint of every file in `dir` but its `node_modules`, or `null`
- * when it can't be read.
- */
-const fingerprint = async (dir: string): Promise<string | null> => {
-    const lines: string[] = []
-    const walk = async (at: string): Promise<void> => {
-        const entries = await readdir(at, { withFileTypes: true })
-        for (const entry of entries) {
-            const path = join(at, entry.name)
-            if (entry.isDirectory()) {
-                if (entry.name !== 'node_modules') await walk(path)
-            } else if (entry.isFile()) {
-                const bytes = await Bun.file(path).arrayBuffer()
-                lines.push(`${path}\t${Bun.hash(bytes)}`)
-            }
-        }
-    }
-    try {
-        await walk(dir)
-    } catch {
-        return null
-    }
-    return lines.sort().join('\n')
-}
-
 /**
  * Runs `luca upgrade`: refuses while a run is going, picks the version,
- * installs it with Bun, reloads the board with its settings kept and its
- * paths rewritten, then prints `computer_checks`. Never throws: a refusal,
- * a failed step, or a check that is a problem ends it with `ok: false`.
+ * installs it with Bun, then hands the last steps to `new_install` (see
+ * `finishUpgrade`), or runs them here when it can't take them. Never
+ * throws: a refusal, a failed step, or a check that is a problem ends it
+ * with `ok: false`.
  *
  * @example
- * const end = await runUpgrade({ to: null, installed_version: lucaVersion(), runs_dir: defaultRunsDir(), registry_path, npm, bun, paseo, board_dir, engine_path, bun_path, computer_checks, log: console.log })
+ * const end = await runUpgrade({ to: null, home: homedir(), installed_version: lucaVersion(), runs_dir: defaultRunsDir(), registry_path, list_processes: listProcesses, npm, bun, paseo, board_dir, skills_dir, engine_path, bun_path, new_install, computer_checks, log: console.log })
  */
 export const runUpgrade = async ({
     to,
+    home,
     installed_version,
     runs_dir,
     registry_path,
+    list_processes,
     npm,
     bun,
     paseo,
     board_dir,
+    skills_dir,
     engine_path,
     bun_path,
+    new_install,
     computer_checks,
     log,
 }: {
     /** `--to <version>`, or `null` to stay on the installed channel. */
     to: string | null
+    /** The home folder, whose `.claude/skills` gets Luca's own skills. */
+    home: string
     /** The version of Luca installed now. */
     installed_version: string
     runs_dir: string
     /** The board's run registry. */
     registry_path: string
+    /** Every running process's command line, to tell live engines from gone ones. */
+    list_processes: ListProcesses
     npm: NpmRegistry
     bun: BunGlobal
     paseo: PaseoPlugins
     /** The board folder inside Luca's install folder. */
     board_dir: string
+    /** The skills folder inside Luca's install folder. */
+    skills_dir: string
     /** The real path of the installed `luca-run`. */
     engine_path: string
     /** Bun's own path. */
     bun_path: string
+    /** The install `bun add -g` makes, which finishes the upgrade. */
+    new_install: NewInstall
     /**
      * Doctor's computer checks of the new install, run after the board
-     * reload; none when not given.
+     * reload when this process runs the last steps; none when not given.
      */
     computer_checks?: () => Promise<DoctorCheck[]>
     log: (line: string) => void
@@ -192,17 +211,30 @@ export const runUpgrade = async ({
         return { ok, message }
     }
     try {
-        const going = await goingRuns({ runs_dir, registry_path })
+        const going = await goingRuns({
+            runs_dir,
+            registry_path,
+            list_processes,
+        })
         if (!going.ok) {
             return say({ message: `Refused: ${going.error}`, ok: false })
         }
         if (going.runs.length > 0) {
+            const unchecked =
+                going.ps_error === null
+                    ? ''
+                    : ` Luca couldn't list the processes (${going.ps_error}), so every unfinished run counts as going.`
             return say({
-                message: `Refused: runs are going, so an upgrade would change their engine halfway. Wait for them to end (or stop them), then try again:\n${going.runs.map(describeRun).join('\n')}`,
+                message: `Refused: runs are going, so an upgrade would change their engine halfway.${unchecked} Wait for them to end (or stop them), then try again:\n${going.runs.map(describeRun).join('\n')}`,
                 ok: false,
             })
         }
         log('[luca upgrade] no run is going')
+        if (going.stopped.length > 0) {
+            log(
+                `[luca upgrade] These runs stopped before they ended, and nothing runs them now. They don't stop the upgrade. To go on with one on the new version, after the upgrade:\n${going.stopped.map((run) => `${describeRun(run)}: ${resumeCommand(run)}`).join('\n')}`
+            )
+        }
 
         let version: string
         if (to !== null) {
@@ -222,39 +254,48 @@ export const runUpgrade = async ({
             })
         }
 
-        const before = await fingerprint(board_dir)
+        const before = await boardFingerprint(board_dir)
         const spec = `${LUCA_PACKAGE}@${version}`
         log(`[luca upgrade] installing ${spec} (from ${installed_version})`)
         await bun.addGlobal({ spec })
         log(`[luca upgrade] installed ${spec}`)
 
-        const board = await setUpBoard({
-            command: 'luca upgrade',
+        let hand_off: HandOff
+        try {
+            hand_off = await new_install.finish({
+                version,
+                board_before: before,
+            })
+        } catch (error) {
+            return say({
+                message: `Luca ${version} is installed, but Luca couldn't start it to finish the upgrade (${reason(error)}). Run luca init to finish: it reloads the board and copies Luca's skills.`,
+                ok: false,
+            })
+        }
+        if (hand_off.handed_off) {
+            // The new install printed its own lines, its last one included.
+            return hand_off.exit_code === 0
+                ? { ok: true, message: `Luca ${version} is installed.` }
+                : say({
+                      message: `Luca ${version} is installed, but its last steps failed (exit ${hand_off.exit_code}). See above for what to fix.`,
+                      ok: false,
+                  })
+        }
+        log(
+            `[luca upgrade] ${hand_off.why}, so Luca ${installed_version} does the last steps.`
+        )
+        return await finishUpgrade({
+            version,
+            board_before: before,
+            home,
             paseo,
-            // Upgrade only reloads; `luca init` asks to turn plugins on.
-            ask: async () => false,
             board_dir,
+            skills_dir,
             engine_path,
             bun_path,
+            computer_checks,
             log,
         })
-        if (board.ok) {
-            const after = await fingerprint(board_dir)
-            if (before === null || after === null || before !== after) {
-                log(
-                    "[luca upgrade] The board's files changed: run /reload-skills in a Paseo chat so its slash commands are up to date."
-                )
-            }
-        }
-        const end = say({
-            message: board.ok
-                ? `Luca ${version} is installed.`
-                : `Luca ${version} is installed, but the board wasn't reloaded. Run luca init to fix it.`,
-            ok: board.ok,
-        })
-        const checks = (await computer_checks?.()) ?? []
-        for (const line of formatChecks({ checks })) log(line)
-        return { ...end, ok: end.ok && !hasProblem({ checks }) }
     } catch (error) {
         // Such as a failed `bun add -g` or registry lookup.
         return say({ message: reason(error), ok: false })

package/engine/config/config-fields.ts

@@ -0,0 +1,127 @@
+/**
+ * Reads of single config fields, each with the default the engine uses when
+ * the config leaves it out: the prepare and test time limits, how many
+ * prepares run at once, the decision model, the models block, and the feature
+ * map's path.
+ */
+import { normalize } from 'node:path'
+
+import {
+    DecisionModelConfigSchema,
+    ModelsConfigSchema,
+    type EngineConfig,
+    type ModelsConfig,
+} from './engine-config-schema'
+
+import type { DecisionModelId } from '../jev/jev-schemas'
+import { DEFAULT_COMMAND_TIMEOUT_MS } from '../shell/run-command'
+
+/**
+ * How long the prepare command may run when the config doesn't say: 30
+ * minutes. A first build in a fresh worktree can take many minutes
+ * (HeartGold's takes about 8), far past the 5 minutes other commands get.
+ */
+export const DEFAULT_PREPARE_TIMEOUT_MS = 30 * 60 * 1000
+
+/**
+ * The prepare command's time limit: the config's `prepare_timeout_ms`, else
+ * the default.
+ *
+ * @example
+ * prepareTimeoutOf({ config: { ...config, prepare_timeout_ms: 3_600_000 } }) // 3_600_000
+ */
+export const prepareTimeoutOf = ({
+    config,
+}: {
+    config: EngineConfig
+}): number => config.prepare_timeout_ms ?? DEFAULT_PREPARE_TIMEOUT_MS
+
+/**
+ * Each test command's time limit (#542): the config's `test_timeout_ms`,
+ * else the engine's default for any command. It holds for every run of a
+ * test command (baseline, red check, gates); types and lint keep the default.
+ *
+ * @example
+ * testTimeoutOf({ config: { ...config, test_timeout_ms: 900_000 } }) // 900_000
+ */
+export const testTimeoutOf = ({ config }: { config: EngineConfig }): number =>
+    config.test_timeout_ms ?? DEFAULT_COMMAND_TIMEOUT_MS
+
+/**
+ * How many prepare runs may go at once when the config doesn't say: 1. A
+ * build is often heavy on the CPU, so builds at the same time only slow each
+ * other down (HeartGold's four first builds took 19 to 25 minutes each at
+ * once, against 8 to 10 alone).
+ */
+export const DEFAULT_PREPARE_CONCURRENCY = 1
+
+/**
+ * How many prepare runs may go at once: the config's `prepare_concurrency`,
+ * else the default.
+ *
+ * @example
+ * prepareConcurrencyOf({ config: { ...config, prepare_concurrency: 2 } }) // 2
+ */
+export const prepareConcurrencyOf = ({
+    config,
+}: {
+    config: EngineConfig
+}): number => config.prepare_concurrency ?? DEFAULT_PREPARE_CONCURRENCY
+
+/**
+ * The decision model a run asks: the config's `decision_model.model`, else
+ * Clef (`DEFAULT_DECISION_MODEL`).
+ *
+ * @example
+ * decisionModelOf({ config: { ...config, decision_model: { model: '@cf/cloudflare/clef-flash' } } })
+ * // '@cf/cloudflare/clef-flash'
+ */
+export const decisionModelOf = ({
+    config,
+}: {
+    config: EngineConfig
+}): DecisionModelId =>
+    config.decision_model?.model ?? DecisionModelConfigSchema.parse({}).model
+
+/**
+ * The run's model floors and confidence bar: the config's `models`, else
+ * the schema's defaults (every floor `opus`).
+ *
+ * @example
+ * modelsOf({ config }).floors['test-writer'] // 'opus'
+ */
+export const modelsOf = ({ config }: { config: EngineConfig }): ModelsConfig =>
+    config.models ?? ModelsConfigSchema.parse({})
+
+/**
+ * The feature map's path (#583), in the form a worktree-relative path takes
+ * everywhere else (`normalize`, no leading `./`), or `null` with no map.
+ * `./docs/feature-map.md` and `docs//feature-map.md` are both
+ * `docs/feature-map.md`. The role rules, the permission rules, the prompts,
+ * and the red check all read the map's path here, so they agree on it
+ * whatever way the config spells it.
+ *
+ * @example
+ * featureMapPath({ config: { ...config, feature_map: './docs/feature-map.md' } }) // 'docs/feature-map.md'
+ */
+export const featureMapPath = ({
+    config,
+}: {
+    config: EngineConfig
+}): string | null =>
+    config.feature_map === undefined
+        ? null
+        : normalize(config.feature_map).replace(/^\.\//, '')
+
+/**
+ * Whether a feature map path names a folder of pages (#597): any path not
+ * ending in `.md`. The path alone decides, so the guard and the prompts,
+ * which never read the disk, agree with the red check. `loadEngineConfig`
+ * refuses such a path when it is a file, so a map file must end in `.md`.
+ *
+ * @example
+ * isFeatureMapFolder({ path: 'docs/feature-map' }) // true
+ * isFeatureMapFolder({ path: 'docs/feature-map.md' }) // false
+ */
+export const isFeatureMapFolder = ({ path }: { path: string }): boolean =>
+    !path.toLowerCase().endsWith('.md')

package/engine/config/config-reload.ts

@@ -0,0 +1,250 @@
+import isEqual from 'lodash/isEqual'
+import omit from 'lodash/omit'
+import reduce from 'lodash/reduce'
+import { z } from 'zod'
+
+import type { EngineConfig } from './engine-config'
+
+/**
+ * The config fields a resumed run takes from the repo's
+ * `.luca/config.json` again (#516). They say how the engine builds a
+ * checkout before its tests, how long a test may run, or which new docs
+ * may be committed, not what the tests are, so a run can change them
+ * halfway without making its earlier results wrong: a repo that swaps a
+ * slow `prepare` for a fast cached one gets it on the next resume.
+ *
+ * - `prepare`: the command run before each test run in a checkout.
+ * - `prepare_timeout_ms`: how long that command may run.
+ * - `prepare_concurrency`: how many prepare runs may go at once. The
+ *   prepare slots take the limit on each call (`prepareCheck`), so a new
+ *   one counts from the next prepare run.
+ * - `test_concurrency`: how many test runs may go at once (#544). The test
+ *   slots take the limit on each call (`inTestSlot`), as the prepare slots
+ *   do, so a new one counts from the next test run.
+ * - `test_timeout_ms`: how long each test command may run (#542). Each run
+ *   of a test command reads it then, so a new one counts from the next.
+ * - `test_case_timeout_ms`: how long one fast test may take (#580). Each run
+ *   of a fast test command reads it then, so a new one counts from the next.
+ * - `leftover_allow`: more new markdown the leftover scan lets through
+ *   (#520). Each scan reads it then, so a run stuck on a leftover can be
+ *   unstuck by allowing the file and resuming.
+ */
+export const RELOADED_FIELDS = [
+    'prepare',
+    'prepare_timeout_ms',
+    'prepare_concurrency',
+    'test_concurrency',
+    'test_timeout_ms',
+    'test_case_timeout_ms',
+    'leftover_allow',
+] as const
+
+/**
+ * The config fields a run keeps from its `run_started`, whatever the file
+ * says on a resume:
+ *
+ * - `checks`: the baseline, the red check, and the gates compare test
+ *   results across the run. A ticket takes another's baseline by commit
+ *   alone (`sharedBaselineStep` in `core/decide-build.ts`), and the red
+ *   check holds every old passing test of the baseline to the new run by
+ *   file and name (`checkRed` in `gates/red-check.ts`). A baseline taken
+ *   with old commands is not comparable with a run of new ones. Intake also
+ *   judged the run's tickets against these commands (a `bun` test command
+ *   for the red check).
+ * - `test_file_patterns`: which files are tests decides the red check, the
+ *   role rules, and which commits were the test-writer's.
+ * - `test_helper_patterns`: which non-test files the test-writer may write
+ *   (#619), as `test_file_patterns` says which test files it may.
+ * - `test_setup_files`: part of what the tests are, as `checks` is.
+ * - `feature_map`: says which test files belong to which feature (#583), as
+ *   `test_file_patterns` says which files are tests: the red check holds a
+ *   ticket's new test files to it, and the role rules let the test-writer
+ *   edit it.
+ * - `rule_files`: the rules lens judges against them; tickets already
+ *   reviewed were judged on the old ones.
+ * - `muninn`: the run's memory vault is fixed at start (`run_started.memory`).
+ * - `run_budget_tokens`: the budget the run's tokens are counted against,
+ *   and the board's, from `run_started`; a raise is a `retry` reply.
+ * - `decision_model`: the model shadow mode asks (#534), so a run's asks
+ *   are all of one model and can be scored together.
+ * - `models`: the model floors and the confidence bar (#603), so one run's
+ *   routing stays consistent.
+ * - `generators`: the commands writers may ask the engine to run (#618),
+ *   whose output is committed with the tickets, as the prompts named them.
+ */
+export const FROZEN_FIELDS = [
+    'checks',
+    'test_file_patterns',
+    'test_helper_patterns',
+    'test_setup_files',
+    'feature_map',
+    'rule_files',
+    'muninn',
+    'run_budget_tokens',
+    'decision_model',
+    'models',
+    'generators',
+] as const
+
+const positiveInt = z.number().int().positive().nullable()
+const patterns = z.array(z.string().min(1)).nullable()
+
+/**
+ * One reloaded field that changed: its value in the run before (`from`)
+ * and in the file now (`to`). `null` is a field left out, so a field added
+ * or removed is a change too.
+ */
+export const ConfigChangeSchema = z.discriminatedUnion('field', [
+    z.object({
+        field: z.literal('prepare'),
+        from: z.string().min(1).nullable(),
+        to: z.string().min(1).nullable(),
+    }),
+    z.object({
+        field: z.literal('prepare_timeout_ms'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('prepare_concurrency'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('test_concurrency'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('test_timeout_ms'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('test_case_timeout_ms'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('leftover_allow'),
+        from: patterns,
+        to: patterns,
+    }),
+])
+
+export type ConfigChange = z.infer<typeof ConfigChangeSchema>
+
+/**
+ * The reloaded fields whose value differs between the run's config
+ * (`current`) and the one just read (`next`), old to new, in
+ * `RELOADED_FIELDS` order. Frozen fields are never changes. Pure.
+ *
+ * @example
+ * configChanges({ current: { ...config, prepare: 'make' }, next: { ...config, prepare: 'make fast' } })
+ * // [{ field: 'prepare', from: 'make', to: 'make fast' }]
+ */
+export const configChanges = ({
+    current,
+    next,
+}: {
+    current: EngineConfig
+    next: EngineConfig
+}): ConfigChange[] => {
+    const all: ConfigChange[] = [
+        {
+            field: 'prepare',
+            from: current.prepare ?? null,
+            to: next.prepare ?? null,
+        },
+        {
+            field: 'prepare_timeout_ms',
+            from: current.prepare_timeout_ms ?? null,
+            to: next.prepare_timeout_ms ?? null,
+        },
+        {
+            field: 'prepare_concurrency',
+            from: current.prepare_concurrency ?? null,
+            to: next.prepare_concurrency ?? null,
+        },
+        {
+            field: 'test_concurrency',
+            from: current.test_concurrency ?? null,
+            to: next.test_concurrency ?? null,
+        },
+        {
+            field: 'test_timeout_ms',
+            from: current.test_timeout_ms ?? null,
+            to: next.test_timeout_ms ?? null,
+        },
+        {
+            field: 'test_case_timeout_ms',
+            from: current.test_case_timeout_ms ?? null,
+            to: next.test_case_timeout_ms ?? null,
+        },
+        {
+            field: 'leftover_allow',
+            from: current.leftover_allow ?? null,
+            to: next.leftover_allow ?? null,
+        },
+    ]
+    return all.filter(({ from, to }) => !isEqual(from, to))
+}
+
+const applyChange = ({
+    config,
+    change,
+}: {
+    config: EngineConfig
+    change: ConfigChange
+}): EngineConfig => {
+    switch (change.field) {
+        case 'prepare':
+            return change.to === null
+                ? omit(config, 'prepare')
+                : { ...config, prepare: change.to }
+        case 'prepare_timeout_ms':
+            return change.to === null
+                ? omit(config, 'prepare_timeout_ms')
+                : { ...config, prepare_timeout_ms: change.to }
+        case 'prepare_concurrency':
+            return change.to === null
+                ? omit(config, 'prepare_concurrency')
+                : { ...config, prepare_concurrency: change.to }
+        case 'test_concurrency':
+            return change.to === null
+                ? omit(config, 'test_concurrency')
+                : { ...config, test_concurrency: change.to }
+        case 'test_timeout_ms':
+            return change.to === null
+                ? omit(config, 'test_timeout_ms')
+                : { ...config, test_timeout_ms: change.to }
+        case 'test_case_timeout_ms':
+            return change.to === null
+                ? omit(config, 'test_case_timeout_ms')
+                : { ...config, test_case_timeout_ms: change.to }
+        case 'leftover_allow':
+            return change.to === null
+                ? omit(config, 'leftover_allow')
+                : { ...config, leftover_allow: change.to }
+    }
+}
+
+/**
+ * `config` with each change's new value: set, or left out for `null`. Pure.
+ *
+ * @example
+ * withConfigChanges({ config, changes: [{ field: 'prepare', from: 'make', to: null }] })
+ * // config without prepare
+ */
+export const withConfigChanges = ({
+    config,
+    changes,
+}: {
+    config: EngineConfig
+    changes: ConfigChange[]
+}): EngineConfig =>
+    reduce(
+        changes,
+        (next, change) => applyChange({ config: next, change }),
+        config
+    )