@pipedog/core 0.0.0 → 0.1.0

package/dist/bus/bridge_processor.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Bus bridge and edge processors for inter-worker frame routing.
+ *
+ * Provides:
+ *
+ * - `BusBridgeProcessor`: a mid-pipeline processor that exchanges frames with
+ *   other workers through the bus, consuming local frames.
+ * - `_BusEdgeProcessor`: a pipeline-edge processor used internally by
+ *   `PipelineWorker` when `bridged` is set. Tees frames between the local
+ *   pipeline and the bus (frames continue locally and are also forwarded to
+ *   the bus).
+ */
+import { type Frame } from "../frames/frames.ts";
+import type { PipelineWorker } from "../pipeline/worker.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions, type FrameProcessorSetup } from "../processors/frame_processor.ts";
+import type { FrameClass } from "../utils/frame_queue.ts";
+import type { WorkerBus } from "./bus.ts";
+import { type BusMessage } from "./messages.ts";
+export interface BusBridgeProcessorOptions extends FrameProcessorOptions {
+    /** The `WorkerBus` to exchange frames with. */
+    bus: WorkerBus;
+    /** Name of the owning worker, used as message source. */
+    workerName: string;
+    /** When set, only exchange frames with this worker. */
+    targetWorker?: string | null;
+    /**
+     * Optional bridge name for routing. When set, outgoing frames are tagged
+     * with this name and only incoming frames with the same bridge name are
+     * accepted.
+     */
+    bridge?: string | null;
+    /**
+     * Extra frame types that should never cross the bus (on top of lifecycle
+     * frames which are always excluded).
+     */
+    excludeFrames?: readonly FrameClass[] | null;
+}
+declare const BusBridgeProcessor_base: typeof FrameProcessor & import("../utils/mixin.ts").Ctor<import("./subscriber.ts").BusSubscriberMethods>;
+/**
+ * Bidirectional mid-pipeline bridge between a Pipecat pipeline and the bus.
+ *
+ * Placed in a transport or session worker's pipeline to exchange frames with
+ * other workers via the `WorkerBus`. Lifecycle and excluded frames pass
+ * through locally without crossing the bus.
+ */
+export declare class BusBridgeProcessor extends BusBridgeProcessor_base {
+    protected _bus: WorkerBus;
+    protected _workerName: string;
+    protected _targetWorker: string | null;
+    protected _bridge: string | null;
+    protected _excludeFrames: readonly FrameClass[];
+    /**
+     * Initialize the BusBridgeProcessor.
+     *
+     * The deprecated `target_task` parameter is not ported; use `targetWorker`.
+     */
+    constructor(options: BusBridgeProcessorOptions);
+    /** Subscribe to the bus during processor setup. */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Unsubscribe from the bus on cleanup. */
+    cleanup(): Promise<void>;
+    /**
+     * Process a frame: send to bus, or pass through locally if excluded.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is traveling.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /**
+     * Handle an incoming bus message by pushing its frame into the pipeline.
+     *
+     * @param message The bus message to handle.
+     */
+    onBusMessage(message: BusMessage): Promise<void>;
+}
+export interface _BusEdgeProcessorOptions extends FrameProcessorOptions {
+    /**
+     * The owning worker; the edge reads `worker.bus` lazily so the bus only
+     * needs to be set (via `PipelineWorker.attach`) by the time the processor
+     * is set up. `worker.name` is the message source.
+     */
+    worker: PipelineWorker;
+    /** Direction this edge captures and publishes to the bus. */
+    direction: FrameDirection;
+    /**
+     * Extra frame types that should never cross the bus (lifecycle frames are
+     * always excluded).
+     */
+    excludeFrames?: readonly FrameClass[] | null;
+}
+/**
+ * Pipeline-edge tap that publishes local frames onto the bus.
+ *
+ * Placed by `PipelineWorker` at the source and sink of a bridged pipeline.
+ * Frames always continue through the local pipeline; in addition, frames
+ * travelling in `direction` are published to the bus. The opposite path, a
+ * frame arriving from the bus, belongs to the worker, which queues it into
+ * the pipeline itself.
+ *
+ * Internal to pipecat (used by `pipeline/worker.ts`); exported only for that.
+ */
+export declare class _BusEdgeProcessor extends FrameProcessor {
+    protected _task: PipelineWorker;
+    protected _direction: FrameDirection;
+    protected _excludeFrames: readonly FrameClass[];
+    constructor(options: _BusEdgeProcessorOptions);
+    /** Pass the frame through locally and forward matching ones to the bus. */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+export {};
+//# sourceMappingURL=bridge_processor.d.ts.map

package/dist/bus/bridge_processor.js

@@ -0,0 +1,166 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/bridge_processor.py
+/**
+ * Bus bridge and edge processors for inter-worker frame routing.
+ *
+ * Provides:
+ *
+ * - `BusBridgeProcessor`: a mid-pipeline processor that exchanges frames with
+ *   other workers through the bus, consuming local frames.
+ * - `_BusEdgeProcessor`: a pipeline-edge processor used internally by
+ *   `PipelineWorker` when `bridged` is set. Tees frames between the local
+ *   pipeline and the bus (frames continue locally and are also forwarded to
+ *   the bus).
+ */
+import { CancelFrame, EndFrame, OutputTransportMessageUrgentFrame, PipelineFlushFrame, StartFrame, StopFrame, } from "../frames/frames.js";
+import { FrameProcessor, } from "../processors/frame_processor.js";
+import { BusFrameMessage } from "./messages.js";
+import { BusSubscriber } from "./subscriber.js";
+const _LIFECYCLE_FRAMES = [StartFrame, EndFrame, CancelFrame, StopFrame];
+const _PASSTHROUGH_FRAMES = [OutputTransportMessageUrgentFrame];
+function isInstanceOfAny(frame, types) {
+    return types.some((type) => frame instanceof type);
+}
+/**
+ * Bidirectional mid-pipeline bridge between a Pipecat pipeline and the bus.
+ *
+ * Placed in a transport or session worker's pipeline to exchange frames with
+ * other workers via the `WorkerBus`. Lifecycle and excluded frames pass
+ * through locally without crossing the bus.
+ */
+export class BusBridgeProcessor extends BusSubscriber(FrameProcessor) {
+    _bus;
+    _workerName;
+    _targetWorker;
+    _bridge;
+    _excludeFrames;
+    /**
+     * Initialize the BusBridgeProcessor.
+     *
+     * The deprecated `target_task` parameter is not ported; use `targetWorker`.
+     */
+    constructor(options) {
+        super(options);
+        this._bus = options.bus;
+        this._workerName = options.workerName;
+        this._targetWorker = options.targetWorker ?? null;
+        this._bridge = options.bridge ?? null;
+        this._excludeFrames = options.excludeFrames ?? [];
+    }
+    /** Subscribe to the bus during processor setup. */
+    async setup(setup) {
+        await super.setup(setup);
+        await this._bus.subscribe(this);
+    }
+    /** Unsubscribe from the bus on cleanup. */
+    async cleanup() {
+        await super.cleanup();
+        await this._bus.unsubscribe(this);
+    }
+    /**
+     * Process a frame: send to bus, or pass through locally if excluded.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is traveling.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        // Lifecycle frames never cross the bus
+        if (isInstanceOfAny(frame, _LIFECYCLE_FRAMES)) {
+            await this.pushFrame(frame, direction);
+            return;
+        }
+        // Urgent transport frames belong to this pipeline rather than to a
+        // peer: they have to reach the transport even with no peer active.
+        if (isInstanceOfAny(frame, _PASSTHROUGH_FRAMES)) {
+            await this.pushFrame(frame, direction);
+            return;
+        }
+        // Excluded frames never cross the bus
+        if (this._excludeFrames.length > 0 && isInstanceOfAny(frame, this._excludeFrames)) {
+            await this.pushFrame(frame, direction);
+            return;
+        }
+        // Send to bus
+        const msg = new BusFrameMessage({
+            source: this._workerName,
+            frame,
+            direction,
+            bridge: this._bridge,
+        });
+        await this._bus.send(msg);
+    }
+    /**
+     * Handle an incoming bus message by pushing its frame into the pipeline.
+     *
+     * @param message The bus message to handle.
+     */
+    async onBusMessage(message) {
+        if (!(message instanceof BusFrameMessage)) {
+            return;
+        }
+        // Skip own frames
+        if (message.source === this._workerName) {
+            return;
+        }
+        // Filter by bridge name
+        if (this._bridge && message.bridge !== this._bridge) {
+            return;
+        }
+        // If targetWorker set, only accept from that worker
+        if (this._targetWorker && message.source !== this._targetWorker) {
+            return;
+        }
+        // If message targeted at someone else, skip
+        if (message.target && message.target !== this._workerName) {
+            return;
+        }
+        // The frame has cleared every filter, so this pipeline is the one
+        // taking it in.
+        if (message.frame instanceof PipelineFlushFrame) {
+            this.pipelineWorker.trackFlushProbe(message.frame);
+        }
+        await this.pushFrame(message.frame, message.direction);
+    }
+}
+/**
+ * Pipeline-edge tap that publishes local frames onto the bus.
+ *
+ * Placed by `PipelineWorker` at the source and sink of a bridged pipeline.
+ * Frames always continue through the local pipeline; in addition, frames
+ * travelling in `direction` are published to the bus. The opposite path, a
+ * frame arriving from the bus, belongs to the worker, which queues it into
+ * the pipeline itself.
+ *
+ * Internal to pipecat (used by `pipeline/worker.ts`); exported only for that.
+ */
+export class _BusEdgeProcessor extends FrameProcessor {
+    _task;
+    _direction;
+    _excludeFrames;
+    constructor(options) {
+        super(options);
+        this._task = options.worker;
+        this._direction = options.direction;
+        this._excludeFrames = options.excludeFrames ?? [];
+    }
+    /** Pass the frame through locally and forward matching ones to the bus. */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        await this.pushFrame(frame, direction);
+        if (direction !== this._direction) {
+            return;
+        }
+        if (isInstanceOfAny(frame, _LIFECYCLE_FRAMES)) {
+            return;
+        }
+        if (this._excludeFrames.length > 0 && isInstanceOfAny(frame, this._excludeFrames)) {
+            return;
+        }
+        await this._task.bus.send(new BusFrameMessage({ source: this._task.name, frame, direction }));
+    }
+}
+//# sourceMappingURL=bridge_processor.js.map

