@ceralive/cerastream 2026.6.0-rc.1

package/dist/errors.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+/**
+ * Thrown by every contract-stub function body (Task 17). The schema in this
+ * package is real and frozen; the IPC client/transport is implemented in Task 31.
+ * Every stub throws this so callers fail loud and honest, never silently no-op.
+ */
+export declare class NotImplementedError extends Error {
+    constructor(symbol: string);
+}
+/**
+ * Thrown when the engine returns a JSON-RPC error response (Task 31). Carries the
+ * numeric JSON-RPC code, the stable string `data.code` (a {@link RpcErrorCode}
+ * when it is a member of the frozen Tier-1 enum, or a transport-tier protocol
+ * string such as `cerastream.protocol.parse_error`), and the human message.
+ */
+export declare class CerastreamRpcError extends Error {
+    /** Numeric JSON-RPC `error.code`. */
+    readonly code: number;
+    /** Stable string `error.data.code`, when the server supplied one. */
+    readonly dataCode: string | undefined;
+    /** The request id this error answered, when present. */
+    readonly requestId: number | string | null;
+    constructor(code: number, message: string, dataCode: string | undefined, requestId: number | string | null);
+}
+/**
+ * Thrown when the control connection is lost (socket closed/errored) while a
+ * request was in flight, or when {@link connect} cannot reach the engine and
+ * auto-reconnect is disabled.
+ */
+export declare class CerastreamConnectionError extends Error {
+    /** The underlying transport error, when there was one. */
+    readonly cause: unknown;
+    constructor(message: string, cause?: unknown);
+}
+/** Thrown when a request exceeds the configured per-request timeout. */
+export declare class CerastreamTimeoutError extends Error {
+    constructor(method: string, timeoutMs: number);
+}
+export declare const rpcErrorCodeSchema: z.ZodEnum<{
+    "cerastream.protocol.unsupported_version": "cerastream.protocol.unsupported_version";
+    "cerastream.params.invalid": "cerastream.params.invalid";
+    "cerastream.state.not_streaming": "cerastream.state.not_streaming";
+    "cerastream.state.already_streaming": "cerastream.state.already_streaming";
+    "cerastream.device.not_found": "cerastream.device.not_found";
+    "cerastream.bitrate.out_of_range": "cerastream.bitrate.out_of_range";
+    "cerastream.preview.unsupported_tier": "cerastream.preview.unsupported_tier";
+    "cerastream.internal": "cerastream.internal";
+}>;
+export type RpcErrorCode = z.infer<typeof rpcErrorCodeSchema>;
+/**
+ * Numeric JSON-RPC `error.code` for each Tier 1 string code (schema.md Error
+ * codes table). `-32000…-32099` is the JSON-RPC application range; `-32602` /
+ * `-32603` are the reserved invalid-params / internal-error codes.
+ */
+export declare const RPC_ERROR_NUMERIC: Readonly<Record<RpcErrorCode, number>>;
+export declare const processErrorCodeSchema: z.ZodEnum<{
+    srtla_initial_connect_failed: "srtla_initial_connect_failed";
+    srtla_no_connections: "srtla_no_connections";
+    capture_audio_error: "capture_audio_error";
+    capture_video_error: "capture_video_error";
+    pipeline_stall: "pipeline_stall";
+    srt_connect_failed: "srt_connect_failed";
+    srt_connection_lost: "srt_connection_lost";
+}>;
+export type ProcessErrorCode = z.infer<typeof processErrorCodeSchema>;
+/** Origin of a Tier 2 runtime error (the notification channel CeraUI routes on). */
+export declare const processErrorSourceSchema: z.ZodEnum<{
+    srtla: "srtla";
+    engine: "engine";
+}>;
+export type ProcessErrorSource = z.infer<typeof processErrorSourceSchema>;

