@alt-javascript/boot-camel-lite-starter 1.0.2

package/README.md

@@ -0,0 +1,83 @@
+# boot-camel-lite-starter
+
+`@alt-javascript/boot` CDI auto-configuration for camel-lite core plus the eight most common components: `direct`, `seda`, `log`, `file`, `http`, `ftp`, `timer`, and `cron`.
+
+## Install
+
+```sh
+npm install boot-camel-lite-starter @alt-javascript/boot @alt-javascript/cdi @alt-javascript/config
+```
+
+## CDI Beans Registered
+
+| Bean name | Type | Description |
+|-----------|------|-------------|
+| `camelLiteContext` | `CamelContext` | The running Camel context |
+| `routeRegistry` | `RouteRegistry` | Scans config + CDI for routes and loads them into the context |
+| `camelComponent.direct` | `DirectComponent` | `direct:` scheme |
+| `camelComponent.seda` | `SedaComponent` | `seda:` scheme |
+| `camelComponent.log` | `LogComponent` | `log:` scheme |
+| `camelComponent.file` | `FileComponent` | `file:` scheme |
+| `camelComponent.http` | `HttpComponent` | `http:`/`https:` scheme (producer only) |
+| `camelComponent.ftp` | `FtpComponent` | `ftp:` scheme |
+| `camelComponent.timer` | `TimerComponent` | `timer:` scheme |
+| `camelComponent.cron` | `CronComponent` | `cron:` scheme |
+| `camelProducerTemplate` | `ProducerTemplate` | Send messages programmatically |
+| `camelConsumerTemplate` | `ConsumerTemplate` | Poll endpoints programmatically |
+
+## Configuration
+
+All keys are nested under `boot.camel-lite`.
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `boot.camel-lite.<scheme>.enabled` | boolean | `true` | Set to `false` to skip registering that component bean |
+| `boot.camel-lite.routes[n].definition` | object | — | An already-parsed route definition object (equivalent to a parsed YAML route file) |
+
+### Config route definition example
+
+```yaml
+boot:
+  camel-lite:
+    routes:
+      - definition:
+          - from: "direct:hello"
+            steps:
+              - log: "${body}"
+              - to: "direct:world"
+```
+
+`@alt-javascript/config` deserialises this at load time; the starter passes it to `RouteLoader.loadObject()` to avoid a double-parse.
+
+## Usage
+
+```js
+import { camelLiteStarter } from 'boot-camel-lite-starter';
+
+const { applicationContext } = await camelLiteStarter({ config: cfg });
+
+const ctx = applicationContext.get('camelLiteContext');
+await ctx.ready();
+
+const pt = applicationContext.get('camelProducerTemplate');
+await pt.sendBody('direct:hello', 'world');
+```
+
+## CDI RouteBuilder Discovery
+
+Any CDI bean that exposes a `configure(camelContext)` method is treated as a RouteBuilder and discovered automatically by `RouteRegistry`. No explicit registration is required — declare the bean in your CDI config array and give it a `configure` method:
+
+```js
+class GreetingRoutes {
+  configure(camelContext) {
+    camelContext
+      .from('direct:greet')
+      .log('${body}');
+  }
+}
+```
+
+## See Also
+
+- [camel-lite root README](../../README.md)
+- [boot-camel-lite-extras-starter README](../boot-camel-lite-extras-starter/README.md)

package/index.js