package/dist/bus/bus.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Abstract worker bus for inter-worker pub/sub messaging.
+ *
+ * Provides the abstract `WorkerBus` base class. Concrete implementations
+ * (e.g. `AsyncQueueBus`) live in separate modules.
+ */
+import { Queue, type Task } from "@pipedog/asyncio";
+import { BaseObject, type BaseObjectOptions } from "../utils/base_object.ts";
+import { type BusMessage } from "./messages.ts";
+import { BusMessageQueue } from "./queue.ts";
+import type { BusSubscriber } from "./subscriber.ts";
+export interface BusSubscriptionOptions {
+    /** The subscriber receiving messages. */
+    subscriber: BusSubscriber;
+    /** Priority queue for incoming messages. */
+    queue?: BusMessageQueue;
+    /** Secondary queue for data messages dispatched by the router worker. */
+    dataQueue?: Queue<BusMessage>;
+    /**
+     * Task that reads from the priority queue, handles system messages inline,
+     * and routes data messages to the data queue.
+     */
+    routerTask?: Task<unknown> | null;
+    /** Task that processes data messages sequentially from the data queue. */
+    dataTask?: Task<unknown> | null;
+}
+/** A single subscriber's state on the bus. */
+export declare class BusSubscription {
+    subscriber: BusSubscriber;
+    queue: BusMessageQueue;
+    dataQueue: Queue<BusMessage>;
+    routerTask: Task<unknown> | null;
+    dataTask: Task<unknown> | null;
+    constructor(options: BusSubscriptionOptions);
+    toString(): string;
+}
+export interface WorkerBusOptions extends BaseObjectOptions {
+}
+/**
+ * Abstract base for inter-worker and runner-worker communication.
+ *
+ * Provides pub/sub messaging where each subscriber receives messages
+ * independently through its own priority queue. System messages (e.g.
+ * cancel) are delivered before normal data messages.
+ *
+ * Subclasses implement `publish()` for the specific transport. `send()`
+ * handles local-only messages automatically. For network buses, override
+ * `start()`/`stop()` to manage connections and call `onMessageReceived()`
+ * when messages arrive from the network.
+ */
+export declare abstract class WorkerBus extends BaseObject {
+    protected _subscriptions: Map<string, BusSubscription>;
+    protected _running: boolean;
+    /**
+     * Initialize the WorkerBus.
+     *
+     * @param options Additional arguments passed to `BaseObject`.
+     */
+    constructor(options?: WorkerBusOptions);
+    /** Start dispatch tasks for all registered subscribers. */
+    start(): Promise<void>;
+    /** Stop all dispatch tasks. */
+    stop(): Promise<void>;
+    /**
+     * Register a subscriber to receive messages from the bus.
+     *
+     * Idempotent: re-subscribing an already-registered subscriber is a no-op.
+     *
+     * @param subscriber The `BusSubscriber` to register.
+     */
+    subscribe(subscriber: BusSubscriber): Promise<void>;
+    /**
+     * Remove a subscriber and cancel its dispatch tasks.
+     *
+     * @param subscriber The `BusSubscriber` to remove.
+     */
+    unsubscribe(subscriber: BusSubscriber): Promise<void>;
+    /**
+     * Send a message through the bus.
+     *
+     * Local-only messages are delivered directly to subscribers. All other
+     * messages are passed to `publish()` for transport.
+     *
+     * @param message The bus message to send.
+     */
+    send(message: BusMessage): Promise<void>;
+    /**
+     * Publish a message to the transport.
+     *
+     * Subclasses implement this for the specific transport. Called by `send()`
+     * after filtering local-only messages.
+     *
+     * @param message The bus message to publish.
+     */
+    abstract publish(message: BusMessage): Promise<void>;
+    /**
+     * Deliver a message to all local subscribers via their priority queues.
+     *
+     * Called by bus implementations when a message arrives (either from a local
+     * `send()` or from a network transport).
+     */
+    onMessageReceived(message: BusMessage): void;
+    /** Start the router and data dispatch tasks for a subscriber. */
+    protected _startDispatchTask(sub: BusSubscription): void;
+    /** Route system messages inline, data messages to the data queue. */
+    protected _routerTask(sub: BusSubscription): Promise<void>;
+    /** Process data messages sequentially from the data queue. */
+    protected _dataDispatchTask(sub: BusSubscription): Promise<void>;
+}
+//# sourceMappingURL=bus.d.ts.map

