@alt-javascript/camel-lite-component-seda 1.0.2

package/README.md

@@ -0,0 +1,63 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+Async in-process queuing via a blocking queue. `seda:` (Staged Event-Driven Architecture) decouples producer and consumer threads — the producer returns immediately after enqueuing, and the consumer processes independently.
+
+## Install
+
+```sh
+npm install camel-lite-component-seda
+```
+
+## URI Syntax
+
+```
+seda:name[?size=0&concurrentConsumers=1]
+```
+
+| Parameter            | Default | Description |
+|----------------------|---------|-------------|
+| `size`               | `0`     | Maximum queue depth. `0` = unlimited. |
+| `concurrentConsumers`| `1`     | Number of concurrent consumer workers draining the queue. |
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { SedaComponent } from 'camel-lite-component-seda';
+
+const context = new CamelContext();
+context.addComponent('seda', new SedaComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    // Consumer route — runs async
+    ctx.from('seda:work')
+      .process(exchange => {
+        console.log('Processing:', exchange.in.body);
+      });
+
+    // Producer route — fire-and-forget
+    ctx.from('direct:submit')
+      .to('seda:work');
+  }
+});
+
+await context.start();
+
+// Fire-and-forget: returns before seda:work processes the exchange
+const template = context.createProducerTemplate();
+await template.sendBody('seda:work', 'task payload');
+
+// Receive a single body (blocks until one is available)
+const consumer = context.createConsumerTemplate();
+const body = await consumer.receiveBody('seda:work');
+console.log(body);
+
+await context.stop();
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@alt-javascript/camel-lite-component-seda",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "@alt-javascript/logger": "^3.0.7",
+    "@alt-javascript/config": "^3.0.7",
+    "@alt-javascript/common": "^3.0.7",
+    "@alt-javascript/camel-lite-core": "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",
+    "seda",
+    "async",
+    "messaging",
+    "queuing",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/SedaComponent.js

@@ -0,0 +1,24 @@
+import { Component } from '@alt-javascript/camel-lite-core';
+import SedaEndpoint from './SedaEndpoint.js';
+
+class SedaComponent extends Component {
+  // Endpoint cache — ensures producer and consumer for the same URI share one queue
+  #endpoints = new Map();
+
+  createEndpoint(uri, remaining, parameters, context) {
+    if (this.#endpoints.has(uri)) {
+      return this.#endpoints.get(uri);
+    }
+    const endpoint = new SedaEndpoint(uri, remaining, parameters, context);
+    this.#endpoints.set(uri, endpoint);
+    return endpoint;
+  }
+
+  // Called by CamelContext.stop() to allow cleanup if needed
+  clearEndpoints() {
+    this.#endpoints.clear();
+  }
+}
+
+export { SedaComponent };
+export default SedaComponent;

package/src/SedaConsumer.js

