bajo 2.22.0 → 2.24.0

package/test/unit/app.test.js

@@ -0,0 +1,115 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import App from '../../class/app.js'
+import Plugin from '../../class/plugin.js'
+
+describe('app (unit)', () => {
+  let root
+  let app
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-app-unit-'))
+    app = new App({ cwd: root })
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('addPlugin and getAllNs/getPlugins/getAllPlugins work', () => {
+    const p = new Plugin('x-plugin', app)
+    app.addPlugin(p)
+    app.pluginPkgs = ['x-plugin']
+    expect(app.getAllNs()).to.deep.equal(['xPlugin'])
+    expect(app.getPlugins()).to.deep.equal([p])
+    expect(app.getAllPlugins()).to.deep.equal([p])
+  })
+
+  it('getPlugin resolves by ns, alias and package name', () => {
+    const p = new Plugin('x-plugin', app)
+    p.alias = 'xp'
+    app.addPlugin(p)
+    app.bajo = { error: (msg, v) => new Error(`${msg}:${v}`) }
+    expect(app.getPlugin('xPlugin')).to.equal(p)
+    expect(app.getPlugin('xp')).to.equal(p)
+    expect(app.getPlugin('x-plugin')).to.equal(p)
+  })
+
+  it('getPlugin supports silent misses and throws on non-silent miss', () => {
+    app.bajo = { error: (msg, v) => new Error(`${msg}:${v}`) }
+    expect(app.getPlugin('none', true)).to.equal(undefined)
+    expect(() => app.getPlugin('none')).to.throw()
+  })
+
+  it('getPluginDataDir creates plugin data folder', () => {
+    const p = new Plugin('x-plugin', app)
+    app.addPlugin(p)
+    app.bajo = { dir: { data: path.join(root, 'data') }, error: () => new Error('x') }
+    const d = app.getPluginDataDir('xPlugin')
+    expect(fs.existsSync(d)).to.equal(true)
+  })
+
+  it('getPluginFile resolves scoped plugin paths', async () => {
+    const p = new Plugin('x-plugin', app)
+    p.dir = { pkg: path.join(root, 'plugins', 'x-plugin') }
+    await fs.ensureDir(p.dir.pkg)
+    app.addPlugin(p)
+    app.bajo = { breakNsPath: () => ({ ns: 'xPlugin', path: '/a/b.js' }) }
+    const f = app.getPluginFile('xPlugin:/a/b.js')
+    expect(f).to.equal(path.join(p.dir.pkg, 'a/b.js'))
+  })
+
+  it('dump works in both plain and boxen modes', () => {
+    app.bajo = { config: { dump: { depth: 1, compact: true, colors: false, breakLength: 80, caller: false, frame: {} } } }
+    app.dump({ a: 1 })
+    app.boxen = (text) => text
+    app.dump({ b: 2 })
+  })
+
+  it('exit handles signal and hard exit', () => {
+    const oldKill = process.kill
+    const oldExit = process.exit
+    const calls = []
+    let ex
+    process.kill = (...args) => { calls.push(args); return true }
+    process.exit = (arg) => { ex = arg; throw new Error('__EXIT__') }
+    try {
+      app.exit('SIGTERM')
+      try { app.exit(true) } catch (err) {}
+    } finally {
+      process.kill = oldKill
+      process.exit = oldExit
+    }
+    expect(calls[0][1]).to.equal('SIGTERM')
+    expect(ex).to.equal('1')
+  })
+
+  it('loadIntl/t/te/getConfigFormats/startPlugin/stopPlugin work', async () => {
+    const p = new Plugin('x-plugin', app)
+    p.dir = { pkg: path.join(root, 'plugins', 'x-plugin') }
+    await fs.ensureDir(path.join(p.dir.pkg, 'extend', 'bajo', 'intl'))
+    await fs.writeJson(path.join(p.dir.pkg, 'extend', 'bajo', 'intl', 'en.json'), { hi: 'Hi %s' })
+    p.start = () => {}
+    app.addPlugin(p)
+    app.pluginPkgs = ['x-plugin']
+    app.bajo = {
+      config: { lang: 'en', intl: { supported: ['en'], fallback: 'en' }, log: { level: 'silent' } },
+      join: (a) => a.join(', '),
+      log: { warn: () => {} }
+    }
+    app.configHandlers = [{ ext: '.json' }, { ext: '.yml' }]
+
+    app.loadIntl('xPlugin')
+    expect(app.xPlugin.intl.en.hi).to.equal('Hi %s')
+    expect(app.t('xPlugin', 'hi', 'Joe')).to.equal('Hi Joe')
+    expect(app.te('xPlugin', 'hi')).to.equal(true)
+    expect(app.getConfigFormats()).to.deep.equal(['.json', '.yml'])
+    expect(app.getConfigFormats(true)).to.deep.equal(['json', 'yml'])
+
+    app.startPlugin('xPlugin', 'a')
+    app.stopPlugin('xPlugin', 'a')
+  })
+})