package/dist/bus/bus.js

@@ -0,0 +1,200 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/bus.py
+/**
+ * Abstract worker bus for inter-worker pub/sub messaging.
+ *
+ * Provides the abstract `WorkerBus` base class. Concrete implementations
+ * (e.g. `AsyncQueueBus`) live in separate modules.
+ */
+import { Queue, rethrowIfCancelled, sleep } from "@pipedog/asyncio";
+import { BaseObject } from "../utils/base_object.js";
+import { logger } from "../utils/logger.js";
+import { BusLocalMessage, BusSystemMessage } from "./messages.js";
+import { BusMessageQueue } from "./queue.js";
+/** A single subscriber's state on the bus. */
+export class BusSubscription {
+    subscriber;
+    queue;
+    dataQueue;
+    routerTask;
+    dataTask;
+    constructor(options) {
+        this.subscriber = options.subscriber;
+        this.queue = options.queue ?? new BusMessageQueue();
+        this.dataQueue = options.dataQueue ?? new Queue();
+        this.routerTask = options.routerTask ?? null;
+        this.dataTask = options.dataTask ?? null;
+    }
+    toString() {
+        return `BusSubscription(subscriber=${this.subscriber.name})`;
+    }
+}
+/**
+ * Abstract base for inter-worker and runner-worker communication.
+ *
+ * Provides pub/sub messaging where each subscriber receives messages
+ * independently through its own priority queue. System messages (e.g.
+ * cancel) are delivered before normal data messages.
+ *
+ * Subclasses implement `publish()` for the specific transport. `send()`
+ * handles local-only messages automatically. For network buses, override
+ * `start()`/`stop()` to manage connections and call `onMessageReceived()`
+ * when messages arrive from the network.
+ */
+export class WorkerBus extends BaseObject {
+    _subscriptions = new Map();
+    _running = false;
+    /**
+     * Initialize the WorkerBus.
+     *
+     * @param options Additional arguments passed to `BaseObject`.
+     */
+    constructor(options = {}) {
+        super(options);
+    }
+    /** Start dispatch tasks for all registered subscribers. */
+    async start() {
+        if (this._running) {
+            return;
+        }
+        this._running = true;
+        for (const sub of this._subscriptions.values()) {
+            this._startDispatchTask(sub);
+        }
+        // Schedule tasks right away.
+        await sleep(0);
+    }
+    /** Stop all dispatch tasks. */
+    async stop() {
+        if (!this._running) {
+            return;
+        }
+        this._running = false;
+        for (const sub of this._subscriptions.values()) {
+            if (sub.routerTask) {
+                await this.cancelTask(sub.routerTask);
+                sub.routerTask = null;
+            }
+            if (sub.dataTask) {
+                await this.cancelTask(sub.dataTask);
+                sub.dataTask = null;
+            }
+        }
+    }
+    /**
+     * Register a subscriber to receive messages from the bus.
+     *
+     * Idempotent: re-subscribing an already-registered subscriber is a no-op.
+     *
+     * @param subscriber The `BusSubscriber` to register.
+     */
+    async subscribe(subscriber) {
+        if (this._subscriptions.has(subscriber.name)) {
+            return;
+        }
+        const sub = new BusSubscription({ subscriber });
+        if (this._running) {
+            this._startDispatchTask(sub);
+            // Schedule worker right away.
+            await sleep(0);
+        }
+        this._subscriptions.set(subscriber.name, sub);
+    }
+    /**
+     * Remove a subscriber and cancel its dispatch tasks.
+     *
+     * @param subscriber The `BusSubscriber` to remove.
+     */
+    async unsubscribe(subscriber) {
+        const sub = this._subscriptions.get(subscriber.name);
+        this._subscriptions.delete(subscriber.name);
+        if (sub) {
+            if (sub.routerTask) {
+                await this.cancelTask(sub.routerTask);
+            }
+            if (sub.dataTask) {
+                await this.cancelTask(sub.dataTask);
+            }
+        }
+    }
+    /**
+     * Send a message through the bus.
+     *
+     * Local-only messages are delivered directly to subscribers. All other
+     * messages are passed to `publish()` for transport.
+     *
+     * @param message The bus message to send.
+     */
+    async send(message) {
+        if (message instanceof BusLocalMessage) {
+            this.onMessageReceived(message);
+            return;
+        }
+        await this.publish(message);
+    }
+    /**
+     * Deliver a message to all local subscribers via their priority queues.
+     *
+     * Called by bus implementations when a message arrives (either from a local
+     * `send()` or from a network transport).
+     */
+    onMessageReceived(message) {
+        for (const sub of this._subscriptions.values()) {
+            sub.queue.putNowait(message);
+        }
+    }
+    /** Start the router and data dispatch tasks for a subscriber. */
+    _startDispatchTask(sub) {
+        sub.routerTask = this.createTask(() => this._routerTask(sub), `bus_router_${sub.subscriber}`);
+        sub.dataTask = this.createTask(() => this._dataDispatchTask(sub), `bus_data_${sub.subscriber}`);
+    }
+    /** Route system messages inline, data messages to the data queue. */
+    async _routerTask(sub) {
+        while (true) {
+            const message = await sub.queue.get();
+            if (!sub.subscriber.acceptsBusMessage(message)) {
+                continue;
+            }
+            if (message instanceof BusSystemMessage) {
+                // A subscriber exception must not tear down the dispatch task, or the
+                // subscriber would silently stop receiving all future messages
+                // (including cancel/cleanup). Log and keep going.
+                try {
+                    await sub.subscriber.onBusMessage(message);
+                }
+                catch (e) {
+                    rethrowIfCancelled(e);
+                    logger.exception(`${this}: subscriber '${sub.subscriber.name}' raised handling ` +
+                        `system message ${message}; keeping dispatch alive`, e);
+                }
+            }
+            else {
+                sub.dataQueue.putNowait(message);
+            }
+        }
+    }
+    /** Process data messages sequentially from the data queue. */
+    async _dataDispatchTask(sub) {
+        while (true) {
+            const message = await sub.dataQueue.get();
+            if (!sub.subscriber.acceptsBusMessage(message)) {
+                continue;
+            }
+            // A subscriber exception must not tear down the dispatch task, or the
+            // subscriber would silently stop receiving all future messages
+            // (including cancel/cleanup). Log and keep going.
+            try {
+                await sub.subscriber.onBusMessage(message);
+            }
+            catch (e) {
+                rethrowIfCancelled(e);
+                logger.exception(`${this}: subscriber '${sub.subscriber.name}' raised handling ` +
+                    `data message ${message}; keeping dispatch alive`, e);
+            }
+        }
+    }
+}
+//# sourceMappingURL=bus.js.map

