@ceralive/cerastream 2026.9.4 → 2026.9.6

package/README.md

@@ -9,6 +9,7 @@ engine's JSON-RPC 2.0 / NDJSON control plane over a Unix domain socket.
 - The nine server-push event payloads (discriminated union)
 - Two-tier error codes (RPC + runtime)
 - Typed capture-probe causes retained on runtime events and rejected-start exceptions
+  (including HDMI `unsupported-format`, `interlaced-unsupported`, `source-changed`)
 - Typed platform capture-converter reporting (`librga`, `v4l2-rga2`, or `none`)
 - Typed RK3588 composition config (secondary input, six PiP/PbP layouts, alpha),
   gated by the READY-trialled `composition` capability token
@@ -18,6 +19,9 @@ engine's JSON-RPC 2.0 / NDJSON control plane over a Unix domain socket.
   local preview availability
 - Per-codec encoder capability entries with format, resolution/framerate, and
   explicit 4K60 qualification-gate truth
+- Additive `client.setEdidProfile()` — switch the HDMI-RX EDID between the named
+  `full` / `robust-4k60` profiles as one transaction: written, byte-verified,
+  persisted, then the device projection re-read only after the link settles
 - Additive `client.changeConfig()` — reconfigure the live session (resolution,
   framerate, codec, pipeline, source) as one transaction with typed rollback;
   composition-only changes use live layout/alpha writes and secondary rebind
@@ -82,6 +86,15 @@ systemd-owned service — the client connects to it and never spawns it.
 
 ## Versioning
 
+Version **2026.9.6 / schema 0.18.0** adds
+`client.listSwitchTargets()` and optional `active_encode.switch_targets`.
+Targets are `{input_id, kind: "capture"|"synthetic"|"network"}`; the query returns
+`{session_id?, active_input?, switch_targets: [...]}`. They describe built live
+legs, not idle capabilities; passthrough/composition explicitly return `[]`.
+Import `SessionSwitchTarget` and `ListSwitchTargetsResult` from this package,
+never shadow the wire types. Re-query before switching and handle refusal; the
+snapshot does not reserve a leg. Release/publish must happen before consumption.
+
 Two independent version axes. The **wire-schema version** (`PROTOCOL_VERSION` +
 `SCHEMA_VERSION`) is pinned cross-language with the engine and is additive-only
 within `cerastream-ipc/1`. The **npm package version** is CalVer

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { type HelloResult } from './envelope.js';
 import { type EventParams } from './events.js';
