A bus and a queue — through ports, with in-memory adapters

How it works

Two ports, in ports.ts. A Bus publishes and subscribes; a Queue pushes, reserves under a lease, acknowledges, and releases. Neither mentions a process, and no process mentions a broker. memory.ts is the only adapter this repo ships — an adapter over SQS, Redis Streams, NATS or pg-boss is a translation of the same shapes.

A subscription is a process

Which is the whole trick: an external stream becomes ordinary state, so a view binds to it exactly as it binds to a counter. Subscribing happens on the way in, and the unsubscribe is the disposal.

const stop = bus.subscribe(topic, (event) => self.cast({ type: 'event', text: String(event) })) self.signal.addEventListener('abort', stop, { once: true }) yield { topic, events, received } for await (const msg of self) { events = [...events.slice(-5), msg.text] yield { topic, events, received: ++received } }

Look one up by topic and the registry becomes the subscription cache: one subscription per topic however many views want it, and the unsubscribe when the last one leaves. That is the same lookup that dedupes queries and addresses remote processes.

A worker is a process too

Reserve, handle, acknowledge — and if the handler throws, release the job instead of losing it. Nothing here is a framework hook; the retry count above is what the queue reports.

const job = await queue.reserve(leaseMs) if (job === undefined) { soon(() => self.cast({ type: 'poll' }), idleMs); continue } try { done = [...done, await handle(job, self.signal)] await queue.ack(job.id) } catch { await queue.release(job.id) // failed, not died: give it back now }

Press kill while a worker is holding a job

The process is disposed, its handler is aborted through self.signal, and nothing acknowledges the job — so it stays invisible until its lease runs out, and then the other worker takes it. That is what at-least-once looks like when the queue, rather than the worker, is the thing that guarantees it. The attempts count in the #jobs feed goes up on the redelivery.

The poll loop uses a timer, not a bare self.cast: a mailbox loop that casts to itself synchronously resolves in microtasks and the event loop never turns again, so no timer, no I/O and no pause would ever be heard.

messaging.test.ts drives all of it headlessly. The queue takes its clock as an argument, so the test expires a lease by assigning to a number instead of waiting four seconds.