package/dist/bus/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Worker bus package -- pub/sub messaging between workers and the runner.
+ *
+ * Provides the pub/sub infrastructure that connects workers to each other and
+ * to the runner. Key components:
+ *
+ * - `WorkerBus` -- abstract base class defining the send/receive interface.
+ * - `AsyncQueueBus` -- in-process implementation backed by an asyncio `Queue`.
+ * - `BusBridgeProcessor` -- bidirectional mid-pipeline bridge for
+ *   transport/session workers that exchanges frames with other workers
+ *   through the bus.
+ * - `BusMessage` and its subclasses -- the typed message hierarchy used for
+ *   worker lifecycle events (activation, cancellation, shutdown), job
+ *   coordination, and frame transport.
+ */
+export { WorkerRegistryEntry } from "../registry/types.ts";
+export { BusBridgeProcessor } from "./bridge_processor.ts";
+export { WorkerBus } from "./bus.ts";
+export { AsyncQueueBus } from "./local/index.ts";
+export { BusActivateWorkerMessage, BusAddWorkerMessage, BusCancelMessage, BusCancelWorkerMessage, BusDataMessage, BusDeactivateWorkerMessage, BusEndMessage, BusEndWorkerMessage, BusFlushProgressMessage, BusFrameMessage, BusJobCancelMessage, BusJobRequestMessage, BusJobResponseMessage, BusJobResponseUrgentMessage, BusJobStreamDataMessage, BusJobStreamEndMessage, BusJobStreamStartMessage, BusJobUpdateMessage, BusJobUpdateRequestMessage, BusJobUpdateUrgentMessage, BusLocalMessage, BusMessage, BusSystemMessage, BusTTSSpeakMessage, BusWorkerErrorMessage, BusWorkerLocalErrorMessage, BusWorkerReadyMessage, BusWorkerRegistryMessage, } from "./messages.ts";
+export { BusSubscriber } from "./subscriber.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/bus/index.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/__init__.py
+/**
+ * Worker bus package -- pub/sub messaging between workers and the runner.
+ *
+ * Provides the pub/sub infrastructure that connects workers to each other and
+ * to the runner. Key components:
+ *
+ * - `WorkerBus` -- abstract base class defining the send/receive interface.
+ * - `AsyncQueueBus` -- in-process implementation backed by an asyncio `Queue`.
+ * - `BusBridgeProcessor` -- bidirectional mid-pipeline bridge for
+ *   transport/session workers that exchanges frames with other workers
+ *   through the bus.
+ * - `BusMessage` and its subclasses -- the typed message hierarchy used for
+ *   worker lifecycle events (activation, cancellation, shutdown), job
+ *   coordination, and frame transport.
+ */
+export { WorkerRegistryEntry } from "../registry/types.js";
+export { BusBridgeProcessor } from "./bridge_processor.js";
+export { WorkerBus } from "./bus.js";
+export { AsyncQueueBus } from "./local/index.js";
+export { BusActivateWorkerMessage, BusAddWorkerMessage, BusCancelMessage, BusCancelWorkerMessage, BusDataMessage, BusDeactivateWorkerMessage, BusEndMessage, BusEndWorkerMessage, BusFlushProgressMessage, BusFrameMessage, BusJobCancelMessage, BusJobRequestMessage, BusJobResponseMessage, BusJobResponseUrgentMessage, BusJobStreamDataMessage, BusJobStreamEndMessage, BusJobStreamStartMessage, BusJobUpdateMessage, BusJobUpdateRequestMessage, BusJobUpdateUrgentMessage, BusLocalMessage, BusMessage, BusSystemMessage, BusTTSSpeakMessage, BusWorkerErrorMessage, BusWorkerLocalErrorMessage, BusWorkerReadyMessage, BusWorkerRegistryMessage, } from "./messages.js";
+export { BusSubscriber } from "./subscriber.js";
+//# sourceMappingURL=index.js.map