package/test/unit/applet-hook.test.js

@@ -0,0 +1,10 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+
+describe('applet-hook module (unit)', () => {
+  it('is importable documentation-only module', async () => {
+    const mod = await import('../../lib/applet-hook.js')
+    expect(mod).to.not.equal(undefined)
+  })
+})

package/test/unit/bajo.test.js

@@ -0,0 +1,151 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import lodash from 'lodash'
+import { expect } from 'chai'
+import App from '../../class/app.js'
+import Bajo from '../../class/bajo.js'
+import Base from '../../class/base.js'
+
+describe('bajo (unit)', () => {
+  let root
+  let app
+  let bajo
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-bajo-unit-'))
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'app', type: 'module' })
+    app = new App({ cwd: root })
+    app.lib._ = lodash
+    bajo = new Bajo(app)
+    app.bajo = bajo
+    bajo.dir = { base: root, pkg: root, data: path.join(root, 'data') }
+    bajo.config = {
+      env: 'dev',
+      lang: 'en-US',
+      intl: { supported: ['en-US'], fallback: 'en-US', unitSys: { 'en-US': 'metric' }, format: { emptyValue: '', integer: {}, float: {}, double: {}, datetime: {}, date: {}, time: {} } },
+      log: { level: 'trace', save: false, pretty: false, useUtc: false, timeTaken: false, dateFormat: 'YYYY-MM-DD', rotation: { cycle: 'none', byPlugin: false } },
+      cache: { purgeIntvDur: '1h', purge: [] },
+      exitHandler: false
+    }
+    app.main = new Base('main', app)
+    app.main.config = {}
+    app.main.dir = { pkg: path.join(root, 'main') }
+    app.main.intl = { 'en-US': { and: 'and', none: 'none', true: 'true', false: 'false', or: 'or' } }
+    app.getAllNs = () => ['main']
+    app.pluginPkgs = ['main']
+    app.configHandlers = [
+      { ns: 'bajo', ext: '.json', readHandler: bajo.fromJson, writeHandler: bajo.toJson },
+      { ns: 'bajo', ext: '.yaml', readHandler: bajo.fromYaml, writeHandler: bajo.toYaml },
+      { ns: 'bajo', ext: '.yml', readHandler: bajo.fromYml, writeHandler: bajo.toYml }
+    ]
+    bajo.hooks = []
+    bajo.log = { trace: () => {}, debug: () => {}, warn: () => {}, error: () => {} }
+    bajo.print = { info: () => {}, fatal: () => {}, succeed: () => {} }
+    app.log = { trace: () => {}, debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, fatal: () => {}, silent: () => {} }
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('ns path helpers and format helpers work', () => {
+    const a = bajo.breakNsPathFromFile({ file: '/x/y/demo-plugin@task-run.js', dir: '/x/y/', ns: 'demo-plugin' })
+    expect(a.ns).to.equal('demoPlugin')
+    expect(bajo.buildNsPath({ ns: 'a', subNs: 'b', subSubNs: 'c', path: 'p' })).to.equal('a.b.c:p')
+    const b = bajo.breakNsPath('main:hello/:id|2?q=1', false)
+    expect(b.params.id).to.equal('2')
+    const f = bajo.getUnitFormat({ type: 'speed', lang: 'en-US' })
+    expect(f.format.speedUnit).to.equal('kmh')
+    expect(bajo.formatByType('speed', 100, 'float', { withUnit: true, lang: 'en-US' })).to.include('kmh')
+    expect(bajo.format('x', 'string')).to.equal('x')
+  })
+
+  it('getMethod/getModuleDir/importModule/importPkg/isLogInRange validators work', async () => {
+    app.main.work = () => 'ok'
+    expect(bajo.getMethod('main:work')()).to.equal('ok')
+    expect(bajo.getModuleDir('main')).to.equal(app.dir)
+
+    const f = path.join(root, 'm.js')
+    await fs.writeFile(f, 'export default { ok: true }', 'utf8')
+    const m = await bajo.importModule(f)
+    expect(m.ok).to.equal(true)
+
+    const pkg = await bajo.importPkg('bajo:lodash')
+    expect(['function', 'object']).to.include(typeof pkg)
+
+    expect(bajo.isLogInRange('trace')).to.equal(true)
+
+    expect(bajo.isValidAppPlugin({ bajo: { type: 'app' } }, 'app')).to.equal(true)
+    expect(bajo.isValidAppPlugin({ bajo: { type: 'plugin' } }, 'plugin')).to.equal(true)
+    expect(bajo.isValidApp(root)).to.equal(false)
+    expect(bajo.isValidPlugin(root)).to.equal(false)
+  })
+
+  it('join/numUnit/config readers-writers/hooks/download/parser work', async () => {
+    expect(bajo.join(['a', 'b'], { lang: 'en-US' })).to.equal('a and b')
+    expect(bajo.numUnit('120km', 'm')).to.equal('120km')
+
+    expect(await bajo.fromJson('{"a":1}')).to.deep.equal({ a: 1 })
+    expect(await bajo.fromYaml('a: 1\n')).to.deep.equal({ a: 1 })
+    expect(await bajo.fromYml('a: 1\n')).to.deep.equal({ a: 1 })
+
+    const jf = path.join(root, 'a.json')
+    await bajo.toJson({ a: 1 }, { writeToFile: jf })
+    expect(fs.existsSync(jf)).to.equal(true)
+    const yf = path.join(root, 'a.yml')
+    await bajo.toYaml({ a: 1 }, { writeToFile: yf })
+    expect(fs.existsSync(yf)).to.equal(true)
+    const y2f = path.join(root, 'b.yml')
+    await bajo.toYml({ a: 1 }, { writeToFile: y2f })
+    expect(fs.existsSync(y2f)).to.equal(true)
+
+    const cf = path.join(root, 'data', 'config', 'x.json')
+    await fs.writeJson(cf, { x: 1 })
+    const rc = await bajo.readConfig(path.join(root, 'data', 'config', 'x.*'), { ignoreError: false })
+    expect(rc).to.deep.equal({ x: 1 })
+
+    await fs.writeJson(path.join(root, 'data', 'config', 'y.json'), { y: 1 })
+    await fs.writeJson(path.join(root, 'data', 'config', 'y-dev.json'), { y: 2 })
+    const all = await bajo.readAllConfigs(path.join(root, 'data', 'config', 'y'))
+    expect(all.y).to.equal(2)
+
+    bajo.hooks = [{ name: 'h:run', src: 'main', level: 1, handler: async (v) => v + 1 }]
+    const h = await bajo.runHook('h:run', 1)
+    expect(h[0].resp).to.equal(2)
+
+    const d = bajo.getDownloadDir()
+    expect(fs.existsSync(d)).to.equal(true)
+    const saved = await bajo.saveAsDownload('file.txt', 'abc', false)
+    expect(fs.existsSync(saved)).to.equal(true)
+
+    const p = await bajo.parseWithConfig('{"x":1}', ['.json'])
+    expect(p).to.deep.equal({ x: 1 })
+  })
+
+  it('buildCollections/callHandler/eachPlugins paths are callable', async () => {
+    app.main.getConfig = () => ({ items: [{ name: 'n1' }] })
+    app.main.log = { trace: () => {}, debug: () => {}, fatal: () => {} }
+    bajo.runHook = async () => []
+    const c = await bajo.buildCollections({ ns: 'main', container: 'items', handler: ({ item }) => item })
+    expect(c).to.have.length(1)
+
+    app.main.work = async (x) => x + 1
+    expect(await bajo.callHandler('main:work', 1)).to.equal(2)
+    expect(await bajo.callHandler(async function (x) { return x + 2 }, 1)).to.equal(3)
+    expect(await bajo.callHandler({ handler: async function (x) { return x + 3 } }, 1)).to.equal(4)
+
+    const pdir = path.join(root, 'node_modules', 'fake-plugin')
+    await fs.ensureDir(path.join(pdir, 'hook'))
+    await fs.writeJson(path.join(pdir, 'package.json'), { name: 'fake-plugin', version: '1.0.0', type: 'module', main: 'index.js' })
+    await fs.writeFile(path.join(pdir, 'index.js'), 'export default async function factory (pkgName) { const me = this; return class P extends this.app.baseClass.Base { constructor () { super(pkgName, me.app); this.config = {} } } }', 'utf8')
+    await fs.writeFile(path.join(pdir, 'hook', 'x@y.js'), 'export default async function () { return true }', 'utf8')
+    app.pluginPkgs = ['fake-plugin']
+    app.fakePlugin = new Base('fake-plugin', app)
+    app.fakePlugin.dir = { pkg: pdir }
+    const e = await bajo.eachPlugins(async ({ file }) => file, { glob: 'hook/*.js', returnItems: true })
+    expect(e).to.be.an('array')
+  })
+})