@@ -0,0 +1,86 @@
+import { Consumer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/SedaConsumer');
+
+class SedaConsumer extends Consumer {
+  #uri;
+  #context;
+  #pipeline;
+  #queue;
+  #concurrentConsumers;
+  #workerPromises = [];
+
+  constructor(uri, context, pipeline, queue, concurrentConsumers = 1) {
+    super();
+    this.#uri = uri;
+    this.#context = context;
+    this.#pipeline = pipeline;
+    this.#queue = queue;
+    this.#concurrentConsumers = concurrentConsumers;
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  async start() {
+    this.#context.registerConsumer(this.#uri, this);
+    log.info(`SEDA consumer started: ${this.#uri} (concurrentConsumers: ${this.#concurrentConsumers})`);
+
+    for (let i = 0; i < this.#concurrentConsumers; i++) {
+      const workerId = i;
+      const workerPromise = this.#runWorker(workerId);
+      this.#workerPromises.push(workerPromise);
+    }
+  }
+
+  async #runWorker(workerId) {
+    log.debug(`Worker ${workerId} started for ${this.#uri}`);
+    while (true) {
+      const exchange = await this.#queue.dequeue();
+      if (exchange === null) {
+        // Queue closed — drain complete
+        break;
+      }
+      log.debug(`Worker ${workerId} dequeued exchange ${exchange.in.messageId} from ${this.#uri}`);
+      try {
+        await this.#pipeline.run(exchange);
+      } catch (err) {
+        // Pipeline.run() captures errors into exchange.exception — this catch is a safety net
+        log.error(`Worker ${workerId} error processing exchange ${exchange.in.messageId}: ${err.message}`);
+      }
+    }
+    log.debug(`Worker ${workerId} exiting for ${this.#uri}`);
+  }
+
+  /**
+   * Poll the queue for an exchange, waiting at most timeoutMs milliseconds.
+   * Returns the Exchange if one is available, or null on timeout.
+   * Used by ConsumerTemplate to drain a message from outside the route pipeline.
+   * @param {number} [timeoutMs=5000]
+   * @returns {Promise<Exchange|null>}
+   */
+  async poll(timeoutMs = 5000) {
+    let timer;
+    const timeout = new Promise(resolve => {
+      timer = setTimeout(() => resolve(null), timeoutMs);
+    });
+    const item = await Promise.race([this.#queue.dequeue(), timeout]);
+    clearTimeout(timer);
+    return item;
+  }
+
+  async stop() {
+    // Close the queue — unblocks all waiting dequeues with null
+    this.#queue.close();
+    // Drain all worker loops
+    await Promise.all(this.#workerPromises);
+    this.#workerPromises = [];
+    this.#context.registerConsumer(this.#uri, null);
+    log.info(`SEDA consumer stopped: ${this.#uri}`);
+  }
+}
+
+export { SedaConsumer };
+export default SedaConsumer;

package/src/SedaEndpoint.js

@@ -0,0 +1,52 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import SedaProducer from './SedaProducer.js';
+import SedaConsumer from './SedaConsumer.js';
+import SedaQueue from './SedaQueue.js';
+
+class SedaEndpoint extends Endpoint {
+  #uri;
+  #context;
+  #concurrentConsumers;
+  #size;
+  #queue;
+
+  constructor(uri, remaining, parameters, context) {
+    super();
+    this.#uri = uri;
+    this.#context = context;
+
+    // Parse URI params — parameters is a URLSearchParams instance
+    const params = parameters instanceof URLSearchParams
+      ? parameters
+      : new URLSearchParams(typeof parameters === 'string' ? parameters : '');
+
+    this.#concurrentConsumers = Math.max(1, parseInt(params.get('concurrentConsumers') ?? '1', 10) || 1);
+    this.#size = Math.max(0, parseInt(params.get('size') ?? '0', 10) || 0);
+
+    // One queue per endpoint, shared by producer and all consumer workers
+    this.#queue = new SedaQueue(this.#size);
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  get concurrentConsumers() {
+    return this.#concurrentConsumers;
+  }
+
+  get size() {
+    return this.#size;
+  }
+
+  createProducer() {
+    return new SedaProducer(this.#uri, this.#queue);
+  }
+
+  createConsumer(pipeline) {
+    return new SedaConsumer(this.#uri, this.#context, pipeline, this.#queue, this.#concurrentConsumers);
+  }
+}
+
+export { SedaEndpoint };
+export default SedaEndpoint;

package/src/SedaProducer.js

@@ -0,0 +1,25 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+
+class SedaProducer extends Producer {
+  #uri;
+  #queue;
+
+  constructor(uri, queue) {
+    super();
+    this.#uri = uri;
+    this.#queue = queue;
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  async send(exchange) {
+    // Fire-and-forget: enqueue and return immediately.
+    // SedaQueueFullError propagates to the caller if the queue is at capacity.
+    this.#queue.enqueue(exchange);
+  }
+}
+
+export { SedaProducer };
+export default SedaProducer;

package/src/SedaQueue.js

@@ -0,0 +1,56 @@
+import { SedaQueueFullError } from '@alt-javascript/camel-lite-core';
+
+class SedaQueue {
+  #items = [];
+  #waiters = [];
+  #closed = false;
+  #maxSize;
+
+  constructor(maxSize = 0) {
+    this.#maxSize = maxSize;
+  }
+
+  enqueue(item) {
+    if (this.#closed) {
+      throw new Error('SedaQueue is closed');
+    }
+    if (this.#maxSize > 0 && this.#items.length >= this.#maxSize) {
+      throw new SedaQueueFullError(this.#maxSize);
+    }
+    if (this.#waiters.length > 0) {
+      // A consumer is already waiting — deliver directly without touching the queue
+      this.#waiters.shift().resolve(item);
+    } else {
+      this.#items.push(item);
+    }
+  }
+
+  dequeue() {
+    if (this.#items.length > 0) {
+      return Promise.resolve(this.#items.shift());
+    }
+    if (this.#closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise(resolve => this.#waiters.push({ resolve }));
+  }
+
+  close() {
+    this.#closed = true;
+    for (const waiter of this.#waiters) {
+      waiter.resolve(null);
+    }
+    this.#waiters = [];
+  }
+
+  get size() {
+    return this.#items.length;
+  }
+
+  get closed() {
+    return this.#closed;
+  }
+}
+
+export { SedaQueue };
+export default SedaQueue;

package/src/index.js

@@ -0,0 +1,8 @@
+export { SedaComponent } from './SedaComponent.js';
+export { SedaEndpoint } from './SedaEndpoint.js';
+export { SedaProducer } from './SedaProducer.js';
+export { SedaConsumer } from './SedaConsumer.js';
+export { SedaQueue } from './SedaQueue.js';
+
+import SedaComponent from './SedaComponent.js';
+export default SedaComponent;

package/test/concurrent.test.js

@@ -0,0 +1,155 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { CamelContext, Exchange, RouteDefinition, SedaQueueFullError } from '@alt-javascript/camel-lite-core';
+import { DirectComponent } from '@alt-javascript/camel-lite-component-direct';
+import { SedaComponent, SedaQueue, SedaProducer, SedaConsumer, SedaEndpoint } from '@alt-javascript/camel-lite-component-seda';
+
+function makeLatch(count) {
+  let resolve;
+  let remaining = count;
+  const promise = new Promise(r => { resolve = r; });
+  const tick = () => { if (--remaining <= 0) resolve(); };
+  return { promise, tick };
+}
+
+describe('Concurrent consumers', () => {
+  it('4 concurrent workers process 100 exchanges — all processed, none lost', async () => {
+    const { promise: latch, tick } = makeLatch(100);
+    let counter = 0;
+
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('seda', new SedaComponent());
+
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.to('seda:work?concurrentConsumers=4');
+
+    const routeB = new RouteDefinition('seda:work?concurrentConsumers=4');
+    routeB.process((exchange) => {
+      counter++;
+      tick();
+    });
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+    await context.start();
+
+    const entryConsumer = context.getConsumer('direct:entry');
+    for (let i = 0; i < 100; i++) {
+      const exchange = new Exchange();
+      exchange.in.body = i;
+      await entryConsumer.process(exchange);
+    }
+
+    await latch;
+    await context.stop();
+
+    assert.equal(counter, 100, `expected 100 processed, got ${counter}`);
+  });
+
+  it('stop() with 4 workers in-flight drains all workers cleanly', async () => {
+    const TOTAL = 40;
+    const { promise: latch, tick } = makeLatch(TOTAL);
+    let counter = 0;
+
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('seda', new SedaComponent());
+
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.to('seda:drain?concurrentConsumers=4');
+
+    const routeB = new RouteDefinition('seda:drain?concurrentConsumers=4');
+    routeB.process(async (exchange) => {
+      // Simulate a tiny bit of async work
+      await new Promise(r => setTimeout(r, 5));
+      counter++;
+      tick();
+    });
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+    await context.start();
+
+    const entryConsumer = context.getConsumer('direct:entry');
+    for (let i = 0; i < TOTAL; i++) {
+      const exchange = new Exchange();
+      exchange.in.body = i;
+      await entryConsumer.process(exchange);
+    }
+
+    // Wait for all to be processed, then stop
+    await latch;
+    const stopStart = Date.now();
+    await context.stop();
+    const stopDuration = Date.now() - stopStart;
+
+    assert.equal(counter, TOTAL, `expected ${TOTAL} processed, got ${counter}`);
+    assert.ok(stopDuration < 2000, `stop() should be fast after drain, took ${stopDuration}ms`);
+  });
+});
+
+describe('Backpressure', () => {
+  it('size=2: 3rd enqueue throws SedaQueueFullError', async () => {
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('seda', new SedaComponent());
+
+    // Use a very slow consumer so items stay in queue long enough to hit the limit
+    const { promise: latch, tick } = makeLatch(2);
+
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.to('seda:bounded?size=2');
+
+    const routeB = new RouteDefinition('seda:bounded?size=2');
+    routeB.process(async (exchange) => {
+      // Slow enough that 3 items could pile up before processing starts
+      await new Promise(r => setTimeout(r, 50));
+      tick();
+    });
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+    await context.start();
+
+    // To reliably test backpressure, enqueue directly to a queue with no running consumer
+    const queue = new SedaQueue(2);
+    queue.enqueue(new Exchange());
+    queue.enqueue(new Exchange());
+
+    let threw = false;
+    try {
+      queue.enqueue(new Exchange());
+    } catch (err) {
+      threw = true;
+      assert.ok(err instanceof SedaQueueFullError, `expected SedaQueueFullError, got ${err.constructor.name}`);
+      assert.equal(err.maxSize, 2);
+      assert.ok(err.message.includes('2'));
+    }
+
+    assert.ok(threw, 'should have thrown SedaQueueFullError on 3rd enqueue');
+    await context.stop();
+  });
+
+  it('SedaQueueFullError propagates through send() to caller', async () => {
+    const queue = new SedaQueue(1);
+    const producer = new SedaProducer('seda:bounded', queue);
+
+    const ex1 = new Exchange();
+    const ex2 = new Exchange();
+
+    await producer.send(ex1); // succeeds — queue has 1 item
+
+    await assert.rejects(
+      () => producer.send(ex2),
+      (err) => {
+        assert.ok(err instanceof SedaQueueFullError);
+        assert.equal(err.maxSize, 1);
+        return true;
+      }
+    );
+  });
+
+  it('SedaEndpoint with size param creates bounded queue', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:bounded', 'bounded', new URLSearchParams('size=5'), ctx);
+    assert.equal(ep.size, 5);
+  });
+});

package/test/import.test.js

@@ -0,0 +1,43 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange, Message, CamelContext, Component, Pipeline, SedaQueueFullError } from '@alt-javascript/camel-lite-core';
+import { SedaComponent, SedaEndpoint, SedaProducer, SedaConsumer, SedaQueue } from '@alt-javascript/camel-lite-component-seda';
+
+describe('cross-package import integration', () => {
+  it('Exchange imported from camel-lite-core constructs correctly', () => {
+    const ex = new Exchange();
+    assert.equal(ex.pattern, 'InOnly');
+    assert.ok(ex.in instanceof Message);
+  });
+
+  it('SedaComponent is a subclass of Component', () => {
+    const c = new SedaComponent();
+    assert.ok(c instanceof Component);
+  });
+
+  it('SedaQueueFullError imported from camel-lite-core', () => {
+    const err = new SedaQueueFullError(5);
+    assert.ok(err instanceof Error);
+    assert.equal(err.name, 'SedaQueueFullError');
+    assert.equal(err.maxSize, 5);
+  });
+
+  it('SedaComponent.createEndpoint returns a SedaEndpoint', () => {
+    const c = new SedaComponent();
+    const ctx = new CamelContext();
+    const ep = c.createEndpoint('seda:test', 'test', new URLSearchParams(), ctx);
+    assert.ok(ep instanceof SedaEndpoint);
+  });
+
+  it('SedaEndpoint.createProducer returns SedaProducer', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:test', 'test', new URLSearchParams(), ctx);
+    assert.ok(ep.createProducer() instanceof SedaProducer);
+  });
+
+  it('SedaEndpoint.createConsumer returns SedaConsumer', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:test', 'test', new URLSearchParams(), ctx);
+    assert.ok(ep.createConsumer(new Pipeline([])) instanceof SedaConsumer);
+  });
+});

package/test/seda-queue.test.js

@@ -0,0 +1,98 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { SedaQueue } from '../src/SedaQueue.js';
+import { SedaQueueFullError } from '@alt-javascript/camel-lite-core';
+
+describe('SedaQueue', () => {
+  it('enqueue then dequeue returns the item', async () => {
+    const q = new SedaQueue();
+    q.enqueue('hello');
+    const item = await q.dequeue();
+    assert.equal(item, 'hello');
+  });
+
+  it('dequeue before enqueue — resolves when item arrives', async () => {
+    const q = new SedaQueue();
+    const deqPromise = q.dequeue();
+    q.enqueue('late');
+    const item = await deqPromise;
+    assert.equal(item, 'late');
+  });
+
+  it('multiple items dequeued in FIFO order', async () => {
+    const q = new SedaQueue();
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    assert.equal(await q.dequeue(), 1);
+    assert.equal(await q.dequeue(), 2);
+    assert.equal(await q.dequeue(), 3);
+  });
+
+  it('close() resolves all waiting consumers with null', async () => {
+    const q = new SedaQueue();
+    const p1 = q.dequeue();
+    const p2 = q.dequeue();
+    q.close();
+    assert.equal(await p1, null);
+    assert.equal(await p2, null);
+  });
+
+  it('dequeue on a closed empty queue returns null immediately', async () => {
+    const q = new SedaQueue();
+    q.close();
+    const item = await q.dequeue();
+    assert.equal(item, null);
+  });
+
+  it('enqueue after close throws', () => {
+    const q = new SedaQueue();
+    q.close();
+    assert.throws(() => q.enqueue('x'), { message: 'SedaQueue is closed' });
+  });
+
+  it('size reflects queued items', () => {
+    const q = new SedaQueue();
+    assert.equal(q.size, 0);
+    q.enqueue('a');
+    q.enqueue('b');
+    assert.equal(q.size, 2);
+  });
+
+  it('closed reflects queue state', () => {
+    const q = new SedaQueue();
+    assert.equal(q.closed, false);
+    q.close();
+    assert.equal(q.closed, true);
+  });
+
+  it('maxSize=2: enqueue 2 succeeds, 3rd throws SedaQueueFullError', () => {
+    const q = new SedaQueue(2);
+    q.enqueue('a');
+    q.enqueue('b');
+    assert.throws(
+      () => q.enqueue('c'),
+      (err) => {
+        assert.ok(err instanceof SedaQueueFullError);
+        assert.equal(err.name, 'SedaQueueFullError');
+        assert.equal(err.maxSize, 2);
+        return true;
+      }
+    );
+  });
+
+  it('maxSize=0 (unlimited): accepts many items without throwing', () => {
+    const q = new SedaQueue(0);
+    for (let i = 0; i < 1000; i++) q.enqueue(i);
+    assert.equal(q.size, 1000);
+  });
+
+  it('direct delivery to waiting consumer bypasses items array (size stays 0)', async () => {
+    const q = new SedaQueue();
+    const p = q.dequeue(); // waiter registered
+    assert.equal(q.size, 0);
+    q.enqueue('direct');
+    assert.equal(q.size, 0); // delivered directly, not buffered
+    assert.equal(await p, 'direct');
+  });
+});

package/test/seda.test.js

@@ -0,0 +1,194 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { CamelContext, Exchange, Pipeline, RouteDefinition } from '@alt-javascript/camel-lite-core';
+import { DirectComponent } from '@alt-javascript/camel-lite-component-direct';
+import { SedaComponent, SedaEndpoint, SedaProducer, SedaConsumer, SedaQueue } from '@alt-javascript/camel-lite-component-seda';
+
+// Promise latch — resolves once `count` items have been processed
+function makeLatch(count) {
+  let resolve;
+  let remaining = count;
+  const promise = new Promise(r => { resolve = r; });
+  const tick = () => { if (--remaining <= 0) resolve(); };
+  return { promise, tick };
+}
+
+describe('SedaComponent', () => {
+  it('can be constructed', () => {
+    const c = new SedaComponent();
+    assert.ok(c instanceof SedaComponent);
+  });
+
+  it('createEndpoint returns SedaEndpoint', () => {
+    const c = new SedaComponent();
+    const ctx = new CamelContext();
+    const ep = c.createEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    assert.ok(ep instanceof SedaEndpoint);
+    assert.equal(ep.uri, 'seda:work');
+  });
+
+  it('createEndpoint returns same endpoint for same URI (endpoint cache)', () => {
+    const c = new SedaComponent();
+    const ctx = new CamelContext();
+    const ep1 = c.createEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    const ep2 = c.createEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    assert.strictEqual(ep1, ep2, 'same URI must return same endpoint (shared queue)');
+  });
+});
+
+describe('SedaEndpoint', () => {
+  it('createProducer returns SedaProducer', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    const producer = ep.createProducer();
+    assert.ok(producer instanceof SedaProducer);
+    assert.equal(producer.uri, 'seda:work');
+  });
+
+  it('createConsumer returns SedaConsumer', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    const pipeline = new Pipeline([]);
+    const consumer = ep.createConsumer(pipeline);
+    assert.ok(consumer instanceof SedaConsumer);
+    assert.equal(consumer.uri, 'seda:work');
+  });
+
+  it('concurrentConsumers defaults to 1', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    assert.equal(ep.concurrentConsumers, 1);
+  });
+
+  it('concurrentConsumers parsed from URI param', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:work', 'work', new URLSearchParams('concurrentConsumers=4'), ctx);
+    assert.equal(ep.concurrentConsumers, 4);
+  });
+
+  it('size defaults to 0 (unlimited)', () => {
+    const ctx = new CamelContext();
+    const ep = new SedaEndpoint('seda:work', 'work', new URLSearchParams(), ctx);
+    assert.equal(ep.size, 0);
+  });
+});
+
+describe('SedaProducer', () => {
+  it('send() enqueues without awaiting downstream processing', async () => {
+    const queue = new SedaQueue();
+    const producer = new SedaProducer('seda:work', queue);
+    const exchange = new Exchange();
+
+    // Consumer loop waits for item
+    const dequeuePromise = queue.dequeue();
+    await producer.send(exchange);
+
+    // send() returned — now await the dequeue
+    const dequeued = await dequeuePromise;
+    assert.strictEqual(dequeued, exchange);
+  });
+});
+
+describe('SedaConsumer lifecycle', () => {
+  it('start() registers consumer with context', async () => {
+    const ctx = new CamelContext();
+    const queue = new SedaQueue();
+    const pipeline = new Pipeline([]);
+    const consumer = new SedaConsumer('seda:test', ctx, pipeline, queue, 1);
+
+    await consumer.start();
+    assert.strictEqual(ctx.getConsumer('seda:test'), consumer);
+    await consumer.stop();
+  });
+
+  it('stop() deregisters consumer from context', async () => {
+    const ctx = new CamelContext();
+    const queue = new SedaQueue();
+    const pipeline = new Pipeline([]);
+    const consumer = new SedaConsumer('seda:test', ctx, pipeline, queue, 1);
+
+    await consumer.start();
+    await consumer.stop();
+    assert.equal(ctx.getConsumer('seda:test'), null);
+  });
+});
+
+describe('SEDA integration: single consumer, 10 exchanges', () => {
+  it('all 10 exchanges processed and drained by stop()', async () => {
+    const { promise: latch, tick } = makeLatch(10);
+    const processed = [];
+
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('seda', new SedaComponent());
+
+    // Entry route: direct:entry → seda:work (fire-and-forget)
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.process((exchange) => { exchange.in.body = `msg-${exchange.in.body}`; });
+    routeA.to('seda:work');
+
+    // Worker route: seda:work → process
+    const routeB = new RouteDefinition('seda:work');
+    routeB.process((exchange) => {
+      processed.push(exchange.in.body);
+      tick();
+    });
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+    await context.start();
+
+    const entryConsumer = context.getConsumer('direct:entry');
+
+    // Enqueue 10 exchanges via direct:entry → seda:work
+    for (let i = 0; i < 10; i++) {
+      const exchange = new Exchange();
+      exchange.in.body = i;
+      await entryConsumer.process(exchange);
+    }
+
+    // Wait for all 10 to be processed by the seda worker
+    await latch;
+    // Drain workers
+    await context.stop();
+
+    assert.equal(processed.length, 10, `expected 10 processed, got ${processed.length}`);
+    assert.ok(!context.getConsumer('seda:work'), 'consumer deregistered after stop');
+  });
+
+  it('pipeline error in worker does not stop the worker — subsequent exchanges still processed', async () => {
+    const { promise: latch, tick } = makeLatch(5);
+    const processed = [];
+
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('seda', new SedaComponent());
+
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.to('seda:work');
+
+    let callCount = 0;
+    const routeB = new RouteDefinition('seda:work');
+    routeB.process((exchange) => {
+      callCount++;
+      if (callCount === 2) throw new Error('deliberate worker error');
+      processed.push(exchange.in.body);
+      tick();
+    });
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+    await context.start();
+
+    const entryConsumer = context.getConsumer('direct:entry');
+    for (let i = 0; i < 6; i++) {
+      const exchange = new Exchange();
+      exchange.in.body = `item-${i}`;
+      await entryConsumer.process(exchange);
+    }
+
+    await latch;
+    await context.stop();
+
+    // 1 of 6 failed mid-pipeline (exception captured in exchange); 5 completed
+    assert.equal(processed.length, 5);
+  });
+});