@@ -0,0 +1,76 @@
+/**
+ * boot-camel-lite-starter
+ *
+ * CDI auto-configuration for camel-lite.
+ * Bundles: core + direct, seda, log, file, http, ftp, timer, cron.
+ *
+ * Usage:
+ *   import { camelLiteStarter } from '@alt-javascript/boot-camel-lite-starter';
+ *
+ *   const { applicationContext } = await camelLiteStarter({
+ *     config: {
+ *       'boot.camel-lite.routes': [
+ *         { definition: { route: { from: { uri: 'direct:hello', steps: [{ log: { simple: '${body}' } }] } } } }
+ *       ]
+ *     },
+ *     contexts: [new Context([new Singleton(MyRouteBuilder)])],
+ *   });
+ *
+ *   const ctx = applicationContext.get('camelLiteContext');
+ *   await ctx.ready();
+ *
+ *   const pt = applicationContext.get('camelProducerTemplate');
+ *   await pt.sendBody('direct:hello', 'world');
+ *
+ * Config keys (prefix: boot.camel-lite):
+ *   boot.camel-lite.<scheme>.enabled     — enable/disable bundled component (default: true)
+ *   boot.camel-lite.routes[n].definition — already-parsed route definition object
+ */
+
+import { ApplicationContext } from '@alt-javascript/cdi';
+import { EphemeralConfig } from '@alt-javascript/config';
+import {
+  camelLiteAutoConfiguration,
+  CamelLiteContext,
+  RouteRegistry,
+  CdiProducerTemplate,
+  CdiConsumerTemplate,
+} from './src/CamelLiteAutoConfiguration.js';
+
+export {
+  camelLiteAutoConfiguration,
+  CamelLiteContext,
+  RouteRegistry,
+  CdiProducerTemplate,
+  CdiConsumerTemplate,
+};
+
+export { PREFIX } from './src/CamelLiteAutoConfiguration.js';
+
+/**
+ * Boot the application with camel-lite auto-configuration.
+ *
+ * @param {object} options
+ * @param {Array}   [options.contexts]    — CDI Context array (your beans)
+ * @param {object}  [options.config]      — config object or POJO
+ * @param {object}  [options.startOptions] — forwarded to ApplicationContext.start()
+ * @returns {Promise<{applicationContext: ApplicationContext}>}
+ */
+export async function camelLiteStarter(options = {}) {
+  const { contexts = [], config, startOptions = {} } = options;
+
+  const cfg = config instanceof Object && typeof config.has === 'function'
+    ? config
+    : new EphemeralConfig(config ?? {});
+
+  const autoConfig = await camelLiteAutoConfiguration(options);
+
+  const applicationContext = new ApplicationContext({
+    config: cfg,
+    contexts: [...contexts, autoConfig],
+    ...startOptions,
+  });
+
+  await applicationContext.start();
+  return { applicationContext };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@alt-javascript/boot-camel-lite-starter",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "@alt-javascript/boot": "^3.0.7",
+    "@alt-javascript/cdi": "^3.0.7",
+    "@alt-javascript/config": "^3.0.7",
+    "@alt-javascript/logger": "^3.0.7",
+    "@alt-javascript/common": "^3.0.7",
+    "@alt-javascript/camel-lite-core": "1.0.2",
+    "@alt-javascript/camel-lite-component-direct": "1.0.2",
+    "@alt-javascript/camel-lite-component-seda": "1.0.2",
+    "@alt-javascript/camel-lite-component-log": "1.0.2",
+    "@alt-javascript/camel-lite-component-file": "1.0.2",
+    "@alt-javascript/camel-lite-component-http": "1.0.2",
+    "@alt-javascript/camel-lite-component-ftp": "1.0.2",
+    "@alt-javascript/camel-lite-component-timer": "1.0.2",
+    "@alt-javascript/camel-lite-component-cron": "1.0.2"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alt-javascript/camel-lite"
+  },
+  "author": "Craig Parravicini",
+  "contributors": [
+    "Claude (Anthropic)",
+    "Apache Camel — design inspiration and pattern source"
+  ],
+  "keywords": [
+    "alt-javascript",
+    "camel",
+    "camel-lite",
+    "eai",
+    "eip",
+    "integration",
+    "boot",
+    "starter",
+    "cdi",
+    "dependency-injection",
+    "autoconfigure"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/CamelLiteAutoConfiguration.js

@@ -0,0 +1,338 @@
+/**
+ * CamelLiteAutoConfiguration — CDI auto-configuration for camel-lite.
+ *
+ * Registers the following CDI beans:
+ *
+ *   camelLiteContext      — wraps CamelContext; async start via init()/ready()/destroy()
+ *   routeRegistry         — discovers CDI RouteBuilder beans + config route objects
+ *   direct/seda/log/...   — one ConfiguredComponent per scheme (8 bundled)
+ *   camelProducerTemplate — ProducerTemplate CDI bean
+ *   camelConsumerTemplate — ConsumerTemplate CDI bean
+ *
+ * Config prefix: boot.camel-lite
+ *
+ * Per-scheme enable/disable:
+ *   boot.camel-lite.direct.enabled = false   → DirectComponent not registered
+ *   (default: true for all bundled schemes)
+ *
+ * Route definitions from config:
+ *   boot.camel-lite.routes[0].definition: { route: { from: { uri: ..., steps: [...] } } }
+ *   (already-parsed JS object — @alt-javascript/config deserialises at load time)
+ *
+ * CDI RouteBuilder discovery:
+ *   Any CDI bean with a configure(camelContext) method is treated as a RouteBuilder.
+ */
+
+import { LoggerFactory } from '@alt-javascript/logger';
+import { CamelContext, RouteLoader, ProducerTemplate, ConsumerTemplate } from '@alt-javascript/camel-lite-core';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/boot/CamelLiteAutoConfiguration');
+
+export const PREFIX = 'boot.camel-lite';
+
+// ---------------------------------------------------------------------------
+// CamelLiteContext
+// ---------------------------------------------------------------------------
+
+export class CamelLiteContext {
+  constructor() {
+    this._applicationContext = null;
+    this._camelContext = null;
+    this._startPromise = null;
+  }
+
+  setApplicationContext(ctx) {
+    this._applicationContext = ctx;
+  }
+
+  get camelContext() {
+    return this._camelContext;
+  }
+
+  init() {
+    this._camelContext = new CamelContext();
+
+    // Wire registered components from CDI context into the CamelContext
+    const registry = this._applicationContext.get('routeRegistry');
+    registry.applyComponents(this._camelContext, this._applicationContext);
+    registry.applyRoutes(this._camelContext, this._applicationContext.config);
+
+    this._startPromise = this._camelContext.start();
+    log.info('CamelLiteContext: starting CamelContext (async)');
+    return this._startPromise;
+  }
+
+  /**
+   * Await full CamelContext start (routes active, consumers registered).
+   * @returns {Promise<void>}
+   */
+  async ready() {
+    if (this._startPromise) await this._startPromise;
+  }
+
+  async destroy() {
+    if (this._camelContext) {
+      await this._camelContext.stop();
+      log.info('CamelLiteContext: CamelContext stopped');
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// RouteRegistry
+// ---------------------------------------------------------------------------
+
+export class RouteRegistry {
+  constructor() {
+    this._applicationContext = null;
+  }
+
+  setApplicationContext(ctx) {
+    this._applicationContext = ctx;
+  }
+
+  init() {
+    // No-op at init time — applyComponents and applyRoutes are called by CamelLiteContext.init()
+  }
+
+  /**
+   * Register camel-lite components from CDI beans into the CamelContext.
+   * Each CDI bean named 'camelComponent.<scheme>' has already registered itself;
+   * this just ensures the CamelContext receives them in the right order.
+   * Component beans call camelContext.addComponent() themselves in their init(),
+   * but since CamelLiteContext.init() runs after them (via dependsOn), the
+   * CamelContext doesn't exist yet. So we store the registrations here and
+   * apply them when CamelLiteContext calls applyComponents().
+   *
+   * @param {CamelContext} camelContext
+   * @param {ApplicationContext} appCtx
+   */
+  applyComponents(camelContext, appCtx) {
+    const components = appCtx.components;
+    let count = 0;
+    for (const [name, def] of Object.entries(components)) {
+      if (name.startsWith('camelComponent.')) {
+        const scheme = name.slice('camelComponent.'.length);
+        const wrapper = appCtx.get(name);
+        const component = typeof wrapper.getComponent === 'function'
+          ? wrapper.getComponent()
+          : wrapper;
+        camelContext.addComponent(scheme, component);
+        log.debug(`RouteRegistry: registered component '${scheme}'`);
+        count++;
+      }
+    }
+    log.info(`RouteRegistry: registered ${count} component(s)`);
+  }
+
+  /**
+   * Discover CDI RouteBuilder beans and config-driven route definitions,
+   * register all on the CamelContext.
+   *
+   * @param {CamelContext} camelContext
+   * @param {import('@alt-javascript/config').IConfig} config
+   */
+  applyRoutes(camelContext, config) {
+    let count = 0;
+    const appCtx = this._applicationContext;
+
+    // 1. CDI RouteBuilder beans — any bean with a configure(ctx) method
+    for (const [name, def] of Object.entries(appCtx.components)) {
+      // Skip internal camel-lite beans
+      if (name === 'camelLiteContext' || name === 'routeRegistry' ||
+          name === 'camelProducerTemplate' || name === 'camelConsumerTemplate' ||
+          name.startsWith('camelComponent.')) continue;
+
+      const bean = appCtx.get(name);
+      if (bean && typeof bean.configure === 'function') {
+        log.debug(`RouteRegistry: discovered CDI RouteBuilder '${name}'`);
+        camelContext.addRoutes(bean);
+        count++;
+      }
+    }
+
+    // 2. Config-driven route definition objects
+    // boot.camel-lite.routes is an array; each entry has a .definition property
+    // that is an already-parsed JS object (deserialized by @alt-javascript/config)
+    const routesKey = `${PREFIX}.routes`;
+    if (config.has(routesKey)) {
+      const routes = config.get(routesKey);
+      const arr = Array.isArray(routes) ? routes : [routes];
+      for (let i = 0; i < arr.length; i++) {
+        const entry = arr[i];
+        const defKey = `${routesKey}[${i}].definition`;
+        const definition = config.has(defKey) ? config.get(defKey) : entry?.definition;
+        if (!definition) {
+          log.warn(`RouteRegistry: boot.camel-lite.routes[${i}] has no definition — skipping`);
+          continue;
+        }
+        try {
+          const builder = RouteLoader.loadObject(definition);
+          camelContext.addRoutes(builder);
+          log.info(`RouteRegistry: loaded config route[${i}]`);
+          count++;
+        } catch (err) {
+          log.warn(`RouteRegistry: failed to load config route[${i}]: ${err.message}`);
+        }
+      }
+    }
+
+    log.info(`RouteRegistry: registered ${count} route builder(s)`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Component factory — creates a CDI singleton that holds a camel-lite component
+// instance, retrievable by CamelLiteContext via applyComponents()
+// ---------------------------------------------------------------------------
+
+function makeComponentClass(scheme, ComponentClass) {
+  class ConfiguredComponent {
+    constructor() {
+      this._component = new ComponentClass();
+    }
+
+    /** Returns the underlying camel-lite component instance. */
+    getComponent() {
+      return this._component;
+    }
+  }
+  // Give the class a meaningful name for CDI
+  Object.defineProperty(ConfiguredComponent, 'name', { value: `CamelComponent_${scheme}` });
+  return ConfiguredComponent;
+}
+
+function isEnabled(config, scheme) {
+  const key = `${PREFIX}.${scheme}.enabled`;
+  if (config.has(key)) {
+    const val = config.get(key);
+    return val !== false && val !== 'false';
+  }
+  return true; // enabled by default
+}
+
+// ---------------------------------------------------------------------------
+// ProducerTemplate / ConsumerTemplate CDI beans
+// ---------------------------------------------------------------------------
+
+export class CdiProducerTemplate {
+  constructor() {
+    this.camelLiteContext = null; // autowired
+  }
+
+  init() { /* wired by CDI property injection */ }
+
+  async sendBody(uri, body, headers) {
+    await this.camelLiteContext.ready();
+    const pt = new ProducerTemplate(this.camelLiteContext.camelContext);
+    return pt.sendBody(uri, body, headers);
+  }
+
+  async requestBody(uri, body, headers) {
+    await this.camelLiteContext.ready();
+    const pt = new ProducerTemplate(this.camelLiteContext.camelContext);
+    return pt.requestBody(uri, body, headers);
+  }
+}
+
+export class CdiConsumerTemplate {
+  constructor() {
+    this.camelLiteContext = null; // autowired
+  }
+
+  init() { /* wired by CDI property injection */ }
+
+  async receiveBody(uri, timeoutMs) {
+    await this.camelLiteContext.ready();
+    const ct = new ConsumerTemplate(this.camelLiteContext.camelContext);
+    return ct.receiveBody(uri, timeoutMs);
+  }
+
+  async receive(uri, timeoutMs) {
+    await this.camelLiteContext.ready();
+    const ct = new ConsumerTemplate(this.camelLiteContext.camelContext);
+    return ct.receive(uri, timeoutMs);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// camelLiteAutoConfiguration()
+// ---------------------------------------------------------------------------
+
+const BUNDLED_SCHEMES = ['direct', 'seda', 'log', 'file', 'http', 'ftp', 'timer', 'cron'];
+
+const COMPONENT_IMPORTS = {
+  direct: () => import('@alt-javascript/camel-lite-component-direct').then(m => m.DirectComponent),
+  seda:   () => import('@alt-javascript/camel-lite-component-seda').then(m => m.SedaComponent),
+  log:    () => import('@alt-javascript/camel-lite-component-log').then(m => m.LogComponent),
+  file:   () => import('@alt-javascript/camel-lite-component-file').then(m => m.FileComponent),
+  http:   () => import('@alt-javascript/camel-lite-component-http').then(m => m.HttpComponent),
+  ftp:    () => import('@alt-javascript/camel-lite-component-ftp').then(m => m.FtpComponent),
+  timer:  () => import('@alt-javascript/camel-lite-component-timer').then(m => m.TimerComponent),
+  cron:   () => import('@alt-javascript/camel-lite-component-cron').then(m => m.CronComponent),
+};
+
+/**
+ * Returns CDI component definitions for the core camel-lite starter.
+ *
+ * @param {object} [options]
+ * @param {string[]} [options.schemes] — override bundled scheme list
+ * @returns {Promise<Array>} CDI component definition array
+ */
+export async function camelLiteAutoConfiguration(options = {}) {
+  const schemes = options.schemes ?? BUNDLED_SCHEMES;
+  const defs = [];
+
+  // --- Component beans (loaded eagerly so we have the class reference) ---
+  const componentBeanNames = [];
+  for (const scheme of schemes) {
+    const beanName = `camelComponent.${scheme}`;
+    componentBeanNames.push(beanName);
+
+    const ComponentClass = await COMPONENT_IMPORTS[scheme]();
+    const ConfiguredComponent = makeComponentClass(scheme, ComponentClass);
+
+    defs.push({
+      name: beanName,
+      Reference: ConfiguredComponent,
+      scope: 'singleton',
+      condition: (config) => isEnabled(config, scheme),
+    });
+  }
+
+  // --- RouteRegistry ---
+  defs.push({
+    name: 'routeRegistry',
+    Reference: RouteRegistry,
+    scope: 'singleton',
+  });
+
+  // --- CamelLiteContext (depends on routeRegistry only — component beans are
+  //     optional and scanned dynamically by RouteRegistry.applyComponents()) ---
+  defs.push({
+    name: 'camelLiteContext',
+    Reference: CamelLiteContext,
+    scope: 'singleton',
+    dependsOn: 'routeRegistry',
+  });
+
+  // --- ProducerTemplate ---
+  defs.push({
+    name: 'camelProducerTemplate',
+    Reference: CdiProducerTemplate,
+    scope: 'singleton',
+    properties: [{ name: 'camelLiteContext', reference: 'camelLiteContext' }],
+    dependsOn: 'camelLiteContext',
+  });
+
+  // --- ConsumerTemplate ---
+  defs.push({
+    name: 'camelConsumerTemplate',
+    Reference: CdiConsumerTemplate,
+    scope: 'singleton',
+    properties: [{ name: 'camelLiteContext', reference: 'camelLiteContext' }],
+    dependsOn: 'camelLiteContext',
+  });
+
+  return defs;
+}

package/test/starter.test.js

@@ -0,0 +1,241 @@
+import { describe, it, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { EphemeralConfig } from '@alt-javascript/config';
+import { camelLiteStarter, camelLiteAutoConfiguration, CamelLiteContext } from '../index.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const contexts = []; // track for cleanup
+
+async function boot(config = {}) {
+  const cfg = new EphemeralConfig(config);
+  const { applicationContext } = await camelLiteStarter({ config: cfg });
+  contexts.push(applicationContext);
+  return applicationContext;
+}
+
+after(async () => {
+  for (const ctx of contexts) {
+    try {
+      const c = ctx.get('camelLiteContext');
+      await c.camelContext?.stop();
+    } catch { /* ignore */ }
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 1. Auto-configuration shape
+// ---------------------------------------------------------------------------
+
+describe('camelLiteAutoConfiguration: shape', () => {
+  it('returns an array of CDI component definitions', async () => {
+    const defs = await camelLiteAutoConfiguration();
+    assert.ok(Array.isArray(defs));
+    const names = defs.map(d => d.name);
+    assert.ok(names.includes('camelLiteContext'));
+    assert.ok(names.includes('routeRegistry'));
+    assert.ok(names.includes('camelProducerTemplate'));
+    assert.ok(names.includes('camelConsumerTemplate'));
+    // bundled schemes
+    for (const scheme of ['direct','seda','log','file','http','ftp','timer','cron']) {
+      assert.ok(names.includes(`camelComponent.${scheme}`), `missing camelComponent.${scheme}`);
+    }
+  });
+
+  it('camelLiteContext dependsOn routeRegistry', async () => {
+    const defs = await camelLiteAutoConfiguration();
+    const ctxDef = defs.find(d => d.name === 'camelLiteContext');
+    const deps = Array.isArray(ctxDef.dependsOn)
+      ? ctxDef.dependsOn
+      : [ctxDef.dependsOn];
+    assert.ok(deps.includes('routeRegistry'));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 2. ApplicationContext boots and CamelLiteContext is ready
+// ---------------------------------------------------------------------------
+
+describe('camelLiteStarter: boot lifecycle', () => {
+  it('camelLiteContext bean is present in ApplicationContext', async () => {
+    const appCtx = await boot();
+    const ctx = appCtx.get('camelLiteContext');
+    assert.ok(ctx instanceof CamelLiteContext);
+  });
+
+  it('ready() resolves without throwing', async () => {
+    const appCtx = await boot();
+    const ctx = appCtx.get('camelLiteContext');
+    await assert.doesNotReject(() => ctx.ready());
+  });
+
+  it('CamelContext is started after ready()', async () => {
+    const appCtx = await boot();
+    const ctx = appCtx.get('camelLiteContext');
+    await ctx.ready();
+    assert.equal(ctx.camelContext.started, true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 3. ProducerTemplate CDI bean
+// ---------------------------------------------------------------------------
+
+describe('camelProducerTemplate: sendBody through direct: route', () => {
+  it('sends message through a route and returns exchange with no exception', async () => {
+    // Boot with a config route using a direct: endpoint
+    const cfg = new EphemeralConfig({
+      boot: {
+        'camel-lite': {
+          routes: [{
+            definition: {
+              route: {
+                from: { uri: 'direct:hello', steps: [{ setBody: { constant: 'response' } }] }
+              }
+            }
+          }]
+        }
+      }
+    });
+
+    const { applicationContext } = await camelLiteStarter({ config: cfg });
+    contexts.push(applicationContext);
+    const clCtx = applicationContext.get('camelLiteContext');
+    await clCtx.ready();
+
+    const pt = applicationContext.get('camelProducerTemplate');
+    const exchange = await pt.sendBody('direct:hello', 'input');
+    assert.equal(exchange.exception, null);
+    assert.equal(exchange.in.body, 'response');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 4. CDI RouteBuilder bean discovery
+// ---------------------------------------------------------------------------
+
+describe('RouteRegistry: CDI RouteBuilder bean discovery', () => {
+  it('discovers a CDI bean with configure(ctx) and activates its routes', async () => {
+    const { ApplicationContext } = await import('@alt-javascript/cdi');
+    const { EphemeralConfig } = await import('@alt-javascript/config');
+    const { camelLiteAutoConfiguration } = await import('../index.js');
+    const { RouteBuilder } = await import('@alt-javascript/camel-lite-core');
+
+    const received = [];
+
+    // CamelContext.addRoutes(builder) calls builder.configure(this) then iterates
+    // builder.getRoutes(). A RouteBuilder subclass that calls this.from() in
+    // configure() is the standard CDI RouteBuilder pattern.
+    class TestRouteBuilder extends RouteBuilder {
+      configure(camelCtx) {
+        this.from('direct:cdi-discovered').process(ex => {
+          received.push(ex.in.body);
+        });
+      }
+    }
+
+    const autoConfig = await camelLiteAutoConfiguration();
+    const appCtx = new ApplicationContext({
+      config: new EphemeralConfig({}),
+      contexts: [
+        [{ name: 'testRouteBuilder', Reference: TestRouteBuilder, scope: 'singleton' }],
+        autoConfig,
+      ],
+    });
+    await appCtx.start();
+    contexts.push(appCtx);
+
+    const clCtx = appCtx.get('camelLiteContext');
+    await clCtx.ready();
+
+    const pt = appCtx.get('camelProducerTemplate');
+    await pt.sendBody('direct:cdi-discovered', 'discovery-test');
+
+    assert.deepEqual(received, ['discovery-test']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 5. Config-driven route definition objects
+// ---------------------------------------------------------------------------
+
+describe('RouteRegistry: config route objects via RouteLoader.loadObject', () => {
+  it('loads route from boot.camel-lite.routes[0].definition object', async () => {
+    const fired = [];
+    const cfg = new EphemeralConfig({
+      boot: {
+        'camel-lite': {
+          routes: [{
+            definition: {
+              route: {
+                from: {
+                  uri: 'direct:config-route',
+                  steps: [{ setBody: { constant: 'from-config' } }]
+                }
+              }
+            }
+          }]
+        }
+      }
+    });
+
+    const { applicationContext } = await camelLiteStarter({ config: cfg });
+    contexts.push(applicationContext);
+    const clCtx = applicationContext.get('camelLiteContext');
+    await clCtx.ready();
+
+    const pt = applicationContext.get('camelProducerTemplate');
+    const exchange = await pt.sendBody('direct:config-route', 'input');
+    assert.equal(exchange.in.body, 'from-config');
+  });
+
+  it('loads multiple config routes', async () => {
+    const cfg = new EphemeralConfig({
+      boot: {
+        'camel-lite': {
+          routes: [
+            { definition: { route: { from: { uri: 'direct:multi-a', steps: [{ setBody: { constant: 'a' } }] } } } },
+            { definition: { route: { from: { uri: 'direct:multi-b', steps: [{ setBody: { constant: 'b' } }] } } } },
+          ]
+        }
+      }
+    });
+
+    const { applicationContext } = await camelLiteStarter({ config: cfg });
+    contexts.push(applicationContext);
+    const clCtx = applicationContext.get('camelLiteContext');
+    await clCtx.ready();
+
+    const pt = applicationContext.get('camelProducerTemplate');
+    const exA = await pt.sendBody('direct:multi-a', 'x');
+    const exB = await pt.sendBody('direct:multi-b', 'x');
+    assert.equal(exA.in.body, 'a');
+    assert.equal(exB.in.body, 'b');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 6. Component enable/disable
+// ---------------------------------------------------------------------------
+
+describe('Component enable/disable via config', () => {
+  it('direct: component registered by default (no config flag)', async () => {
+    const appCtx = await boot({});
+    const clCtx = appCtx.get('camelLiteContext');
+    await clCtx.ready();
+    assert.ok(clCtx.camelContext.getComponent('direct'), 'direct component should be registered');
+  });
+
+  it('direct: component absent when boot.camel-lite.direct.enabled=false', async () => {
+    const cfg = new EphemeralConfig({
+      boot: { 'camel-lite': { direct: { enabled: false } } }
+    });
+    const { applicationContext } = await camelLiteStarter({ config: cfg });
+    contexts.push(applicationContext);
+    const clCtx = applicationContext.get('camelLiteContext');
+    await clCtx.ready();
+    assert.equal(clCtx.camelContext.getComponent('direct'), undefined);
+  });
+});