-import { type ChangeConfigParams, type ChangeConfigResult, type GetCapabilitiesResult, type ListDevicesParams, type ListDevicesResult, type PreviewSessionParams, type PreviewSessionResult, type ReloadConfigParams, type ReloadConfigResult, type RequestKeyframeResult, type SetBitrateParams, type SetBitrateResult, type StartParams, type StartResult, type StopParams, type StopResult, type SubscribeEventsParams, type SubscribeEventsResult, type SwitchInputParams, type SwitchInputResult } from './messages.js';
+import { type ChangeConfigParams, type ChangeConfigResult, type GetCapabilitiesResult, type ListDevicesParams, type ListDevicesResult, type PreviewSessionParams, type PreviewSessionResult, type ReloadConfigParams, type ReloadConfigResult, type RequestKeyframeResult, type SetBitrateParams, type SetBitrateResult, type SetEdidProfileParams, type SetEdidProfileResult, type StartParams, type StartResult, type StopParams, type StopResult, type SubscribeEventsParams, type SubscribeEventsResult, type SwitchInputParams, type SwitchInputResult } from './messages.js';
+import { type ListSwitchTargetsResult } from './session-switch.js';
 /** Options for {@link connect}. All optional — `connect({})` is valid. */
 export interface ConnectOptions {
     /** Control socket path override. Defaults to the resolved /run/cerastream/control.sock. */
@@ -65,6 +66,16 @@ export interface CerastreamClient {
      */
     setBitrate(params: SetBitrateParams): Promise<SetBitrateResult>;
     requestKeyframe(): Promise<RequestKeyframeResult>;
+    /**
+     * Switch the HDMI-RX EDID profile transactionally: write, byte-verify,
+     * persist, then re-read the device projection once the link has settled.
+     * @param params The profile to advertise.
+     * @returns The committed profile, the one it replaced, and the post-settle devices.
+     * @throws {CerastreamRpcError} `cerastream.params.invalid` prefixed
+     * `capture-active` while any capture leg is live — including when the driver
+     * itself refuses the write — and `hdmirx-unavailable` on a board with no receiver.
+     */
+    setEdidProfile(params: SetEdidProfileParams): Promise<SetEdidProfileResult>;
     /**
      * Switch the active capture source (manual) or hand selection to failover (auto).
      * @param params The target input id and switch mode.
@@ -72,6 +83,7 @@ export interface CerastreamClient {
      * @throws {CerastreamRpcError} when the input id is unknown.
      */
     switchInput(params: SwitchInputParams): Promise<SwitchInputResult>;
+    listSwitchTargets(): Promise<ListSwitchTargetsResult>;
     /**
      * Enumerate capture devices (GstDeviceMonitor, de-duped by device path).
      * @param params Optional media-class filter.

package/dist/client.js

@@ -3,8 +3,9 @@ import { CONTROL_SOCKET_PATH, PROTOCOL_VERSION } from './constants.js';
 import { helloResultSchema, rpcErrorSchema, rpcResponseSchema, } from './envelope.js';
 import { CerastreamConnectionError, CerastreamRpcError, CerastreamTimeoutError, } from './errors.js';
 import { eventParamsSchema } from './events.js';
-import { changeConfigParamsSchema, changeConfigResultSchema, getCapabilitiesResultSchema, requestKeyframeResultSchema, requestSchemas, } from './messages.js';
+import { changeConfigParamsSchema, changeConfigResultSchema, getCapabilitiesResultSchema, requestKeyframeResultSchema, requestSchemas, setEdidProfileResultSchema, } from './messages.js';
 import { controlSocketPath } from './paths.js';
+import { listSwitchTargetsResultSchema } from './session-switch.js';
 import { LineSocket } from './transport.js';
 const DEFAULTS = {
     requestTimeoutMs: 10_000,
@@ -73,12 +74,18 @@ class ClientImpl {
     async requestKeyframe() {
         return requestKeyframeResultSchema.parse(await this.rawRequest('request-keyframe', {}));
     }
+    async setEdidProfile(params) {
+        return setEdidProfileResultSchema.parse(await this.rawRequest('hdmirx.setEdidProfile', params));
+    }
     switchInput(params) {
         return this.call('switch-input', params);
     }
     listDevices(params) {
         return this.call('list-devices', params);
     }
+    async listSwitchTargets() {
+        return listSwitchTargetsResultSchema.parse(await this.rawRequest('list-switch-targets', {}));
+    }
     async getCapabilities() {
         return getCapabilitiesResultSchema.parse(await this.rawRequest('get-capabilities', undefined));
     }

package/dist/constants.d.ts

@@ -8,7 +8,7 @@ export declare const PROTOCOL_VERSION: 'cerastream-ipc/1';
  * additive-only within protocol major `cerastream-ipc/1` (ADR-0002 §4); this value
  * only moves when the wire schema itself does, in lockstep across both languages.
  */
-export declare const SCHEMA_VERSION: '0.16.0';
+export declare const SCHEMA_VERSION: '0.18.0';
 /** Runtime dir holding both control + preview sockets. systemd `RuntimeDirectory=cerastream`. */
 export declare const DEFAULT_IPC_DIR: '/run/cerastream';
 /** Env override for the IPC dir (tests/dev). Defaults to {@link DEFAULT_IPC_DIR}. */

package/dist/constants.js

@@ -11,7 +11,7 @@ export const PROTOCOL_VERSION = 'cerastream-ipc/1';
  * additive-only within protocol major `cerastream-ipc/1` (ADR-0002 §4); this value
  * only moves when the wire schema itself does, in lockstep across both languages.
  */
-export const SCHEMA_VERSION = '0.16.0';
+export const SCHEMA_VERSION = '0.18.0';
 /** Runtime dir holding both control + preview sockets. systemd `RuntimeDirectory=cerastream`. */
 export const DEFAULT_IPC_DIR = '/run/cerastream';
 /** Env override for the IPC dir (tests/dev). Defaults to {@link DEFAULT_IPC_DIR}. */

package/dist/errors.d.ts

@@ -99,11 +99,14 @@ export declare const captureCauseSchema: z.ZodEnum<{
     "composition-unsupported": "composition-unsupported";
     "decoder-unavailable": "decoder-unavailable";
     device_busy: "device_busy";
+    "interlaced-unsupported": "interlaced-unsupported";
     negotiation_failed: "negotiation_failed";
     no_signal: "no_signal";
     no_silicon_converter: "no_silicon_converter";
     "secondary-unavailable": "secondary-unavailable";
     "software-pixel-path-rejected": "software-pixel-path-rejected";
+    "source-changed": "source-changed";
+    "unsupported-format": "unsupported-format";
 }>;
 export type CaptureCause = z.infer<typeof captureCauseSchema>;
 export declare const captureCauseEntrySchema: z.ZodObject<{
@@ -112,11 +115,14 @@ export declare const captureCauseEntrySchema: z.ZodObject<{
         "composition-unsupported": "composition-unsupported";
         "decoder-unavailable": "decoder-unavailable";
         device_busy: "device_busy";
+        "interlaced-unsupported": "interlaced-unsupported";
         negotiation_failed: "negotiation_failed";
         no_signal: "no_signal";
         no_silicon_converter: "no_silicon_converter";
         "secondary-unavailable": "secondary-unavailable";
         "software-pixel-path-rejected": "software-pixel-path-rejected";
+        "source-changed": "source-changed";
+        "unsupported-format": "unsupported-format";
     }>;
 }, z.core.$strip>;
 export type CaptureCauseEntry = z.infer<typeof captureCauseEntrySchema>;

package/dist/errors.js

@@ -147,6 +147,9 @@ export const captureCauseSchema = z.enum([
     'software-pixel-path-rejected',
     'composition-unsupported',
     'secondary-unavailable',
+    'unsupported-format',
+    'interlaced-unsupported',
+    'source-changed',
 ]);
 export const captureCauseEntrySchema = z.object({
     device: z.string(),

package/dist/events.d.ts

@@ -11,6 +11,14 @@ export declare const activeEncodeSchema: z.ZodObject<{
     resolution: z.ZodString;
     framerate: z.ZodNumber;
     active_input: z.ZodOptional<z.ZodString>;
+    switch_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        input_id: z.ZodString;
+        kind: z.ZodEnum<{
+            capture: "capture";
+            network: "network";
+            synthetic: "synthetic";
+        }>;
+    }, z.core.$strip>>>;
     decoder: z.ZodOptional<z.ZodString>;
     input_codec: z.ZodOptional<z.ZodString>;
     passthrough: z.ZodOptional<z.ZodBoolean>;
@@ -84,6 +92,14 @@ export declare const statusEventSchema: z.ZodObject<{
         resolution: z.ZodString;
         framerate: z.ZodNumber;
         active_input: z.ZodOptional<z.ZodString>;
+        switch_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input_id: z.ZodString;
+            kind: z.ZodEnum<{
+                capture: "capture";
+                network: "network";
+                synthetic: "synthetic";
+            }>;
+        }, z.core.$strip>>>;
         decoder: z.ZodOptional<z.ZodString>;
         input_codec: z.ZodOptional<z.ZodString>;
         passthrough: z.ZodOptional<z.ZodBoolean>;
@@ -243,11 +259,14 @@ export declare const runtimeErrorEventSchema: z.ZodObject<{
         "composition-unsupported": "composition-unsupported";
         "decoder-unavailable": "decoder-unavailable";
         device_busy: "device_busy";
+        "interlaced-unsupported": "interlaced-unsupported";
         negotiation_failed: "negotiation_failed";
         no_signal: "no_signal";
         no_silicon_converter: "no_silicon_converter";
         "secondary-unavailable": "secondary-unavailable";
         "software-pixel-path-rejected": "software-pixel-path-rejected";
+        "source-changed": "source-changed";
+        "unsupported-format": "unsupported-format";
     }>>;
 }, z.core.$strip>;
 /** Payload of a {@link runtimeErrorEventSchema} event. */
@@ -339,6 +358,14 @@ export declare const eventParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         resolution: z.ZodString;
         framerate: z.ZodNumber;
         active_input: z.ZodOptional<z.ZodString>;
+        switch_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input_id: z.ZodString;
+            kind: z.ZodEnum<{
+                capture: "capture";
+                network: "network";
+                synthetic: "synthetic";
+            }>;
+        }, z.core.$strip>>>;
         decoder: z.ZodOptional<z.ZodString>;
         input_codec: z.ZodOptional<z.ZodString>;
         passthrough: z.ZodOptional<z.ZodBoolean>;
@@ -471,11 +498,14 @@ export declare const eventParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         "composition-unsupported": "composition-unsupported";
         "decoder-unavailable": "decoder-unavailable";
         device_busy: "device_busy";
+        "interlaced-unsupported": "interlaced-unsupported";
         negotiation_failed: "negotiation_failed";
         no_signal: "no_signal";
         no_silicon_converter: "no_silicon_converter";
         "secondary-unavailable": "secondary-unavailable";
         "software-pixel-path-rejected": "software-pixel-path-rejected";
+        "source-changed": "source-changed";
+        "unsupported-format": "unsupported-format";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"preview">;
@@ -541,6 +571,14 @@ export declare const cerastreamEventSchema: z.ZodObject<{
             resolution: z.ZodString;
             framerate: z.ZodNumber;
             active_input: z.ZodOptional<z.ZodString>;
+            switch_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                input_id: z.ZodString;
+                kind: z.ZodEnum<{
+                    capture: "capture";
+                    network: "network";
+                    synthetic: "synthetic";
+                }>;
+            }, z.core.$strip>>>;
             decoder: z.ZodOptional<z.ZodString>;
             input_codec: z.ZodOptional<z.ZodString>;
             passthrough: z.ZodOptional<z.ZodBoolean>;
@@ -673,11 +711,14 @@ export declare const cerastreamEventSchema: z.ZodObject<{
             "composition-unsupported": "composition-unsupported";
             "decoder-unavailable": "decoder-unavailable";
             device_busy: "device_busy";
+            "interlaced-unsupported": "interlaced-unsupported";
             negotiation_failed: "negotiation_failed";
             no_signal: "no_signal";
             no_silicon_converter: "no_silicon_converter";
             "secondary-unavailable": "secondary-unavailable";
             "software-pixel-path-rejected": "software-pixel-path-rejected";
+            "source-changed": "source-changed";
+            "unsupported-format": "unsupported-format";
         }>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"preview">;
@@ -747,6 +788,14 @@ export declare const eventSchemas: {
             resolution: z.ZodString;
             framerate: z.ZodNumber;
             active_input: z.ZodOptional<z.ZodString>;
+            switch_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                input_id: z.ZodString;
+                kind: z.ZodEnum<{
+                    capture: "capture";
+                    network: "network";
+                    synthetic: "synthetic";
+                }>;
+            }, z.core.$strip>>>;
             decoder: z.ZodOptional<z.ZodString>;
             input_codec: z.ZodOptional<z.ZodString>;
             passthrough: z.ZodOptional<z.ZodBoolean>;
@@ -884,11 +933,14 @@ export declare const eventSchemas: {
             "composition-unsupported": "composition-unsupported";
             "decoder-unavailable": "decoder-unavailable";
             device_busy: "device_busy";
+            "interlaced-unsupported": "interlaced-unsupported";
             negotiation_failed: "negotiation_failed";
             no_signal: "no_signal";
             no_silicon_converter: "no_silicon_converter";
             "secondary-unavailable": "secondary-unavailable";
             "software-pixel-path-rejected": "software-pixel-path-rejected";
+            "source-changed": "source-changed";
+            "unsupported-format": "unsupported-format";
         }>>;
     }, z.core.$strip>;
     readonly preview: z.ZodObject<{

package/dist/events.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { captureCauseSchema, processErrorCodeSchema, processErrorSourceSchema } from './errors.js';
+import { sessionSwitchTargetSchema } from './session-switch.js';
 import { captureDeviceSchema, configChangePhaseSchema, inputModeSchema, mediaClassSchema, previewEncodeFallbackSchema, previewEncodeModeSchema, streamStateSchema, } from './types.js';
 // Server → client `event` notifications, delivered after `subscribe-events`
 // (schema.md "Events"). Each event is the inner `params` of an rpcEventSchema:
@@ -17,6 +18,7 @@ export const activeEncodeSchema = z.object({
     resolution: z.string(), // "WxH" pixels in effect, e.g. "1920x1080"
     framerate: z.number(), // fps in effect, e.g. 29.97
     active_input: z.string().optional(), // active input id feeding the encode
+    switch_targets: z.array(sessionSwitchTargetSchema).optional(),
     decoder: z.string().optional(), // runtime-selected decode element when transcoding
     input_codec: z.string().optional(), // incoming pre-decode codec token: "h264"/"h265"/"mjpeg"
     passthrough: z.boolean().optional(), // 0.5.0: true when a same-codec passthrough graph is live (no decode/re-encode)

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export * from './errors.js';
 export * from './events.js';
 export * from './messages.js';
 export * from './paths.js';
+export * from './session-switch.js';
 export * from './types.js';

package/dist/index.js

@@ -10,4 +10,5 @@ export * from './errors.js';
 export * from './events.js';
 export * from './messages.js';
 export * from './paths.js';
+export * from './session-switch.js';
 export * from './types.js';

package/dist/messages.d.ts

@@ -179,6 +179,97 @@ export declare const requestKeyframeResultSchema: z.ZodObject<{
     applied: z.ZodLiteral<true>;
 }, z.core.$strip>;
 export type RequestKeyframeResult = z.infer<typeof requestKeyframeResultSchema>;
+export declare const edidProfileSchema: z.ZodEnum<{
+    full: "full";
+    "robust-4k60": "robust-4k60";
+}>;
+export type EdidProfile = z.infer<typeof edidProfileSchema>;
+export declare const setEdidProfileParamsSchema: z.ZodObject<{
+    profile: z.ZodEnum<{
+        full: "full";
+        "robust-4k60": "robust-4k60";
+    }>;
+}, z.core.$strip>;
+export type SetEdidProfileParams = z.infer<typeof setEdidProfileParamsSchema>;
+export declare const edidSettleOutcomeSchema: z.ZodEnum<{
+    "no-signal": "no-signal";
+    relocked: "relocked";
+    unknown: "unknown";
+}>;
+export type EdidSettleOutcome = z.infer<typeof edidSettleOutcomeSchema>;
+export declare const setEdidProfileResultSchema: z.ZodObject<{
+    profile: z.ZodEnum<{
+        full: "full";
+        "robust-4k60": "robust-4k60";
+    }>;
+    previous: z.ZodEnum<{
+        full: "full";
+        "robust-4k60": "robust-4k60";
+    }>;
+    applied: z.ZodLiteral<true>;
+    settle: z.ZodEnum<{
+        "no-signal": "no-signal";
+        relocked: "relocked";
+        unknown: "unknown";
+    }>;
+    devices: z.ZodArray<z.ZodObject<{
+        input_id: z.ZodString;
+        device_path: z.ZodString;
+        display_name: z.ZodString;
+        media_class: z.ZodEnum<{
+            audio: "audio";
+            video: "video";
+        }>;
+        caps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            framerate: z.ZodOptional<z.ZodString>;
+            media_type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            audio: "audio";
+            camlink: "camlink";
+            hdmi: "hdmi";
+            mjpeg: "mjpeg";
+            network: "network";
+            test: "test";
+            uvc_h264: "uvc_h264";
+            uvc_h265: "uvc_h265";
+        }>>;
+        modes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            media_type: z.ZodString;
+            pipeline_kind: z.ZodEnum<{
+                audio: "audio";
+                camlink: "camlink";
+                hdmi: "hdmi";
+                mjpeg: "mjpeg";
+                network: "network";
+                test: "test";
+                uvc_h264: "uvc_h264";
+                uvc_h265: "uvc_h265";
+            }>;
+            caps: z.ZodArray<z.ZodObject<{
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                framerate: z.ZodOptional<z.ZodString>;
+                media_type: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        alsa_card_id: z.ZodOptional<z.ZodString>;
+        product_name: z.ZodOptional<z.ZodString>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            bluetooth: "bluetooth";
+            hdmi: "hdmi";
+            onboard: "onboard";
+            usb: "usb";
+        }>>;
+        stable_id: z.ZodOptional<z.ZodString>;
+        physical_group_id: z.ZodOptional<z.ZodString>;
+        hardware_serial: z.ZodOptional<z.ZodString>;
+        device_address: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SetEdidProfileResult = z.infer<typeof setEdidProfileResultSchema>;
 export declare const switchInputParamsSchema: z.ZodObject<{
     input_id: z.ZodString;
     mode: z.ZodDefault<z.ZodEnum<{

package/dist/messages.js

@@ -74,6 +74,23 @@ export const setBitrateResultSchema = z.object({
 });
 export const requestKeyframeParamsSchema = z.object({});
 export const requestKeyframeResultSchema = z.object({ applied: z.literal(true) });
+// ---- 4b. hdmirx.setEdidProfile (additive, 0.17.0; not in V1_METHODS) ----
+// The operator picks a named POLICY, never a blob: an EDID is a checksummed
+// 256-byte structure whose contents the device owns.
+export const edidProfileSchema = z.enum(['full', 'robust-4k60']);
+export const setEdidProfileParamsSchema = z.object({ profile: edidProfileSchema });
+// How the receiver settled before `devices` below was re-read, so a consumer can
+// tell "relocked and here are its real modes" from "the link is dark".
+export const edidSettleOutcomeSchema = z.enum(['relocked', 'no-signal', 'unknown']);
+export const setEdidProfileResultSchema = z.object({
+    profile: edidProfileSchema,
+    previous: edidProfileSchema,
+    // Always true: a non-applied attempt is an RPC error, never this result.
+    applied: z.literal(true),
+    settle: edidSettleOutcomeSchema,
+    // The POST-SETTLE list-devices projection — never the pre-switch mode list.
+    devices: z.array(captureDeviceSchema),
+});
 // ---- 5. switch-input ----
 export const switchInputParamsSchema = z.object({
     input_id: z.string(), // device/input identifier from list-devices

package/dist/session-switch.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+/** Already-built program-switch legs, not the idle source catalog. */
+export declare const sessionSwitchTargetKindSchema: z.ZodEnum<{
+    capture: "capture";
+    network: "network";
+    synthetic: "synthetic";
+}>;
+export type SessionSwitchTargetKind = z.infer<typeof sessionSwitchTargetKindSchema>;
+export declare const sessionSwitchTargetSchema: z.ZodObject<{
+    input_id: z.ZodString;
+    kind: z.ZodEnum<{
+        capture: "capture";
+        network: "network";
+        synthetic: "synthetic";
+    }>;
+}, z.core.$strip>;
+export type SessionSwitchTarget = z.infer<typeof sessionSwitchTargetSchema>;
+export declare const listSwitchTargetsParamsSchema: z.ZodObject<{}, z.core.$strip>;
+export type ListSwitchTargetsParams = z.infer<typeof listSwitchTargetsParamsSchema>;
+/** A snapshot, not a reservation; re-query before dispatch and handle switch refusal. */
+export declare const listSwitchTargetsResultSchema: z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    active_input: z.ZodOptional<z.ZodString>;
+    switch_targets: z.ZodArray<z.ZodObject<{
+        input_id: z.ZodString;
+        kind: z.ZodEnum<{
+            capture: "capture";
+            network: "network";
+            synthetic: "synthetic";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListSwitchTargetsResult = z.infer<typeof listSwitchTargetsResultSchema>;

package/dist/session-switch.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/** Already-built program-switch legs, not the idle source catalog. */
+export const sessionSwitchTargetKindSchema = z.enum(['capture', 'synthetic', 'network']);
+export const sessionSwitchTargetSchema = z.object({
+    input_id: z.string(),
+    kind: sessionSwitchTargetKindSchema,
+});
+export const listSwitchTargetsParamsSchema = z.object({});
+/** A snapshot, not a reservation; re-query before dispatch and handle switch refusal. */
+export const listSwitchTargetsResultSchema = z.object({
+    session_id: z.string().optional(),
+    active_input: z.string().optional(),
+    switch_targets: z.array(sessionSwitchTargetSchema),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ceralive/cerastream",
-	"version": "2026.9.4",
+	"version": "2026.9.6",
 	"description": "Type-safe TypeScript schema + IPC client for the cerastream streaming engine (JSON-RPC 2.0 / NDJSON over a Unix domain socket).",
 	"type": "module",
 	"main": "dist/index.js",