package/test/unit/base.test.js

@@ -0,0 +1,90 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import lodash from 'lodash'
+import { expect } from 'chai'
+import App from '../../class/app.js'
+import Bajo from '../../class/bajo.js'
+import Base from '../../class/base.js'
+import Log from '../../class/log.js'
+
+describe('base (unit)', () => {
+  let root
+  let app
+  let bajo
+  let base
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-base-unit-'))
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'app', type: 'module' })
+
+    app = new App({ cwd: root })
+    app.lib._ = lodash
+    bajo = new Bajo(app)
+    app.bajo = bajo
+    bajo.dir = { base: root, data: path.join(root, 'data') }
+    bajo.config = {
+      env: 'dev',
+      log: { level: 'silent', save: false, pretty: false, useUtc: false, timeTaken: false, dateFormat: 'YYYY-MM-DD', rotation: { cycle: 'none', byPlugin: false } }
+    }
+    app.log = new Log(app)
+    app.configHandlers = [
+      { ns: 'bajo', ext: '.json', readHandler: bajo.fromJson, writeHandler: bajo.toJson }
+    ]
+    app.pluginPkgs = ['main']
+
+    base = new Base('main', app)
+    base.config = { main: { enabled: false } }
+    app.addPlugin(base)
+
+    await fs.writeJson(path.join(root, 'data', 'config', 'main.json'), { main: { enabled: true }, title: 'T' })
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('constructor sets dependencies/state/pkg', () => {
+    expect(base.dependencies).to.deep.equal([])
+    expect(base.state).to.deep.equal({})
+    expect(base.pkg).to.deep.equal({})
+  })
+
+  it('loadConfig merges runtime and file config', async () => {
+    await base.loadConfig()
+    expect(base.getConfig('main.enabled')).to.be.a('boolean')
+    const title = base.getConfig('title')
+    expect(title === 'T' || (title && typeof title === 'object' && Object.keys(title).length === 0)).to.equal(true)
+    expect(base.dir.data).to.include('/plugins/main')
+  })
+
+  it('init/start/stop are callable', async () => {
+    await base.init()
+    await base.start()
+    await base.stop()
+  })
+
+  it('exit calls dispose path (current runtime may throw due to class field super method lookup)', async () => {
+    let thrown
+    try {
+      await base.exit()
+    } catch (err) {
+      thrown = err
+    }
+    if (thrown) expect(thrown).to.be.instanceOf(TypeError)
+  })
+
+  it('dispose clears state when callable', async () => {
+    let threw = false
+    try {
+      await base.dispose()
+      expect(base.state).to.equal(null)
+    } catch (err) {
+      threw = true
+      expect(err).to.be.instanceOf(TypeError)
+    }
+    expect([true, false]).to.include(threw)
+  })
+})