package/dist/bus/local/async_queue.d.ts

@@ -0,0 +1,12 @@
+import { WorkerBus } from "../bus.ts";
+import type { BusMessage } from "../messages.ts";
+/** In-process bus that delivers messages via priority queues. */
+export declare class AsyncQueueBus extends WorkerBus {
+    /**
+     * Deliver a message to all local subscriber queues.
+     *
+     * @param message The bus message to deliver.
+     */
+    publish(message: BusMessage): Promise<void>;
+}
+//# sourceMappingURL=async_queue.d.ts.map

package/dist/bus/local/async_queue.js

@@ -0,0 +1,21 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/local/async_queue.py
+/** In-process worker bus backed by asyncio queues. */
+import { logger } from "../../utils/logger.js";
+import { WorkerBus } from "../bus.js";
+/** In-process bus that delivers messages via priority queues. */
+export class AsyncQueueBus extends WorkerBus {
+    /**
+     * Deliver a message to all local subscriber queues.
+     *
+     * @param message The bus message to deliver.
+     */
+    async publish(message) {
+        logger.trace(`${this}: sending ${message}`);
+        this.onMessageReceived(message);
+    }
+}
+//# sourceMappingURL=async_queue.js.map

package/dist/bus/local/index.d.ts

@@ -0,0 +1,3 @@
+/** Local (in-process) bus implementations. */
+export { AsyncQueueBus } from "./async_queue.ts";
+//# sourceMappingURL=index.d.ts.map