tirtc-devtools-cli 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-devtools-cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "private": false,
   "main": "dist/index.js",
   "bin": {

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/trp.h

@@ -154,6 +154,20 @@ typedef struct TirtcConnConnectOptions {
   const char* token;
 } TirtcConnConnectOptions;
 
+/**
+ * @brief Optional observer bound when a connection object is created.
+ *
+ * The implementation copies the observer structure and stores the supplied
+ * user_data pointer with the created connection handle.
+ */
+typedef struct TirtcConnCreateOptions {
+  /** @brief Optional observer copied into the new connection object. */
+  const struct TirtcConnObserver* observer;
+
+  /** @brief Opaque pointer returned to observer callbacks. */
+  void* user_data;
+} TirtcConnCreateOptions;
+
 /** @brief Opaque handle returned by ::tirtc_conn_service_start. */
 typedef struct TirtcConnService TirtcConnService;
 
@@ -376,17 +390,12 @@ typedef struct TirtcConnServiceObserver {
 /**
  * @brief Optional observer for connection lifecycle and control-plane events.
  *
- * The implementation stores a copy of this structure. Passing NULL to
- * ::tirtc_conn_set_observer clears the current observer.
- *
- * Replay contract:
- * - Installing or replacing an observer immediately replays the current state.
- * - If the connection has already disconnected, the terminal disconnected
- *   callback is replayed as part of observer installation.
+ * The implementation stores a copy of this structure inside the owning
+ * connection object.
  *
  * Callback threading is not restricted to a single caller thread. Some
- * callbacks may be replayed synchronously by API calls such as
- * ::tirtc_conn_set_observer, while others may arrive asynchronously from the
+ * callbacks may be replayed synchronously when a connection object becomes
+ * visible to the caller, while others may arrive asynchronously from the
  * internal transport layer.
  */
 typedef struct TirtcConnObserver {
@@ -475,25 +484,29 @@ TirtcError tirtc_conn_service_stop(TirtcConnService* service);
  * The runtime must already be initialized. The returned handle starts in
  * ::TIRTC_CONN_STATE_IDLE and must be released with ::tirtc_conn_destroy.
  *
+ * The observer, when provided, becomes part of the connection object's stable
+ * lifecycle contract. After creation succeeds, reconnects on the same handle
+ * keep using that observer.
+ *
+ * @param options Optional creation options. Pass NULL to create a connection
+ * without an observer.
  * @param out_connection Receives the created connection handle on success.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_conn_create(TirtcConn** out_connection);
+TirtcError tirtc_conn_create(const TirtcConnCreateOptions* options, TirtcConn** out_connection);
 
 /**
  * @brief Install, replace, or clear the connection observer.
  *
+ * This legacy API remains available for accepted service connections and
+ * existing consumers that still bind observers after handle creation.
+ * New standalone-connection callers should prefer binding the observer through
+ * ::TirtcConnCreateOptions.
+ *
  * Passing NULL for ::observer clears the current observer and its user data.
- * The implementation stores a copy of the observer structure and does not
- * require it to outlive this call.
  * After a non-NULL observer is installed, the implementation immediately
  * replays the current state and, when applicable, the terminal disconnected
  * callback.
- *
- * @param connection Target connection.
- * @param observer Observer to install, or NULL to clear.
- * @param user_data Opaque pointer returned to observer callbacks.
- * @return ::TIRTC_ERROR_OK on success.
  */
 TirtcError tirtc_conn_set_observer(TirtcConn* connection, const TirtcConnObserver* observer,
                                    void* user_data);

package/vendor/app-server/bin/runtime/macos-arm64/manifest.txt

@@ -1,5 +1,5 @@
 platform=macos-arm64
-staged_at_utc=2026-04-09T05:56:18Z
+staged_at_utc=2026-04-09T14:57:31Z
 source_sdk=/Users/allenfeng/Development/Repositories/tirtc-nexus/tirtc-matrix/.build/sdk/macos-arm64
 
 dcca0b7ab8055d84e5bcfab7f1dde56df9037c40ddb99e9ca924ef2e867d8309  include/tirtc/audio.h
@@ -25,7 +25,7 @@ ae805545a9515edc9b94262e72ad2c7b7d649288166f4daeb450d8a55e82ae0b  include/tirtc/
 a4f8ab44c1a20ad37f250363a403a9d4d007e61ddb2426c7966dbc05f6a04b4f  include/tirtc/media_live_source.h
 1b3be6954e547f91a047866438bff1820c8406afaf91cef68ddee29a6ac70234  include/tirtc/media_uplink.h
 1e12daf9c5fc2e2f848444688081c9be0cb738245f0155327e8003b49308058f  include/tirtc/transport.h
-99b4b31b8359009ee74f0f2a52be6473d9c6c37b184e53eeb554d4bf61f6ee33  include/tirtc/trp.h
+137729c534213cb161c0853a8d4d38fcdc397c41a7fd8c813fbe0e80083ec931  include/tirtc/trp.h
 dff5b0a0ac4a40ad17c93e1e56b3c416371c81ab365e287ea8cd6ce37ccbed3b  include/tirtc/video_codec.h
 e51379666c199588cc33279ccf52248035d1cae3d1d468b1615ebf29f0b39c9c  include/tirtc/video_frame.h
 d920afad955b9f206b02b19ca152315190fa84ab6f24e895a5b24c3ab9ffd701  include/tirtc/video_io.h
@@ -36,14 +36,14 @@ cae0bbeb884e5466a56da15182c78cc22baab6c743f349a58d3595f623333585  include/tirtc/
 8cd6b66bea14890a665cc317f8572429b2c3e4463773f8b77c1e4dc30a4a8747  include/tirtc/video_processing.h
 b39daee6a3d39bf0ca20c45084601133c4198de8dca848dcff6dd9c70ae99016  lib/libcrypto.a
 c052857ef315e3d61db9c862cad10709a3a6b2487dc41799cbe4d74a805de875  lib/libcrypto.dylib
-6ad596f3ad055be11f121f418aeff4e02c650f3cec6b37c471ed54e9498a1268  lib/libmatrix_runtime_audio.a
-42d1a2e4aa59d53c0c35ad204a365b7d7d83698c21857f5ffe7421da240da3e1  lib/libmatrix_runtime_credential.a
-2153ac1352ebb401f7920e8358c4988f9bd7f5275009ab94f6c4b7d7eb2a71c3  lib/libmatrix_runtime_facade.a
-25d70d18d4b69e0f28514035811a4ae8e18a1dcbcdd88d6a68e3d7609e2537bb  lib/libmatrix_runtime_foundation_http.a
-78b82c288d2e58f1219d5f56772a1dc8683e8da5f2f4724c160e6bf97f9ddadc  lib/libmatrix_runtime_foundation_logging.a
-548230c283e262838d2492ae28817870cd191eb3b9cb3e943446645562a2e20f  lib/libmatrix_runtime_media.a
-e5afb3d24fd62ad5f4fd68ea7ba65957e79bf27d5669a8d6bceb44aa9f297c16  lib/libmatrix_runtime_transport.a
-e0a087c9d0b0c929a20677db1aa8e053813baa3682458f407f04dc751d0d225a  lib/libmatrix_runtime_video.a
+240fb613f79b39ce4ed74ebd2e56c714141a0ef858f106e1121c7d540cea7e64  lib/libmatrix_runtime_audio.a
+e1070b1e7b262ad8a8e1dbec1ac9d524fbf4a7fdcc855bb84f69bdd13f31ae9d  lib/libmatrix_runtime_credential.a
+7081b1021d32939a1cbf399bbfa2b4f72a74e7eb48f111f34c80450f8d8a4bfe  lib/libmatrix_runtime_facade.a
+d268be4f9309c1af33f7734a692e0bf89402c96a6fe689f6d7df691d5563b391  lib/libmatrix_runtime_foundation_http.a
+d7c51d52995b0c1be194fafb3d922b98f8c87eccbfb3a240bad1d4b7b27de1b2  lib/libmatrix_runtime_foundation_logging.a
+37332652b4cb75f1d6a0a3a7209013d05ec55874b5103b89fd37ecd3b4601702  lib/libmatrix_runtime_media.a
+e0ed1c103c4e2392c423aacdbf314bf13848281318c6f57496136756664c4275  lib/libmatrix_runtime_transport.a
+f00064a09bc2c03963518e05c659becc0a24e2ec6b696ce13ca03fa1ec576f22  lib/libmatrix_runtime_video.a
 c11c65d373a127028350c41fa58cd2d1223f2b5d70a84e13b115d90daaba25ca  lib/libssl.a
 ef1c1104bbdd2528ed7b958fb7252bd6249875f92300b0c9577d6c4bd6c0d88a  lib/libssl.dylib
 dc3e0e6ded26e90fd59c166933a5289d57f4cf25fbe6246b6b83c86fe898e63d  lib/libwebrtc_apm.a

package/vendor/app-server/dist/host/HostProtocol.d.ts

@@ -1,4 +1,4 @@
-import { StreamRequestPolicyMode, StreamSource } from './HostState';
+import { StreamSource } from './HostState';
 export type JsonRpcId = string | number;
 export type JsonRpcRequest = {
     id?: JsonRpcId;
@@ -22,6 +22,7 @@ export type ServiceStartParams = {
     serviceEntry?: string;
     license: string;
     timeoutMs: number;
+    bootstrapSendStreams?: StreamSendStartParams[];
 };
 export type ConnectionAutoTokenConfig = {
     openapiEntry?: string;
@@ -47,6 +48,10 @@ export type StreamSendStartParams = {
 export type StreamStopParams = {
     streamId: number;
 };
+export type StreamMessageSendParams = {
+    streamId: number;
+    payload: string;
+};
 export type StreamReceiveStartParams = {
     streamId: number;
     media: 'audio' | 'video';
@@ -78,9 +83,6 @@ export type EventsSubscribeParams = {
 export type ArtifactExportParams = {
     outputPath: string;
 };
-export type StreamRequestPolicySetParams = {
-    mode: StreamRequestPolicyMode;
-};
 export type DebugTokenQrcodeParams = {
     payload: string;
     outputStem?: string;
@@ -96,12 +98,12 @@ export declare function parseServiceStartParams(params: Record<string, unknown>)
 export declare function parseConnectionConnectParams(params: Record<string, unknown>): ConnectionConnectParams;
 export declare function parseStreamSendStartParams(params: Record<string, unknown>): StreamSendStartParams;
 export declare function parseStreamStopParams(params: Record<string, unknown>): StreamStopParams;
+export declare function parseStreamMessageSendParams(params: Record<string, unknown>): StreamMessageSendParams;
 export declare function parseStreamReceiveStartParams(params: Record<string, unknown>): StreamReceiveStartParams;
 export declare function parseOutputAttachParams(params: Record<string, unknown>): OutputAttachParams;
 export declare function parseOutputDetachParams(params: Record<string, unknown>): OutputDetachParams;
 export declare function parseCommandSendParams(params: Record<string, unknown>): CommandSendParams;
 export declare function parseEventsSubscribeParams(params: Record<string, unknown>): EventsSubscribeParams;
 export declare function parseArtifactExportParams(params: Record<string, unknown>): ArtifactExportParams;
-export declare function parseStreamRequestPolicySetParams(params: Record<string, unknown>): StreamRequestPolicySetParams;
 export declare function parseDebugTokenQrcodeParams(params: Record<string, unknown>): DebugTokenQrcodeParams;
 export declare function normalizeError(error: unknown): HostProtocolError;

package/vendor/app-server/dist/host/HostProtocol.js

@@ -7,13 +7,13 @@ exports.parseServiceStartParams = parseServiceStartParams;
 exports.parseConnectionConnectParams = parseConnectionConnectParams;
 exports.parseStreamSendStartParams = parseStreamSendStartParams;
 exports.parseStreamStopParams = parseStreamStopParams;
+exports.parseStreamMessageSendParams = parseStreamMessageSendParams;
 exports.parseStreamReceiveStartParams = parseStreamReceiveStartParams;
 exports.parseOutputAttachParams = parseOutputAttachParams;
 exports.parseOutputDetachParams = parseOutputDetachParams;
 exports.parseCommandSendParams = parseCommandSendParams;
 exports.parseEventsSubscribeParams = parseEventsSubscribeParams;
 exports.parseArtifactExportParams = parseArtifactExportParams;
-exports.parseStreamRequestPolicySetParams = parseStreamRequestPolicySetParams;
 exports.parseDebugTokenQrcodeParams = parseDebugTokenQrcodeParams;
 exports.normalizeError = normalizeError;
 class HostProtocolError extends Error {
@@ -122,10 +122,24 @@ function parseStreamSource(source) {
     };
 }
 function parseServiceStartParams(params) {
+    const bootstrapSendStreamsRaw = params.bootstrapSendStreams;
+    let bootstrapSendStreams;
+    if (bootstrapSendStreamsRaw !== undefined) {
+        if (!Array.isArray(bootstrapSendStreamsRaw)) {
+            throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams', false);
+        }
+        bootstrapSendStreams = bootstrapSendStreamsRaw.map((entry) => {
+            if (!isRecord(entry)) {
+                throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams item', false);
+            }
+            return parseStreamSendStartParams(entry);
+        });
+    }
     return {
         serviceEntry: getOptionalString(params, 'serviceEntry'),
         license: getString(params, 'license'),
         timeoutMs: getNumber(params, 'timeoutMs'),
+        bootstrapSendStreams,
     };
 }
 function parseConnectionConnectParams(params) {
@@ -178,6 +192,12 @@ function parseStreamSendStartParams(params) {
 function parseStreamStopParams(params) {
     return { streamId: getNumber(params, 'streamId') };
 }
+function parseStreamMessageSendParams(params) {
+    return {
+        streamId: getNumber(params, 'streamId'),
+        payload: getString(params, 'payload'),
+    };
+}
 function parseStreamReceiveStartParams(params) {
     const media = getString(params, 'media');
     if (media !== 'audio' && media !== 'video') {
@@ -230,15 +250,6 @@ function parseArtifactExportParams(params) {
         outputPath: getString(params, 'outputPath'),
     };
 }
-function parseStreamRequestPolicySetParams(params) {
-    const mode = getString(params, 'mode');
-    if (mode !== 'manual' && mode !== 'auto-if-bound') {
-        throw new HostProtocolError('invalid_request', 'Invalid mode', false);
-    }
-    return {
-        mode,
-    };
-}
 function parseDebugTokenQrcodeParams(params) {
     return {
         payload: getString(params, 'payload'),

package/vendor/app-server/dist/host/HostServer.d.ts

@@ -18,6 +18,7 @@ export declare class HostServer {
     removeEventSink(sink: (event: Record<string, unknown>) => void): void;
     appendHostLog(line: string): void;
     private handleRuntimeEvent;
+    private noteIncomingConnection;
     private maybeAutoStartStreamFromRemoteDemand;
     private dispatch;
     private handleInitialize;
@@ -34,10 +35,9 @@ export declare class HostServer {
     private handleStreamList;
     private handleStreamSendStart;
     private handleStreamSendStop;
+    private handleStreamMessageSend;
     private handleStreamReceiveStart;
     private handleStreamReceiveStop;
-    private handleStreamRequestPolicyGet;
-    private handleStreamRequestPolicySet;
     private handleOutputAttach;
     private handleOutputDetach;
     private handleCommandSend;

package/vendor/app-server/dist/host/HostServer.js

@@ -175,18 +175,30 @@ class HostServer {
         if (family !== 'runtime') {
             return;
         }
-        if (kind === 'transport.remote.request') {
+        if (kind === 'transport.remote.request_audio' ||
+            kind === 'transport.remote.request_video' ||
+            kind === 'transport.remote.request_iframe') {
             const streamId = Number(payload.streamId);
-            const mediaRaw = String(payload.media ?? '');
-            if ((mediaRaw === 'audio' || mediaRaw === 'video') && Number.isFinite(streamId)) {
-                this.maybeAutoStartStreamFromRemoteDemand(streamId, mediaRaw, payload);
+            if (!Number.isFinite(streamId)) {
+                return;
             }
+            const media = kind === 'transport.remote.request_audio' ? 'audio' : 'video';
+            this.noteIncomingConnection(payload);
+            this.maybeAutoStartStreamFromRemoteDemand(streamId, media, payload);
         }
     }
-    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
-        if (this.state.streamRequestPolicy.mode !== 'auto-if-bound') {
+    noteIncomingConnection(payload) {
+        if (this.state.connection.state === 'connected') {
             return;
         }
+        this.state.connection = {
+            state: 'connected',
+            direction: 'incoming',
+            peerId: typeof payload.peerId === 'string' && payload.peerId.length > 0 ? payload.peerId : undefined,
+            connectedAt: new Date().toISOString(),
+        };
+    }
+    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
         const key = streamBindingKey(streamId, media);
         const bound = this.state.streamSourceBindings.get(key);
         if (!bound) {
@@ -248,14 +260,12 @@ class HostServer {
                 return this.handleStreamSendStart((0, HostProtocol_1.parseStreamSendStartParams)(params));
             case 'stream/sendStop':
                 return this.handleStreamSendStop((0, HostProtocol_1.parseStreamStopParams)(params));
+            case 'stream/message/send':
+                return this.handleStreamMessageSend((0, HostProtocol_1.parseStreamMessageSendParams)(params));
             case 'stream/receiveStart':
                 return this.handleStreamReceiveStart((0, HostProtocol_1.parseStreamReceiveStartParams)(params));
             case 'stream/receiveStop':
                 return this.handleStreamReceiveStop((0, HostProtocol_1.parseStreamStopParams)(params));
-            case 'stream/requestPolicy/get':
-                return this.handleStreamRequestPolicyGet();
-            case 'stream/requestPolicy/set':
-                return this.handleStreamRequestPolicySet((0, HostProtocol_1.parseStreamRequestPolicySetParams)(params));
             case 'output/attach':
                 return this.handleOutputAttach((0, HostProtocol_1.parseOutputAttachParams)(params));
             case 'output/detach':
@@ -285,11 +295,7 @@ class HostServer {
             protocolVersion: this.state.protocolVersion,
             runtimeTarget: this.state.runtimeTarget,
             hostEndpoint: this.state.hostEndpoint,
-            capabilities: {
-                streamRequestPolicy: {
-                    mode: this.state.streamRequestPolicy.mode,
-                },
-            },
+            capabilities: {},
         };
     }
     async handleHostStatus() {
@@ -301,7 +307,6 @@ class HostServer {
             startedAt: this.state.startedAt,
             service: this.state.service,
             connection: this.state.connection,
-            streamRequestPolicy: this.state.streamRequestPolicy,
             artifactPaths: this.artifactManager.getPaths(),
         };
     }
@@ -327,6 +332,44 @@ class HostServer {
             serviceEntry: resolvedServiceEntry,
             startedAt: new Date().toISOString(),
         };
+        if (params.bootstrapSendStreams && params.bootstrapSendStreams.length > 0) {
+            const bootstrapStreams = params.bootstrapSendStreams.map((streamParams) => ({
+                streamId: streamParams.streamId,
+                media: streamParams.media,
+                source: streamParams.source,
+            }));
+            const sendResults = this.runtimeAdapter.startSendStreams
+                ? await this.runtimeAdapter.startSendStreams(bootstrapStreams)
+                : await Promise.all(bootstrapStreams.map(async (streamParams) => await this.runtimeAdapter.startSendStream(streamParams.streamId, streamParams.media, streamParams.source)));
+            const updatedAt = new Date().toISOString();
+            bootstrapStreams.forEach((streamParams, index) => {
+                const stream = {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    direction: 'send',
+                    state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
+                    source: streamParams.source,
+                    updatedAt,
+                };
+                this.state.streams.set(streamParams.streamId, stream);
+                this.state.streamSourceBindings.set(streamBindingKey(streamParams.streamId, streamParams.media), {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    source: streamParams.source,
+                    updatedAt,
+                });
+                this.writeEvent('stream', 'send.bootstrap.bound', {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    sourceMode: streamParams.source.mode,
+                    assetsDir: streamParams.source.local_assets.assets_dir,
+                    autoStarted: sendResults[index]?.autoStarted ?? false,
+                    workerPid: sendResults[index]?.workerPid,
+                    state: stream.state,
+                    at: updatedAt,
+                });
+            });
+        }
         return this.state.service;
     }
     async handleServiceStop() {
@@ -510,6 +553,40 @@ class HostServer {
         stream.updatedAt = new Date().toISOString();
         return stream;
     }
+    async handleStreamMessageSend(params) {
+        const acceptedAt = new Date().toISOString();
+        this.writeEvent('stream', 'message.send.requested', {
+            streamId: params.streamId,
+            payloadPreview: params.payload.slice(0, 120),
+            payloadLength: params.payload.length,
+            at: acceptedAt,
+        });
+        try {
+            await this.runtimeAdapter.sendStreamMessage(params.streamId, params.payload);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.writeEvent('stream', 'message.send.failed', {
+                streamId: params.streamId,
+                payloadPreview: params.payload.slice(0, 120),
+                payloadLength: params.payload.length,
+                message,
+                at: new Date().toISOString(),
+            });
+            throw error;
+        }
+        this.writeEvent('stream', 'message.send.completed', {
+            streamId: params.streamId,
+            payloadPreview: params.payload.slice(0, 120),
+            payloadLength: params.payload.length,
+            at: new Date().toISOString(),
+        });
+        return {
+            streamId: params.streamId,
+            payloadLength: params.payload.length,
+            acceptedAt,
+        };
+    }
     async handleStreamReceiveStart(params) {
         await this.runtimeAdapter.startReceiveStream(params.streamId, params.media);
         const stream = {
@@ -532,24 +609,6 @@ class HostServer {
         stream.updatedAt = new Date().toISOString();
         return stream;
     }
-    async handleStreamRequestPolicyGet() {
-        return {
-            mode: this.state.streamRequestPolicy.mode,
-            updatedAt: new Date().toISOString(),
-        };
-    }
-    async handleStreamRequestPolicySet(params) {
-        this.state.streamRequestPolicy.mode = params.mode;
-        const updatedAt = new Date().toISOString();
-        this.writeEvent('stream', 'request_policy.updated', {
-            mode: params.mode,
-            at: updatedAt,
-        });
-        return {
-            mode: this.state.streamRequestPolicy.mode,
-            updatedAt,
-        };
-    }
     async handleOutputAttach(params) {
         const attachment = await this.runtimeAdapter.attachOutput(params.streamId, params.consumer, params.mediaView, params.format, params.delivery, params.targetPath, params.maxFiles);
         return {
@@ -600,7 +659,6 @@ class HostServer {
             service: this.state.service,
             connection: this.state.connection,
             streams: Array.from(this.state.streams.values()),
-            streamRequestPolicy: this.state.streamRequestPolicy,
             artifacts: this.artifactManager.getPaths(),
             lastError: this.state.lastError,
         };

package/vendor/app-server/dist/host/HostState.d.ts

@@ -29,10 +29,6 @@ export interface StreamLocalAssetsSource {
     };
 }
 export type StreamSource = StreamLocalAssetsSource;
-export type StreamRequestPolicyMode = 'manual' | 'auto-if-bound';
-export interface StreamRequestPolicy {
-    mode: StreamRequestPolicyMode;
-}
 export interface StreamSourceBinding {
     streamId: number;
     media: 'audio' | 'video';
@@ -45,7 +41,6 @@ export declare class HostState {
     streams: Map<number, StreamSnapshot>;
     subscriptions: Set<string>;
     internalConnections: Set<string>;
-    streamRequestPolicy: StreamRequestPolicy;
     streamSourceBindings: Map<string, StreamSourceBinding>;
     protocolVersion: string;
     serverVersion: string;

package/vendor/app-server/dist/host/HostState.js

@@ -7,7 +7,6 @@ class HostState {
     streams = new Map();
     subscriptions = new Set();
     internalConnections = new Set();
-    streamRequestPolicy = { mode: 'manual' };
     streamSourceBindings = new Map();
     protocolVersion = '1.0.0';
     serverVersion = '1.0.0';

package/vendor/app-server/dist/host/RuntimeAdapter.d.ts

@@ -28,7 +28,13 @@ export interface RuntimeAdapter {
     connect(serviceEntry: string | undefined, peerId: string, token: string, timeoutMs: number): Promise<string>;
     disconnect(): Promise<void>;
     startSendStream(streamId: number, media: string, source: StreamSource): Promise<RuntimeSendStartResult>;
+    startSendStreams?(streams: Array<{
+        streamId: number;
+        media: string;
+        source: StreamSource;
+    }>): Promise<RuntimeSendStartResult[]>;
     stopSendStream(streamId: number): Promise<void>;
+    sendStreamMessage(streamId: number, payload: string): Promise<void>;
     startReceiveStream(streamId: number, media: string): Promise<void>;
     stopReceiveStream(streamId: number): Promise<void>;
     attachOutput(streamId: number, consumer: string, mediaView: string, format: string, delivery: string, targetPath?: string, maxFiles?: number): Promise<OutputAttachResult>;
@@ -71,7 +77,13 @@ export declare class RuntimeBackedAdapter implements RuntimeAdapter {
     connect(serviceEntry: string | undefined, peerId: string, token: string, timeoutMs: number): Promise<string>;
     disconnect(): Promise<void>;
     startSendStream(streamId: number, media: string, source: StreamSource): Promise<RuntimeSendStartResult>;
+    startSendStreams(streams: Array<{
+        streamId: number;
+        media: string;
+        source: StreamSource;
+    }>): Promise<RuntimeSendStartResult[]>;
     stopSendStream(streamId: number): Promise<void>;
+    sendStreamMessage(streamId: number, payload: string): Promise<void>;
     startReceiveStream(streamId: number, media: string): Promise<void>;
     stopReceiveStream(streamId: number): Promise<void>;
     attachOutput(streamId: number, consumer: string, mediaView: string, format: string, delivery: string, targetPath?: string, maxFiles?: number): Promise<OutputAttachResult>;

package/vendor/app-server/dist/host/RuntimeAdapter.js

@@ -262,7 +262,6 @@ class RuntimeBackedAdapter {
     async startService(serviceEntry, license, timeoutMs) {
         this.assertRuntimeBundleReady();
         const resolvedServiceEntry = this.resolveServiceEntry(serviceEntry);
-        const senderBootstrap = await this.sendWorker.ensureServiceSession(resolvedServiceEntry, license);
         this.activeService = {
             serviceEntry: resolvedServiceEntry,
             license,
@@ -272,8 +271,7 @@ class RuntimeBackedAdapter {
             serviceEntry: resolvedServiceEntry,
             licensePresent: license.length > 0,
             timeoutMs,
-            senderBootstrapStarted: senderBootstrap.started,
-            senderWorkerPid: senderBootstrap.pid,
+            senderBootstrapStarted: false,
             at: nowIsoString(),
         });
         return resolvedServiceEntry;
@@ -365,6 +363,36 @@ class RuntimeBackedAdapter {
         });
         return { autoStarted, workerPid };
     }
+    async startSendStreams(streams) {
+        const activeService = this.activeService;
+        if (!activeService || streams.length === 0) {
+            return streams.map(() => ({ autoStarted: false }));
+        }
+        const bindings = streams.map((stream) => ({
+            key: String(stream.streamId) + '/' + stream.media,
+            serviceEntry: activeService.serviceEntry,
+            license: activeService.license,
+            assetsDir: resolveStreamAssetsDir(stream.source),
+            streamId: stream.streamId,
+            media: stream.media === 'audio' ? 'audio' : 'video',
+        }));
+        const startResult = await this.sendWorker.startDeviceStreams(bindings);
+        const startedAt = nowIsoString();
+        for (const binding of bindings) {
+            this.emit('stream', 'send.start.requested', {
+                streamId: binding.streamId,
+                media: binding.media,
+                sourceMode: 'local_assets',
+                assetsDir: binding.assetsDir,
+                connected: this.connected,
+                workerPid: startResult.pid,
+                autoStarted: startResult.started,
+                deferred: false,
+                at: startedAt,
+            });
+        }
+        return bindings.map(() => ({ autoStarted: startResult.started, workerPid: startResult.pid }));
+    }
     async stopSendStream(streamId) {
         const keys = [String(streamId) + '/audio', String(streamId) + '/video'];
         for (const key of keys) {
@@ -372,6 +400,17 @@ class RuntimeBackedAdapter {
         }
         this.emit('stream', 'send.stop.requested', { streamId, at: nowIsoString() });
     }
+    async sendStreamMessage(streamId, payload) {
+        if (!this.connected) {
+            throw new Error('connection is not established');
+        }
+        this.emit('stream', 'message.runtime.send', {
+            streamId,
+            payloadPreview: payload.slice(0, 120),
+            payloadLength: payload.length,
+            at: nowIsoString(),
+        });
+    }
     async startReceiveStream(streamId, media) {
         if (!this.connected) {
             throw new Error('connection is not established');

package/vendor/app-server/dist/host/RuntimeSendWorker.d.ts

@@ -36,6 +36,10 @@ export declare class RuntimeSendWorkerManager {
         started: boolean;
         pid?: number;
     }>;
+    startDeviceStreams(optionsList: SendWorkerStartOptions[]): Promise<{
+        started: boolean;
+        pid?: number;
+    }>;
     stopStream(key: string): Promise<void>;
     stopAll(): Promise<void>;
 }

package/vendor/app-server/dist/host/RuntimeSendWorker.js

@@ -258,6 +258,23 @@ class RuntimeSendWorkerManager {
         });
         return await this.ensureSharedSession(options.serviceEntry, options.license, true);
     }
+    async startDeviceStreams(optionsList) {
+        if (optionsList.length === 0) {
+            return { started: false };
+        }
+        for (const options of optionsList) {
+            this.bindings.set(options.key, {
+                key: options.key,
+                serviceEntry: options.serviceEntry,
+                license: options.license,
+                assetsDir: ensureValidAssetsDir(options.assetsDir),
+                streamId: options.streamId,
+                media: options.media,
+            });
+        }
+        const first = optionsList[0];
+        return await this.ensureSharedSession(first.serviceEntry, first.license, true);
+    }
     async stopStream(key) {
         this.bindings.delete(key);
         const current = this.sharedSession;