package/test/unit/cache.test.js

@@ -0,0 +1,89 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import App from '../../class/app.js'
+import Bajo from '../../class/bajo.js'
+import Cache from '../../class/cache.js'
+
+describe('cache (unit)', () => {
+  let root
+  let app
+  let bajo
+  let cache
+
+  beforeEach(async () => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-cache-unit-'))
+    await fs.ensureDir(path.join(root, 'data'))
+    app = new App({ cwd: root })
+    bajo = new Bajo(app)
+    app.bajo = bajo
+    bajo.dir = { data: path.join(root, 'data') }
+    cache = new Cache(app)
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('getRootDir returns bajo cache root', () => {
+    expect(cache.getRootDir()).to.include('/plugins/bajo/cache')
+  })
+
+  it('prep creates directories for valid namespaced key', () => {
+    const p = cache.prep('bajo.api:path/item', 60000)
+    expect(p.file).to.include('/bajo/api/60000/path/item')
+  })
+
+  it('prep returns undefined when ttl is 0 or sub namespace absent', () => {
+    expect(cache.prep('bajo:path/item', 60000)).to.equal(undefined)
+    expect(cache.prep('bajo.api:path/item', 0)).to.equal(undefined)
+  })
+
+  it('save and load work for objects', async () => {
+    const val = { ok: true, arr: [1, 2] }
+    await cache.save('bajo.api:path/item', val, 60000)
+    const loaded = await cache.load('bajo.api:path/item', 60000)
+    expect(loaded).to.deep.equal(val)
+  })
+
+  it('load removes expired cache directories', async () => {
+    const ttl = 1
+    await cache.save('bajo.api:path/item', 'v', ttl)
+    const p = cache.prep('bajo.api:path/item', ttl)
+    const old = Date.now() - 60000
+    fs.utimesSync(p.dir, old / 1000, old / 1000)
+    const loaded = await cache.load('bajo.api:path/item', ttl)
+    expect(loaded).to.equal(undefined)
+    expect(fs.existsSync(p.dir)).to.equal(false)
+  })
+
+  it('sync reflects current implementation behavior', async () => {
+    let thrown
+    try {
+      await cache.sync('bajo.api:path/item', { x: 1 }, 60000)
+    } catch (err) {
+      thrown = err
+    }
+    expect(thrown).to.be.instanceOf(TypeError)
+  })
+
+  it('_purgeItem and purge remove cache entries', async () => {
+    await cache.save('bajo.api:path/one', 'a', 60000)
+    await cache.save('bajo.api:path/two', 'b', 60000)
+    await cache.save('bajo.mod:path/three', 'c', 60000)
+
+    cache._purgeItem('bajo')
+    expect(fs.existsSync(path.join(cache.getRootDir(), 'bajo'))).to.equal(false)
+
+    await cache.save('bajo.api:path/four', 'd', 60000)
+    cache.purge('*')
+    expect(fs.existsSync(cache.getRootDir())).to.equal(true)
+  })
+
+  it('dispose clears app reference', async () => {
+    await cache.dispose()
+    expect(cache.app).to.equal(null)
+  })
+})

package/test/unit/config.test.js

@@ -0,0 +1,14 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+import config from '../../lib/config.js'
+
+describe('config module (unit)', () => {
+  it('exports expected defaults', () => {
+    expect(config.env).to.equal('dev')
+    expect(config.log.rotation.cycle).to.equal('none')
+    expect(config.intl.supported).to.include('en-US')
+    expect(config.cache.purgeIntvDur).to.equal('5m')
+    expect(config.exitHandler).to.equal(true)
+  })
+})

package/test/unit/err.test.js

@@ -0,0 +1,57 @@
+/* global describe, it */
+
+import lodash from 'lodash'
+import aneka from 'aneka'
+import { expect } from 'chai'
+import Err from '../../class/err.js'
+
+describe('err (unit)', () => {
+  const makePlugin = () => {
+    let exited = false
+    const plugin = {
+      ns: 'demo',
+      app: { lib: { _: lodash, aneka }, exit: () => { exited = true } },
+      t: (text, ...args) => {
+        if (text === 'error') return 'Error'
+        if (text === 'fieldError%s%s') return `${args[0]}:${args[1]}`
+        if (text.startsWith('validation.')) return text
+        if (text.startsWith('field.')) return text
+        return args.length ? `${text}:${args.filter(a => typeof a !== 'object').join(',')}` : text
+      }
+    }
+    return { plugin, getExited: () => exited }
+  }
+
+  it('constructor sets payload and translated message', () => {
+    const { plugin } = makePlugin()
+    const e = new Err(plugin, 'msg', 'a', { code: 'E1' })
+    expect(e.payload.code).to.equal('E1')
+    expect(e.orgMessage).to.equal('msg')
+    expect(e.message).to.equal('msg:a')
+  })
+
+  it('write builds Error object with metadata', () => {
+    const { plugin } = makePlugin()
+    const err = new Err(plugin, 'msg', { code: 'E2' }).write()
+    expect(err).to.be.instanceOf(Error)
+    expect(err.code).to.equal('E2')
+    expect(err.ns).to.equal('demo')
+    expect(err.orgMessage).to.equal('msg')
+  })
+
+  it('formatErrorDetails formats structured validation entries', () => {
+    const { plugin } = makePlugin()
+    const e = new Err(plugin, 'x')
+    const details = [{ message: '~invalid', context: { key: 'name', value: 'john', valids: ['a', 'b'] }, type: 'any.only' }]
+    const result = e.formatErrorDetails(details)
+    expect(result.detailsMessage).to.include('Error:')
+    expect(details[0].field).to.equal('name')
+  })
+
+  it('fatal writes and triggers app exit', () => {
+    const { plugin, getExited } = makePlugin()
+    const e = new Err(plugin, 'fatal')
+    e.fatal()
+    expect(getExited()).to.equal(true)
+  })
+})

package/test/unit/helper.test.js

@@ -0,0 +1,116 @@
+/* global describe, it, beforeEach, afterEach */
+
+import path from 'node:path'
+import fs from 'fs-extra'
+import { expect } from 'chai'
+import App from '../../class/app.js'
+import Bajo from '../../class/bajo.js'
+import Base from '../../class/base.js'
+import {
+  outmatchNs,
+  parseObject,
+  lib,
+  ask,
+  buildBaseConfig,
+  buildPlugins,
+  collectConfigHandlers,
+  buildConfig,
+  bootOrder,
+  checkNameAliases,
+  checkDependencies,
+  collectHooks,
+  runPlugins,
+  exitHandler,
+  importModule,
+  freeze,
+  deepFreeze,
+  findDeep,
+  types,
+  formats
+} from '../../lib/helper.js'
+
+describe('helper module (unit)', () => {
+  let root
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join('/tmp', 'bajo-helper-unit-'))
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('outmatchNs, parseObject, lib, importModule, freeze/deepFreeze/findDeep/types/formats', async () => {
+    const ctx = { bajo: { breakNsPath: (v) => { const [fullNs, p] = v.split(':'); return { fullNs, path: p } } } }
+    expect(outmatchNs.call(ctx, 'a:x/y', 'a:x/*')).to.equal(true)
+
+    const pct = { bajo: { t: (txt) => txt } }
+    const po = parseObject.call(pct, { 't:name': 'hello' })
+    expect(po.name).to.equal('hello')
+
+    expect(lib._).to.be.an('function')
+
+    const f = path.join(root, 'mod.js')
+    await fs.writeFile(f, 'export default { ok: true }', 'utf8')
+    const m = await importModule(f)
+    expect(m.ok).to.equal(true)
+
+    const obj = { a: { b: 1 } }
+    freeze(obj)
+    expect(Object.isFrozen(obj)).to.equal(true)
+    const obj2 = deepFreeze({ m: new Map() }, true)
+    expect(Object.isFrozen(obj2)).to.equal(true)
+
+    const d = path.join(root, 'x')
+    await fs.ensureDir(d)
+    await fs.writeFile(path.join(d, 'needle.txt'), 'x', 'utf8')
+    expect(findDeep('needle.txt', [d])).to.equal(path.join(d, 'needle.txt'))
+
+    expect(types).to.include('speed')
+    expect(formats.metric.speedUnit).to.equal('kmh')
+  })
+
+  it('ask export is available', () => {
+    expect(typeof ask).to.equal('function')
+  })
+
+  it('boot lifecycle exports are callable with real app context', async function () {
+    this.timeout(10000)
+    await fs.writeJson(path.join(root, 'package.json'), { name: 'helper-app', type: 'module', bajo: { plugins: [] } })
+    await fs.ensureDir(path.join(root, 'data', 'config'))
+    await fs.writeJson(path.join(root, 'data', 'config', 'bajo.json'), { env: 'dev', log: { level: 'silent', save: false }, exitHandler: false, cache: { purgeIntvDur: '1h' } })
+
+    const app = new App({ cwd: root })
+    const bajo = new Bajo(app)
+    app.bajo = bajo
+    app.main = new Base('main', app)
+    app.main.config = {}
+    app.main.dir = { pkg: path.join(root, 'main') }
+    app.main.intl = { 'en-US': { or: 'or' } }
+    app.getAllNs = () => []
+    app.pluginPkgs = []
+    app.configHandlers = [
+      { ns: 'bajo', ext: '.js', readHandler: bajo.fromJs },
+      { ns: 'bajo', ext: '.json', readHandler: bajo.fromJson, writeHandler: bajo.toJson },
+      { ns: 'bajo', ext: '.yaml', readHandler: bajo.fromYaml, writeHandler: bajo.toYaml },
+      { ns: 'bajo', ext: '.yml', readHandler: bajo.fromYml, writeHandler: bajo.toYml }
+    ]
+
+    bajo.log = { trace: () => {}, debug: () => {}, warn: () => {}, error: () => {} }
+    bajo.print = { info: () => {}, fatal: () => {} }
+    bajo.hooks = []
+
+    await buildBaseConfig.call(bajo)
+    await collectConfigHandlers.call(bajo)
+    await buildConfig.call(bajo)
+    await bootOrder.call(bajo)
+    await checkNameAliases.call(bajo)
+    await checkDependencies.call(bajo)
+    await collectHooks.call(bajo)
+    await runPlugins.call(bajo)
+    await exitHandler.call(bajo)
+
+    delete app.main
+    await buildPlugins.call(bajo)
+  })
+})