refactor(config): track per-hook ran flag, replace runHooksFrom indices

The old API exposed two coupled primitives — hooksCount() / runHooksFrom(N) —
that pushed positional bookkeeping onto the caller. Container.create snapshotted
the count before plugin boot and replayed everything past that index after.
Brittle: any future change that reorders or removes hooks would silently
re-run the wrong ones.

Replace with a per-hook { fn, ran } record and a single runPendingHooks(cfg)
that fires anything not yet applied to the current config. Caller no longer
deals with indices:

    if (Config.runPendingHooks(config)) {
      // re-feed helper config…
    }

Behavior is unchanged for the existing flow:
- create() rebuilds config and re-runs every hook (marks all ran).
- A hook registered after create() is pending until runPendingHooks() picks it up.
- Hooks registered while runPendingHooks() is running are picked up in the
  same pass (loop re-checks length each iteration).

Internal API only — no other call sites in the repo or test suite.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: DavertMik

lib/config.js

@@ -32,6 +32,7 @@ const defaultConfig = {
   ],
 }
 
+/** @type {Array<{ fn: (cfg: object) => void, ran: boolean }>} */
 let hooks = []
 let config = {}
 
@@ -49,7 +50,12 @@ class Config {
    */
   static create(newConfig) {
     config = deepMerge(deepClone(defaultConfig), newConfig)
-    hooks.forEach(f => f(config))
+    // Re-apply every hook against the freshly built config and mark them ran;
+    // hooks added later (e.g. from plugin boot) stay pending until runPendingHooks.
+    for (let i = 0; i < hooks.length; i++) {
+      hooks[i].fn(config)
+      hooks[i].ran = true
+    }
     return config
   }
 
@@ -121,25 +127,31 @@ class Config {
   }
 
   static addHook(fn) {
-    hooks.push(fn)
-  }
-
-  /**
-   * Number of registered config hooks. Useful for snapshotting before a phase
-   * (e.g. plugin loading) and re-running only the hooks added during it.
-   * @return {number}
-   */
-  static hooksCount() {
-    return hooks.length
+    hooks.push({ fn, ran: false })
   }
 
   /**
-   * Run hooks in `[fromIndex, end)` against the given config object, mutating it.
-   * @param {number} fromIndex
-   * @param {Object<string, *>} cfg
+   * Run every hook that hasn't been applied to the current config yet.
+   * Hooks added after `Config.create()` (e.g. by a plugin's boot code) stay
+   * pending until this is called; once it runs, they're marked applied so
+   * subsequent calls are no-ops.
+   *
+   * Hooks registered while pending hooks are running are picked up too —
+   * the loop re-checks length on each iteration.
+   *
+   * @param {Object<string, *>} [cfg] target config (defaults to the live singleton)
+   * @return {boolean} true if any hook ran
    */
-  static runHooksFrom(fromIndex, cfg) {
-    for (let i = fromIndex; i < hooks.length; i++) hooks[i](cfg)
+  static runPendingHooks(cfg = config) {
+    let ran = false
+    for (let i = 0; i < hooks.length; i++) {
+      const h = hooks[i]
+      if (h.ran) continue
+      h.fn(cfg)
+      h.ran = true
+      ran = true
+    }
+    return ran
   }
 
   /**

lib/container.js

@@ -77,7 +77,6 @@ class Container {
     container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
     container.proxySupportConfig = config.include || {}
     container.proxySupport = createSupportObjects(container.proxySupportConfig)
-    const hooksBeforePlugins = Config.hooksCount()
     container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
@@ -123,10 +122,11 @@ class Container {
     // Wait for all async helpers to finish loading and populate the actor
     await asyncHelperPromise
 
-    // If plugins registered any Config hooks during their boot, run them now
-    // and re-apply the (possibly mutated) helper config to already-instantiated helpers.
-    if (Config.hooksCount() > hooksBeforePlugins) {
-      Config.runHooksFrom(hooksBeforePlugins, config)
+    // Plugins may have registered Config hooks during their boot (e.g. the
+    // browser plugin pushing `setBrowserConfig` overrides). Run anything that
+    // hasn't been applied yet and re-feed the mutated helper config to the
+    // already-instantiated helpers.
+    if (Config.runPendingHooks(config)) {
       for (const name of Object.keys(container.helpers)) {
         const helper = container.helpers[name]
         if (helper && typeof helper._setConfig === 'function' && config.helpers && config.helpers[name]) {