package/dist/errors.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+/**
+ * Thrown by every contract-stub function body (Task 17). The schema in this
+ * package is real and frozen; the IPC client/transport is implemented in Task 31.
+ * Every stub throws this so callers fail loud and honest, never silently no-op.
+ */
+export class NotImplementedError extends Error {
+    constructor(symbol) {
+        super(`${symbol}: not yet implemented`);
+        this.name = "NotImplementedError";
+    }
+}
+/**
+ * Thrown when the engine returns a JSON-RPC error response (Task 31). Carries the
+ * numeric JSON-RPC code, the stable string `data.code` (a {@link RpcErrorCode}
+ * when it is a member of the frozen Tier-1 enum, or a transport-tier protocol
+ * string such as `cerastream.protocol.parse_error`), and the human message.
+ */
+export class CerastreamRpcError extends Error {
+    /** Numeric JSON-RPC `error.code`. */
+    code;
+    /** Stable string `error.data.code`, when the server supplied one. */
+    dataCode;
+    /** The request id this error answered, when present. */
+    requestId;
+    constructor(code, message, dataCode, requestId) {
+        super(message);
+        this.name = "CerastreamRpcError";
+        this.code = code;
+        this.dataCode = dataCode;
+        this.requestId = requestId;
+    }
+}
+/**
+ * Thrown when the control connection is lost (socket closed/errored) while a
+ * request was in flight, or when {@link connect} cannot reach the engine and
+ * auto-reconnect is disabled.
+ */
+export class CerastreamConnectionError extends Error {
+    /** The underlying transport error, when there was one. */
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "CerastreamConnectionError";
+        this.cause = cause;
+    }
+}
+/** Thrown when a request exceeds the configured per-request timeout. */
+export class CerastreamTimeoutError extends Error {
+    constructor(method, timeoutMs) {
+        super(`request \`${method}\` timed out after ${timeoutMs}ms`);
+        this.name = "CerastreamTimeoutError";
+    }
+}
+// ---- Tier 1: synchronous RPC errors (error response) ----
+// Stable string `error.data.code` namespaced cerastream.<domain>.<reason>.
+export const rpcErrorCodeSchema = z.enum([
+    "cerastream.protocol.unsupported_version",
+    "cerastream.params.invalid",
+    "cerastream.state.not_streaming",
+    "cerastream.state.already_streaming",
+    "cerastream.device.not_found",
+    "cerastream.bitrate.out_of_range",
+    "cerastream.preview.unsupported_tier",
+    "cerastream.internal",
+]);
+/**
+ * Numeric JSON-RPC `error.code` for each Tier 1 string code (schema.md Error
+ * codes table). `-32000…-32099` is the JSON-RPC application range; `-32602` /
+ * `-32603` are the reserved invalid-params / internal-error codes.
+ */
+export const RPC_ERROR_NUMERIC = {
+    "cerastream.protocol.unsupported_version": -32000,
+    "cerastream.params.invalid": -32602,
+    "cerastream.state.not_streaming": -32001,
+    "cerastream.state.already_streaming": -32002,
+    "cerastream.device.not_found": -32003,
+    "cerastream.bitrate.out_of_range": -32004,
+    "cerastream.preview.unsupported_tier": -32005,
+    "cerastream.internal": -32603,
+};
+// ---- Tier 2: asynchronous runtime error-event codes ----
+// Maps 1:1 onto CeraUI's PROCESS_ERROR_CODES (the TRANSITIONAL stderr table) so
+// Task 32 is a table swap, not a rewrite (ADR-0002 Error-Code Namespace).
+export const processErrorCodeSchema = z.enum([
+    "srtla_initial_connect_failed",
+    "srtla_no_connections",
+    "capture_audio_error",
+    "capture_video_error",
+    "pipeline_stall",
+    "srt_connect_failed",
+    "srt_connection_lost",
+]);
+/** Origin of a Tier 2 runtime error (the notification channel CeraUI routes on). */
+export const processErrorSourceSchema = z.enum(["srtla", "engine"]);

package/dist/events.d.ts

