@pipedog/core 0.0.0 → 0.2.0

package/dist/bus/serializers/json.js

@@ -0,0 +1,367 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/serializers/json.py
+/**
+ * JSON-based bus message serializer with pluggable type adapters.
+ *
+ * PORTING NOTES (the wire format is upstream's, so TS and Python workers can
+ * share a network bus):
+ *
+ * - Python tags a typed value with its fully qualified class name
+ *   (`"pipecat.frames.frames.TextFrame"`) and resolves it back with
+ *   `importlib`. JavaScript has neither module names on classes nor dynamic
+ *   synchronous imports, so classes are resolved through a registry
+ *   (`registerSerializableType()`). Every class exported by
+ *   `frames/frames.ts`, `bus/messages.ts` and `bus/ui/messages.ts` is
+ *   registered under its upstream name, along with the other Pipecat types
+ *   bus messages carry. An instance of an unregistered class is skipped with
+ *   the "unserializable type" warning.
+ * - Dataclass field names travel in snake_case, as upstream sends them;
+ *   class fields are camelCase in TS and are converted both ways. Keys of
+ *   plain dicts are sent unchanged.
+ * - `as const` enums are plain values in TS, so a value can't say which enum
+ *   it belongs to. Fields holding a (non-string) upstream `Enum` are declared
+ *   with `registerEnumField()` so they are tagged as upstream tags them
+ *   (`BusFrameMessage.direction` is declared by default). Class-based enums
+ *   (`ErrorCategory`) are recognized on their own. `StrEnum` values are plain
+ *   strings on both sides.
+ * - Pydantic models and dataclasses are both plain classes in TS and are
+ *   serialized the same way (fields set to null are left out).
+ * - On deserialization the decoded fields are passed to the class's options
+ *   constructor and then assigned to the instance, which covers upstream's
+ *   `init=False` fields.
+ */
+import { FunctionSchema } from "../../adapters/schemas/function_schema.js";
+import { ToolsSchema } from "../../adapters/schemas/tools_schema.js";
+import * as frames from "../../frames/frames.js";
+import * as metrics from "../../metrics/metrics.js";
+import { LLMContext, LLMSpecificMessage } from "../../processors/aggregators/llm_context.js";
+import { FrameDirection } from "../../processors/frame_processor.js";
+import * as registryTypes from "../../registry/types.js";
+import { ErrorCategory } from "../../utils/errors.js";
+import { logger } from "../../utils/logger.js";
+import { LLMContextAdapter, ToolsSchemaAdapter } from "../adapters/index.js";
+import * as messages from "../messages.js";
+import { BusFrameMessage } from "../messages.js";
+import * as uiMessages from "../ui/messages.js";
+import { MessageSerializer } from "./base.js";
+// Upstream's `_resolve_type` resolves any importable name; here, the registry.
+const typesByName = new Map();
+const namesByType = new Map();
+// Fields that hold a value of an `as const` enum, by the class declaring them.
+const enumFields = new Map();
+/**
+ * Register a type under its fully qualified (upstream) name, so it can be
+ * tagged on serialization and resolved on deserialization.
+ *
+ * @param qualifiedName Dotted path like `"pipecat.frames.frames.TextFrame"`.
+ * @param type The class, or the `as const` enum object.
+ */
+export function registerSerializableType(qualifiedName, type) {
+    typesByName.set(qualifiedName, type);
+    namesByType.set(type, qualifiedName);
+}
+/**
+ * Declare that a class field holds a value of an `as const` enum, so the
+ * value is tagged with the enum's name as upstream tags an `Enum` member.
+ * The enum must be registered with `registerSerializableType()`.
+ *
+ * @param type The class declaring the field (subclasses inherit it).
+ * @param field The field's (camelCase) name.
+ * @param enumType The enum object.
+ */
+export function registerEnumField(type, field, enumType) {
+    let fields = enumFields.get(type);
+    if (!fields) {
+        fields = new Map();
+        enumFields.set(type, fields);
+    }
+    fields.set(field, enumType);
+}
+function isClass(value) {
+    return typeof value === "function" && /^class[\s{]/.test(Function.prototype.toString.call(value));
+}
+function registerModule(prefix, namespace) {
+    for (const [name, value] of Object.entries(namespace)) {
+        if (isClass(value) && !namesByType.has(value)) {
+            registerSerializableType(`${prefix}.${name}`, value);
+        }
+    }
+}
+let defaultsRegistered = false;
+function registerDefaultTypes() {
+    if (defaultsRegistered) {
+        return;
+    }
+    defaultsRegistered = true;
+    registerModule("pipecat.frames.frames", frames);
+    registerModule("pipecat.bus.messages", messages);
+    registerModule("pipecat.bus.ui.messages", uiMessages);
+    registerModule("pipecat.metrics.metrics", metrics);
+    registerModule("pipecat.registry.types", registryTypes);
+    registerSerializableType("pipecat.processors.aggregators.llm_context.LLMContext", LLMContext);
+    registerSerializableType("pipecat.processors.aggregators.llm_context.LLMSpecificMessage", LLMSpecificMessage);
+    registerSerializableType("pipecat.adapters.schemas.tools_schema.ToolsSchema", ToolsSchema);
+    registerSerializableType("pipecat.adapters.schemas.function_schema.FunctionSchema", FunctionSchema);
+    registerSerializableType("pipecat.processors.frame_processor.FrameDirection", FrameDirection);
+    // ErrorCategory has a private constructor, so it is not a `Ctor` to the type checker.
+    registerSerializableType("pipecat.utils.errors.ErrorCategory", ErrorCategory);
+    registerEnumField(BusFrameMessage, "direction", FrameDirection);
+}
+function camelToSnake(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function snakeToCamel(name) {
+    return name.replace(/([a-z0-9])_([a-z0-9])/g, (_m, a, b) => a + b.toUpperCase());
+}
+function bytesToBase64(data) {
+    let binary = "";
+    const chunk = 0x8000;
+    for (let i = 0; i < data.length; i += chunk) {
+        binary += String.fromCharCode(...data.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+}
+function base64ToBytes(encoded) {
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+function isJsonNative(value) {
+    return (value === null ||
+        value === undefined ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/** A class-based enum (static members with `name`, plus `values()` and `fromValue()`). */
+function isClassEnum(type) {
+    const ctor = type;
+    return typeof ctor?.values === "function" && typeof ctor?.fromValue === "function";
+}
+/** The `as const` enum declared for `field` on `type` or one of its bases. */
+function enumFieldType(type, field) {
+    let proto = type.prototype;
+    while (proto && proto !== Object.prototype) {
+        const found = enumFields.get(proto.constructor)?.get(field);
+        if (found) {
+            return found;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+/**
+ * Serialize bus messages as JSON with pluggable type adapters.
+ *
+ * Handles JSON-native types, enums, bytes, dataclasses, and any type with a
+ * registered `TypeAdapter` (e.g. `LLMContext`, `ToolsSchema`). Adapters for
+ * common Pipecat types are registered by default. Additional type adapters
+ * can be registered via `registerAdapter()`.
+ *
+ * @example
+ * const serializer = new JSONMessageSerializer();
+ *
+ * const data = serializer.serialize(message);
+ * const restored = serializer.deserialize(data);
+ */
+export class JSONMessageSerializer extends MessageSerializer {
+    _adapters;
+    /** Create a serializer with default adapters for `LLMContext` and `ToolsSchema`. */
+    constructor() {
+        super();
+        registerDefaultTypes();
+        this._adapters = new Map([
+            [LLMContext, new LLMContextAdapter()],
+            [ToolsSchema, new ToolsSchemaAdapter()],
+        ]);
+    }
+    /**
+     * Register a type adapter.
+     *
+     * @param type The type to handle.
+     * @param adapter The adapter that serializes/deserializes instances of this type.
+     */
+    registerAdapter(type, adapter) {
+        this._adapters.set(type, adapter);
+    }
+    /**
+     * Convert a bus message to JSON bytes.
+     *
+     * @param message The bus message to serialize.
+     * @returns UTF-8 encoded JSON bytes.
+     */
+    serialize(message) {
+        const data = this._serializeValue(message);
+        return new TextEncoder().encode(JSON.stringify(data));
+    }
+    /**
+     * Reconstruct a bus message from JSON bytes.
+     *
+     * @param data The JSON bytes produced by `serialize()`.
+     * @returns The reconstructed `BusMessage`, or null if deserialization fails.
+     */
+    deserialize(data) {
+        const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+        const payload = JSON.parse(text);
+        return this._deserializeValue(payload);
+    }
+    /** Recursively serialize a value to a JSON-compatible representation. */
+    _serializeValue(value) {
+        if (isJsonNative(value)) {
+            return value ?? null;
+        }
+        if (isClassEnum(value.constructor)) {
+            const name = namesByType.get(value.constructor);
+            if (name !== undefined) {
+                return { __type__: name, __data__: value.name };
+            }
+        }
+        if (isPlainObject(value)) {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, this._serializeValue(v)]));
+        }
+        if (value instanceof Map) {
+            return Object.fromEntries([...value.entries()].map(([k, v]) => [String(k), this._serializeValue(v)]));
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => this._serializeValue(v));
+        }
+        if (value instanceof Uint8Array) {
+            return { __type__: "bytes", __data__: bytesToBase64(value) };
+        }
+        if (typeof value === "function") {
+            return null;
+        }
+        const type = value.constructor;
+        const typeName = namesByType.get(type);
+        const adapter = this._findAdapter(type);
+        if (adapter !== null && typeName !== undefined) {
+            return {
+                __type__: typeName,
+                __data__: adapter.serialize(value, (v) => this._serializeValue(v)),
+            };
+        }
+        if (typeof value === "object" && typeName !== undefined) {
+            const fields = {};
+            for (const [key, v] of Object.entries(value)) {
+                if (v === null || v === undefined) {
+                    continue;
+                }
+                const enumType = enumFieldType(type, key);
+                const serialized = enumType ? this._serializeEnum(enumType, v) : this._serializeValue(v);
+                if (serialized !== null) {
+                    fields[camelToSnake(key)] = serialized;
+                }
+            }
+            return { __type__: typeName, __data__: fields };
+        }
+        logger.warning(`JSONMessageSerializer: skipping field with unserializable type ${type?.name ?? typeof value}`);
+        return null;
+    }
+    /** Tag a value of an `as const` enum with its member name. */
+    _serializeEnum(enumType, value) {
+        const typeName = namesByType.get(enumType);
+        const member = Object.entries(enumType).find(([, v]) => v === value)?.[0];
+        if (typeName === undefined || member === undefined) {
+            return this._serializeValue(value);
+        }
+        return { __type__: typeName, __data__: member };
+    }
+    /** Recursively deserialize a value from its JSON representation. */
+    _deserializeValue(value) {
+        if (isJsonNative(value)) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => this._deserializeValue(v));
+        }
+        if (isPlainObject(value)) {
+            if ("__type__" in value && "__data__" in value) {
+                return this._deserializeTyped(value.__type__, value.__data__);
+            }
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, this._deserializeValue(v)]));
+        }
+        return value;
+    }
+    /** Deserialize a tagged value using its fully qualified type name. */
+    _deserializeTyped(typeName, data) {
+        if (typeName === "bytes") {
+            return base64ToBytes(data);
+        }
+        const type = resolveType(typeName);
+        if (type === null) {
+            logger.warning(`JSONMessageSerializer: could not resolve type ${typeName}`);
+            return null;
+        }
+        if (!isClass(type)) {
+            // An `as const` enum: look the member up by name.
+            return enumMember(type, typeName, data);
+        }
+        if (isClassEnum(type)) {
+            return enumMember(type, typeName, data);
+        }
+        const adapter = this._findAdapter(type);
+        if (adapter !== null) {
+            return adapter.deserialize(data, (v) => this._deserializeValue(v), type);
+        }
+        if (isPlainObject(data)) {
+            const fields = {};
+            for (const [key, value] of Object.entries(data)) {
+                fields[snakeToCamel(key)] = this._deserializeValue(value);
+            }
+            const Concrete = type;
+            const obj = new Concrete({ ...fields });
+            for (const [key, value] of Object.entries(fields)) {
+                obj[key] = value;
+            }
+            return obj;
+        }
+        logger.warning(`JSONMessageSerializer: no adapter registered for type ${typeName}`);
+        return null;
+    }
+    /** Find an adapter for a type, checking parent classes through the prototype chain. */
+    _findAdapter(type) {
+        let proto = type?.prototype ?? null;
+        while (proto && proto !== Object.prototype) {
+            const adapter = this._adapters.get(proto.constructor);
+            if (adapter) {
+                return adapter;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return null;
+    }
+}
+/** The enum member called `name`, as Python's `cls[name]` (which raises KeyError). */
+function enumMember(type, typeName, name) {
+    if (!Object.hasOwn(type, name)) {
+        throw new Error(`${typeName} has no member '${name}'`);
+    }
+    return type[name];
+}
+/**
+ * Resolve a fully qualified type name to its class.
+ *
+ * @param qualifiedName Dotted path like `"pipecat.frames.frames.TextFrame"`.
+ * @returns The resolved class (or enum), or null if it cannot be found.
+ */
+function resolveType(qualifiedName) {
+    const index = qualifiedName.lastIndexOf(".");
+    if (index <= 0) {
+        return null;
+    }
+    return typesByName.get(qualifiedName) ?? null;
+}
+//# sourceMappingURL=json.js.map

package/dist/bus/subscriber.d.ts

@@ -0,0 +1,46 @@
+/** Bus subscriber mixin for receiving messages from a WorkerBus. */
+import { type Ctor } from "../utils/mixin.ts";
+import type { BusMessage } from "./messages.ts";
+/**
+ * An object that receives messages from a `WorkerBus`.
+ *
+ * Implementors override `onBusMessage()` to handle incoming messages.
+ * Concrete subscribers must provide a `name` property (typically inherited
+ * from `BaseObject`).
+ */
+export interface BusSubscriber extends BusSubscriberMethods {
+    /** Unique name identifying this subscriber on the bus. */
+    readonly name: string;
+}
+/** The members the `BusSubscriber` mixin provides (the base supplies `name`). */
+export interface BusSubscriberMethods {
+    /**
+     * Whether this subscriber should be handed this message.
+     *
+     * Checked by the bus before every delivery. Returning false drops the
+     * message for this subscriber alone; others still receive it. Subscribers
+     * that take everything, which is the default, need not override this.
+     *
+     * @param message The bus message about to be delivered.
+     * @returns Whether to deliver the message.
+     */
+    acceptsBusMessage(message: BusMessage): boolean;
+    /**
+     * Handle an incoming bus message.
+     *
+     * Only called for messages `acceptsBusMessage` allowed.
+     *
+     * @param message The bus message to handle.
+     */
+    onBusMessage(message: BusMessage): Promise<void>;
+}
+/**
+ * Mixin for objects that receive messages from a `WorkerBus`:
+ * `class BaseWorker(BaseObject, BusSubscriber)` →
+ * `class BaseWorker extends BusSubscriber(BaseObject)`.
+ *
+ * The base class provides `name` (upstream's `name` property raises
+ * `NotImplementedError` and is always supplied by `BaseObject`).
+ */
+export declare const BusSubscriber: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<BusSubscriberMethods>, BusSubscriber>;
+//# sourceMappingURL=subscriber.d.ts.map

package/dist/bus/subscriber.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/subscriber.py
+/** Bus subscriber mixin for receiving messages from a WorkerBus. */
+import { defineMixin } from "../utils/mixin.js";
+/**
+ * Mixin for objects that receive messages from a `WorkerBus`:
+ * `class BaseWorker(BaseObject, BusSubscriber)` →
+ * `class BaseWorker extends BusSubscriber(BaseObject)`.
+ *
+ * The base class provides `name` (upstream's `name` property raises
+ * `NotImplementedError` and is always supplied by `BaseObject`).
+ */
+export const BusSubscriber = defineMixin("BusSubscriber", (Base) => {
+    class BusSubscriberMixin extends Base {
+        /** See `BusSubscriber.acceptsBusMessage`. Accepts everything by default. */
+        acceptsBusMessage(_message) {
+            return true;
+        }
+        /** See `BusSubscriber.onBusMessage`. Does nothing by default. */
+        async onBusMessage(_message) { }
+    }
+    return BusSubscriberMixin;
+});
+//# sourceMappingURL=subscriber.js.map

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

@@ -0,0 +1,3 @@
+/** UI bus carriers exchanged between `PipelineWorker` and `UIWorker`. */
+export { BusUICommandMessage, BusUIDataMessage, BusUIEventMessage, BusUIJobCompletedMessage, BusUIJobGroupCompletedMessage, BusUIJobGroupStartedMessage, BusUIJobUpdateMessage, UI_CANCEL_JOB_GROUP_EVENT_NAME, UI_SNAPSHOT_EVENT_NAME, } from "./messages.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/bus/ui/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/ui/__init__.py
+/** UI bus carriers exchanged between `PipelineWorker` and `UIWorker`. */
+export { BusUICommandMessage, BusUIDataMessage, BusUIEventMessage, BusUIJobCompletedMessage, BusUIJobGroupCompletedMessage, BusUIJobGroupStartedMessage, BusUIJobUpdateMessage, UI_CANCEL_JOB_GROUP_EVENT_NAME, UI_SNAPSHOT_EVENT_NAME, } from "./messages.js";
+//# sourceMappingURL=index.js.map

package/dist/bus/ui/messages.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Bus carriers for the UI Worker protocol.
+ *
+ * These classes are the on-the-bus shape that a UI worker (see `workers/ui`)
+ * and the client-facing worker exchange. They are NOT the on-the-wire format
+ * the client sees: the client-facing worker translates between the two, in
+ * whichever format its own client speaks.
+ *
+ * For example, `PipelineWorker` with RTVI enabled republishes inbound client
+ * messages onto the bus in `onUiMessage` and turns outbound carriers into
+ * RTVI frames in `onBusMessage`; the wire types it produces live in
+ * `processors/frameworks/rtvi/models` (`UIEventMessage`, `UICommandMessage`,
+ * `UIJobGroupMessage`, ...).
+ *
+ * All carriers subclass `BusUIDataMessage`, which a client-facing worker
+ * dispatches on to pick the outbound ones out of its bus traffic.
+ *
+ * - `BusUIEventMessage` and `BusUICommandMessage` carry client events and
+ *   server commands respectively.
+ * - `BusUIJobGroupStartedMessage`, `BusUIJobUpdateMessage`,
+ *   `BusUIJobCompletedMessage`, and `BusUIJobGroupCompletedMessage` carry the
+ *   four phases of a user-facing job group's lifecycle (see `UIWorker`).
+ *
+ * The carriers live in the `bus` layer (rather than alongside `UIWorker`)
+ * because both `PipelineWorker` (in `pipeline`) and `UIWorker` (in
+ * `workers`) reference them, and `pipeline` must not import from `workers`.
+ */
+import { BusDataMessage, type BusMessageOptions } from "../messages.ts";
+/**
+ * The `eventName` of the client's accessibility snapshot on the bus. A
+ * client-facing worker republishes a `ui-snapshot` wire message as a
+ * `BusUIEventMessage` with this name, and `UIWorker` keeps the payload as its
+ * latest snapshot. The leading double underscore keeps app-defined
+ * `@ui_event` names from colliding with it.
+ */
+export declare const UI_SNAPSHOT_EVENT_NAME = "__ui_snapshot";
+/**
+ * The `eventName` of the client's request to cancel a job group. A
+ * client-facing worker republishes a `ui-cancel-job-group` wire message as a
+ * `BusUIEventMessage` with this name, and the worker that dispatched the
+ * group turns it into a cancel request.
+ */
+export declare const UI_CANCEL_JOB_GROUP_EVENT_NAME = "__cancel_job_group";
+/**
+ * Base for all UI Worker protocol bus carriers.
+ *
+ * A client-facing worker dispatches on this type to translate a worker's
+ * outbound UI carriers into its client's wire format, so every UI bus message
+ * below subclasses it.
+ */
+export declare class BusUIDataMessage extends BusDataMessage {
+}
+export interface BusUIEventMessageOptions extends BusMessageOptions {
+    /** App-defined event name. */
+    eventName?: string;
+    /** App-defined payload. Schemaless by design. */
+    payload?: unknown;
+}
+/**
+ * A UI event sent from the client to a server-side worker.
+ *
+ * Emitted by the client-facing worker when the client dispatches an event via
+ * `PipecatClient.sendUIEvent(event, payload)`. `UIWorker` subclasses dispatch
+ * these to `@ui_event(name)` handlers.
+ */
+export declare class BusUIEventMessage extends BusUIDataMessage {
+    eventName: string;
+    payload: unknown;
+    constructor(options: BusUIEventMessageOptions);
+}
+export interface BusUICommandMessageOptions extends BusMessageOptions {
+    /** App-defined command name. */
+    commandName?: string;
+    /** App-defined payload (already a plain object by the time it lands on the bus). */
+    payload?: unknown;
+}
+/**
+ * A UI command sent from a server-side worker to the client.
+ *
+ * Published by `UIWorker.sendCommand(name, payload)`. The client-facing
+ * worker translates it into a command on its client's wire format; over RTVI
+ * that is an `RTVIUICommandFrame({ command: commandName, payload })` pushed
+ * through the pipeline.
+ */
+export declare class BusUICommandMessage extends BusUIDataMessage {
+    commandName: string;
+    payload: unknown;
+    constructor(options: BusUICommandMessageOptions);
+}
+export interface BusUIJobGroupStartedMessageOptions extends BusMessageOptions {
+    /** Shared job-group identifier for the group. */
+    jobId?: string;
+    /** Names of the workers the work was dispatched to. */
+    workers?: string[] | null;
+    /** Optional human-readable label for the group. */
+    label?: string | null;
+    /** Whether the client may request cancellation. */
+    cancellable?: boolean;
+    /** Epoch milliseconds when the group started. */
+    at?: number;
+}
+/**
+ * A user-facing job group has been dispatched.
+ *
+ * Published by a `UIWorker` as it dispatches the group. The client-facing
+ * worker forwards it as a `ui-job-group` envelope with
+ * `kind = "group_started"`.
+ */
+export declare class BusUIJobGroupStartedMessage extends BusUIDataMessage {
+    jobId: string;
+    workers: string[] | null;
+    label: string | null;
+    cancellable: boolean;
+    at: number;
+    constructor(options: BusUIJobGroupStartedMessageOptions);
+}
+export interface BusUIJobUpdateMessageOptions extends BusMessageOptions {
+    /** The shared job-group identifier. */
+    jobId?: string;
+    /** The worker that produced the update. */
+    workerName?: string;
+    /** The worker's update payload, forwarded verbatim. */
+    data?: unknown;
+    /** Epoch milliseconds when the update was emitted on the bus. */
+    at?: number;
+}
+/**
+ * Per-worker progress for a user-facing job group.
+ *
+ * Forwarded by a `UIWorker` whenever a worker of one of its job groups emits
+ * a `BusJobUpdateMessage`. The client-facing worker forwards it as a
+ * `ui-job-group` envelope with `kind = "job_update"`.
+ */
+export declare class BusUIJobUpdateMessage extends BusUIDataMessage {
+    jobId: string;
+    workerName: string;
+    data: unknown;
+    at: number;
+    constructor(options: BusUIJobUpdateMessageOptions);
+}
+export interface BusUIJobCompletedMessageOptions extends BusMessageOptions {
+    /** The shared job-group identifier. */
+    jobId?: string;
+    /** The worker that produced the response. */
+    workerName?: string;
+    /** Completion status as a string (`JobStatus` value). */
+    status?: string;
+    /** The worker's response payload. */
+    response?: unknown;
+    /** Epoch milliseconds when the response was received. */
+    at?: number;
+}
+/**
+ * A worker in a user-facing job group has completed.
+ *
+ * Forwarded by a `UIWorker` when a worker of one of its job groups reaches a
+ * terminal state. The client-facing worker forwards it as a `ui-job-group`
+ * envelope with `kind = "job_completed"`.
+ */
+export declare class BusUIJobCompletedMessage extends BusUIDataMessage {
+    jobId: string;
+    workerName: string;
+    status: string;
+    response: unknown;
+    at: number;
+    constructor(options: BusUIJobCompletedMessageOptions);
+}
+export interface BusUIJobGroupCompletedMessageOptions extends BusMessageOptions {
+    /** The shared job-group identifier. */
+    jobId?: string;
+    /** Epoch milliseconds when the group completed. */
+    at?: number;
+}
+/**
+ * A user-facing job group has completed.
+ *
+ * Published by a `UIWorker` once every worker in the group has finished, or
+ * the group was cancelled. The client-facing worker forwards it as a
+ * `ui-job-group` envelope with `kind = "group_completed"`.
+ */
+export declare class BusUIJobGroupCompletedMessage extends BusUIDataMessage {
+    jobId: string;
+    at: number;
+    constructor(options: BusUIJobGroupCompletedMessageOptions);
+}
+//# sourceMappingURL=messages.d.ts.map