@@ -0,0 +1,334 @@
+import { z } from "zod";
+export declare const statusEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"status">;
+    seq: z.ZodNumber;
+    state: z.ZodEnum<{
+        idle: "idle";
+        starting: "starting";
+        streaming: "streaming";
+        stopping: "stopping";
+    }>;
+    streaming: z.ZodBoolean;
+    active_input: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type StatusEvent = z.infer<typeof statusEventSchema>;
+export declare const switchEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"switch">;
+    seq: z.ZodNumber;
+    active_input: z.ZodString;
+    mode: z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SwitchEvent = z.infer<typeof switchEventSchema>;
+export declare const deviceEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"device">;
+    seq: z.ZodNumber;
+    change: z.ZodEnum<{
+        added: "added";
+        removed: "removed";
+    }>;
+    device: z.ZodObject<{
+        input_id: z.ZodString;
+        device_path: z.ZodString;
+        display_name: z.ZodString;
+        media_class: z.ZodEnum<{
+            video: "video";
+            audio: "audio";
+        }>;
+        caps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            framerate: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DeviceEvent = z.infer<typeof deviceEventSchema>;
+export declare const bitrateEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bitrate">;
+    seq: z.ZodNumber;
+    current_bitrate: z.ZodNumber;
+    max_bitrate: z.ZodNumber;
+}, z.core.$strip>;
+export type BitrateEvent = z.infer<typeof bitrateEventSchema>;
+export declare const srtStatsEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"srt-stats">;
+    seq: z.ZodNumber;
+    rtt_ms: z.ZodNumber;
+    send_buffer: z.ZodNumber;
+    pkt_loss: z.ZodNumber;
+}, z.core.$strip>;
+export type SrtStatsEvent = z.infer<typeof srtStatsEventSchema>;
+export declare const runtimeErrorEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    seq: z.ZodNumber;
+    code: z.ZodEnum<{
+        srtla_initial_connect_failed: "srtla_initial_connect_failed";
+        srtla_no_connections: "srtla_no_connections";
+        capture_audio_error: "capture_audio_error";
+        capture_video_error: "capture_video_error";
+        pipeline_stall: "pipeline_stall";
+        srt_connect_failed: "srt_connect_failed";
+        srt_connection_lost: "srt_connection_lost";
+    }>;
+    source: z.ZodEnum<{
+        srtla: "srtla";
+        engine: "engine";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeErrorEvent = z.infer<typeof runtimeErrorEventSchema>;
+export declare const previewEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"preview">;
+    seq: z.ZodNumber;
+    session_id: z.ZodString;
+    phase: z.ZodString;
+}, z.core.$strip>;
+export type PreviewEvent = z.infer<typeof previewEventSchema>;
+/** Discriminated union of every v1 event payload (the inner `params`). */
+export declare const eventParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"status">;
+    seq: z.ZodNumber;
+    state: z.ZodEnum<{
+        idle: "idle";
+        starting: "starting";
+        streaming: "streaming";
+        stopping: "stopping";
+    }>;
+    streaming: z.ZodBoolean;
+    active_input: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"switch">;
+    seq: z.ZodNumber;
+    active_input: z.ZodString;
+    mode: z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"device">;
+    seq: z.ZodNumber;
+    change: z.ZodEnum<{
+        added: "added";
+        removed: "removed";
+    }>;
+    device: z.ZodObject<{
+        input_id: z.ZodString;
+        device_path: z.ZodString;
+        display_name: z.ZodString;
+        media_class: z.ZodEnum<{
+            video: "video";
+            audio: "audio";
+        }>;
+        caps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            framerate: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"bitrate">;
+    seq: z.ZodNumber;
+    current_bitrate: z.ZodNumber;
+    max_bitrate: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"srt-stats">;
+    seq: z.ZodNumber;
+    rtt_ms: z.ZodNumber;
+    send_buffer: z.ZodNumber;
+    pkt_loss: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    seq: z.ZodNumber;
+    code: z.ZodEnum<{
+        srtla_initial_connect_failed: "srtla_initial_connect_failed";
+        srtla_no_connections: "srtla_no_connections";
+        capture_audio_error: "capture_audio_error";
+        capture_video_error: "capture_video_error";
+        pipeline_stall: "pipeline_stall";
+        srt_connect_failed: "srt_connect_failed";
+        srt_connection_lost: "srt_connection_lost";
+    }>;
+    source: z.ZodEnum<{
+        srtla: "srtla";
+        engine: "engine";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"preview">;
+    seq: z.ZodNumber;
+    session_id: z.ZodString;
+    phase: z.ZodString;
+}, z.core.$strip>], "type">;
+export type EventParams = z.infer<typeof eventParamsSchema>;
+/** Full event envelope: { jsonrpc, method:"event", params } with typed params. */
+export declare const cerastreamEventSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<"event">;
+    params: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"status">;
+        seq: z.ZodNumber;
+        state: z.ZodEnum<{
+            idle: "idle";
+            starting: "starting";
+            streaming: "streaming";
+            stopping: "stopping";
+        }>;
+        streaming: z.ZodBoolean;
+        active_input: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"switch">;
+        seq: z.ZodNumber;
+        active_input: z.ZodString;
+        mode: z.ZodEnum<{
+            manual: "manual";
+            auto: "auto";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"device">;
+        seq: z.ZodNumber;
+        change: z.ZodEnum<{
+            added: "added";
+            removed: "removed";
+        }>;
+        device: z.ZodObject<{
+            input_id: z.ZodString;
+            device_path: z.ZodString;
+            display_name: z.ZodString;
+            media_class: z.ZodEnum<{
+                video: "video";
+                audio: "audio";
+            }>;
+            caps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                framerate: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"bitrate">;
+        seq: z.ZodNumber;
+        current_bitrate: z.ZodNumber;
+        max_bitrate: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"srt-stats">;
+        seq: z.ZodNumber;
+        rtt_ms: z.ZodNumber;
+        send_buffer: z.ZodNumber;
+        pkt_loss: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        seq: z.ZodNumber;
+        code: z.ZodEnum<{
+            srtla_initial_connect_failed: "srtla_initial_connect_failed";
+            srtla_no_connections: "srtla_no_connections";
+            capture_audio_error: "capture_audio_error";
+            capture_video_error: "capture_video_error";
+            pipeline_stall: "pipeline_stall";
+            srt_connect_failed: "srt_connect_failed";
+            srt_connection_lost: "srt_connection_lost";
+        }>;
+        source: z.ZodEnum<{
+            srtla: "srtla";
+            engine: "engine";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"preview">;
+        seq: z.ZodNumber;
+        session_id: z.ZodString;
+        phase: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export type CerastreamEvent = z.infer<typeof cerastreamEventSchema>;
+/** The seven event topics (schema.md "Events" table) — count-assertion source. */
+export declare const EVENT_TOPICS: readonly ["status", "switch", "device", "bitrate", "srt-stats", "error", "preview"];
+export type EventTopicName = (typeof EVENT_TOPICS)[number];
+/** topic → payload Zod schema. Tests assert every topic is represented here. */
+export declare const eventSchemas: {
+    readonly status: z.ZodObject<{
+        type: z.ZodLiteral<"status">;
+        seq: z.ZodNumber;
+        state: z.ZodEnum<{
+            idle: "idle";
+            starting: "starting";
+            streaming: "streaming";
+            stopping: "stopping";
+        }>;
+        streaming: z.ZodBoolean;
+        active_input: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly switch: z.ZodObject<{
+        type: z.ZodLiteral<"switch">;
+        seq: z.ZodNumber;
+        active_input: z.ZodString;
+        mode: z.ZodEnum<{
+            manual: "manual";
+            auto: "auto";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly device: z.ZodObject<{
+        type: z.ZodLiteral<"device">;
+        seq: z.ZodNumber;
+        change: z.ZodEnum<{
+            added: "added";
+            removed: "removed";
+        }>;
+        device: z.ZodObject<{
+            input_id: z.ZodString;
+            device_path: z.ZodString;
+            display_name: z.ZodString;
+            media_class: z.ZodEnum<{
+                video: "video";
+                audio: "audio";
+            }>;
+            caps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                framerate: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly bitrate: z.ZodObject<{
+        type: z.ZodLiteral<"bitrate">;
+        seq: z.ZodNumber;
+        current_bitrate: z.ZodNumber;
+        max_bitrate: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly "srt-stats": z.ZodObject<{
+        type: z.ZodLiteral<"srt-stats">;
+        seq: z.ZodNumber;
+        rtt_ms: z.ZodNumber;
+        send_buffer: z.ZodNumber;
+        pkt_loss: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly error: z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        seq: z.ZodNumber;
+        code: z.ZodEnum<{
+            srtla_initial_connect_failed: "srtla_initial_connect_failed";
+            srtla_no_connections: "srtla_no_connections";
+            capture_audio_error: "capture_audio_error";
+            capture_video_error: "capture_video_error";
+            pipeline_stall: "pipeline_stall";
+            srt_connect_failed: "srt_connect_failed";
+            srt_connection_lost: "srt_connection_lost";
+        }>;
+        source: z.ZodEnum<{
+            srtla: "srtla";
+            engine: "engine";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly preview: z.ZodObject<{
+        type: z.ZodLiteral<"preview">;
+        seq: z.ZodNumber;
+        session_id: z.ZodString;
+        phase: z.ZodString;
+    }, z.core.$strip>;
+};

package/dist/events.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { processErrorCodeSchema, processErrorSourceSchema, } from "./errors.js";
+import { captureDeviceSchema, inputModeSchema, streamStateSchema, } from "./types.js";
+// Server → client `event` notifications, delivered after `subscribe-events`
+// (schema.md "Events"). Each event is the inner `params` of an rpcEventSchema:
+// { type, seq, … }. `type` discriminates; `seq` is a per-type monotonic counter.
+const seq = z.number().int().nonnegative();
+// status — stream state change + heartbeat
+export const statusEventSchema = z.object({
+    type: z.literal("status"),
+    seq,
+    state: streamStateSchema,
+    streaming: z.boolean(),
+    active_input: z.string().optional(),
+});
+// switch — active input changed (manual or failover)
+export const switchEventSchema = z.object({
+    type: z.literal("switch"),
+    seq,
+    active_input: z.string(),
+    mode: inputModeSchema,
+    reason: z.string().optional(),
+});
+// device — GstDeviceMonitor hotplug
+export const deviceEventSchema = z.object({
+    type: z.literal("device"),
+    seq,
+    change: z.enum(["added", "removed"]),
+    device: captureDeviceSchema,
+});
+// bitrate — adaptive controller adjusted encode bitrate
+export const bitrateEventSchema = z.object({
+    type: z.literal("bitrate"),
+    seq,
+    current_bitrate: z.number().int(),
+    max_bitrate: z.number().int(),
+});
+// srt-stats — periodic transport stats
+export const srtStatsEventSchema = z.object({
+    type: z.literal("srt-stats"),
+    seq,
+    rtt_ms: z.number(),
+    send_buffer: z.number().int(),
+    pkt_loss: z.number(),
+});
+// error — runtime error (replaces stderr scraping). Tier 2 code; engine reports
+// facts, CeraUI decides what to show (suppressIfSrtlaNotified is a client policy).
+export const runtimeErrorEventSchema = z.object({
+    type: z.literal("error"),
+    seq,
+    code: processErrorCodeSchema, // Tier 2 (errors.ts)
+    source: processErrorSourceSchema,
+    reason: z.string().optional(), // structured replacement for the stderr <reason>
+});
+// preview — preview session lifecycle
+export const previewEventSchema = z.object({
+    type: z.literal("preview"),
+    seq,
+    session_id: z.string(),
+    phase: z.string(),
+});
+/** Discriminated union of every v1 event payload (the inner `params`). */
+export const eventParamsSchema = z.discriminatedUnion("type", [
+    statusEventSchema,
+    switchEventSchema,
+    deviceEventSchema,
+    bitrateEventSchema,
+    srtStatsEventSchema,
+    runtimeErrorEventSchema,
+    previewEventSchema,
+]);
+/** Full event envelope: { jsonrpc, method:"event", params } with typed params. */
+export const cerastreamEventSchema = z.object({
+    jsonrpc: z.literal("2.0"),
+    method: z.literal("event"),
+    params: eventParamsSchema,
+});
+/** The seven event topics (schema.md "Events" table) — count-assertion source. */
+export const EVENT_TOPICS = [
+    "status",
+    "switch",
+    "device",
+    "bitrate",
+    "srt-stats",
+    "error",
+    "preview",
+];
+/** topic → payload Zod schema. Tests assert every topic is represented here. */
+export const eventSchemas = {
+    status: statusEventSchema,
+    switch: switchEventSchema,
+    device: deviceEventSchema,
+    bitrate: bitrateEventSchema,
+    "srt-stats": srtStatsEventSchema,
+    error: runtimeErrorEventSchema,
+    preview: previewEventSchema,
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./envelope.js";
+export * from "./types.js";
+export * from "./messages.js";
+export * from "./events.js";
+export * from "./paths.js";
+export * from "./config.js";
+export * from "./client.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+// @ceralive/cerastream — control-IPC schema + type-safe client for the cerastream
+// Rust streaming engine. The Zod schemas + types are the frozen public contract
+// (ADR-0002 / schema.md); the client drives that contract over a Bun-native
+// NDJSON/UDS transport (Task 31).
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./envelope.js";
+export * from "./types.js";
+export * from "./messages.js";
+export * from "./events.js";
+export * from "./paths.js";
+export * from "./config.js";
+export * from "./client.js";