tirtc-devtools-cli 0.0.13 → 0.0.14

package/vendor/runtime/script/prepare_runtime_media_dataset.sh

@@ -129,16 +129,18 @@ require_cmd "$FFPROBE_BIN"
 SOURCE_ABS="$(cd "$(dirname "$SOURCE")" && pwd)/$(basename "$SOURCE")"
 SOURCE_FILE_NAME="$(basename "$SOURCE_ABS")"
 
-readonly k_schema_version=1
-readonly k_tool_version="runtime_local_assets_prepare_v4"
+readonly k_schema_version=2
+readonly k_tool_version="runtime_local_assets_prepare_v5"
 readonly k_video_max_width=1280
 readonly k_video_max_height=720
 readonly k_video_fps=15
 readonly k_audio_sample_rate_hz=8000
+readonly k_audio_sample_rate_16k_hz=16000
 readonly k_audio_channels=1
 readonly k_audio_packet_duration_ms=40
+readonly k_mjpeg_packet_duration_ms=80
+readonly k_mjpeg_extract_interval_seconds=10
 readonly k_loop_policy="continuous_pts"
-readonly k_video_codec="h264_annexb"
 readonly k_audio_codec="g711a"
 readonly k_output_audio_format="pcm_s16"
 readonly k_output_video_format="rgba8888"
@@ -224,10 +226,16 @@ fi
 mkdir -p "$ASSETS_DIR/video"
 mkdir -p "$ASSETS_DIR/audio"
 
-VIDEO_PATH="$ASSETS_DIR/video/video.h264"
-VIDEO_PACKET_INDEX_PATH="$ASSETS_DIR/video/video_packets.csv"
+VIDEO_H264_PATH="$ASSETS_DIR/video/video.h264"
+VIDEO_H264_PACKET_INDEX_PATH="$ASSETS_DIR/video/video_packets.csv"
+VIDEO_H265_PATH="$ASSETS_DIR/video/video.h265"
+VIDEO_H265_PACKET_INDEX_PATH="$ASSETS_DIR/video/video_h265_packets.csv"
+VIDEO_MJPEG_PATH="$ASSETS_DIR/video/video.mjpeg"
+VIDEO_MJPEG_PACKET_INDEX_PATH="$ASSETS_DIR/video/video_mjpeg_packets.csv"
 AUDIO_PATH="$ASSETS_DIR/audio/audio.g711a"
 AUDIO_PACKET_INDEX_PATH="$ASSETS_DIR/audio/audio_packets.csv"
+AUDIO_16K_PATH="$ASSETS_DIR/audio/audio_16k.g711a"
+AUDIO_16K_PACKET_INDEX_PATH="$ASSETS_DIR/audio/audio_16k_packets.csv"
 
 video_encode_args=(
   -vf "fps=${k_video_fps},scale=${TARGET_VIDEO_WIDTH}:${TARGET_VIDEO_HEIGHT}:flags=lanczos"
@@ -256,7 +264,52 @@ fi
   -an \
   "${video_encode_args[@]}" \
   -f h264 \
-  "$VIDEO_PATH"
+  "$VIDEO_H264_PATH"
+
+video_h265_encode_args=(
+  -vf "fps=${k_video_fps},scale=${TARGET_VIDEO_WIDTH}:${TARGET_VIDEO_HEIGHT}:flags=lanczos"
+  -c:v libx265
+  -preset medium
+  -pix_fmt yuv420p
+  -bf 0
+  -g "${k_video_fps}"
+  -keyint_min "${k_video_fps}"
+  -sc_threshold 0
+  -x265-params "repeat-headers=1:aud=1:keyint=${k_video_fps}:min-keyint=${k_video_fps}:scenecut=0"
+)
+if [[ "$TARGET_VIDEO_BITRATE_KBPS" -gt 0 ]]; then
+  video_h265_encode_args+=(
+    -b:v "${TARGET_VIDEO_BITRATE_KBPS}k"
+    -maxrate "${TARGET_VIDEO_BITRATE_KBPS}k"
+    -bufsize "$((TARGET_VIDEO_BITRATE_KBPS * 2))k"
+  )
+else
+  video_h265_encode_args+=(-crf 23)
+fi
+
+"$FFMPEG_BIN" -hide_banner -loglevel error -y \
+  -i "$SOURCE_ABS" \
+  -an \
+  "${video_h265_encode_args[@]}" \
+  -f hevc \
+  "$VIDEO_H265_PATH"
+
+mjpeg_frame_dir="$ASSETS_DIR/video/mjpeg_frames"
+mkdir -p "$mjpeg_frame_dir"
+"$FFMPEG_BIN" -hide_banner -loglevel error -y \
+  -i "$SOURCE_ABS" \
+  -vf "fps=1/${k_mjpeg_extract_interval_seconds},scale=${TARGET_VIDEO_WIDTH}:${TARGET_VIDEO_HEIGHT}:flags=lanczos" \
+  -q:v 4 \
+  "$mjpeg_frame_dir/frame_%06d.jpg"
+
+if ! find "$mjpeg_frame_dir" -type f -name 'frame_*.jpg' | grep -q .; then
+  "$FFMPEG_BIN" -hide_banner -loglevel error -y \
+    -i "$SOURCE_ABS" \
+    -frames:v 1 \
+    -vf "scale=${TARGET_VIDEO_WIDTH}:${TARGET_VIDEO_HEIGHT}:flags=lanczos" \
+    -q:v 4 \
+    "$mjpeg_frame_dir/frame_000001.jpg"
+fi
 
 "$FFMPEG_BIN" -hide_banner -loglevel error -y \
   -i "$SOURCE_ABS" \
@@ -267,15 +320,123 @@ fi
   -f alaw \
   "$AUDIO_PATH"
 
-VIDEO_PACKET_INDEX_PATH="$VIDEO_PACKET_INDEX_PATH" \
-VIDEO_PATH="$VIDEO_PATH" \
+ "$FFMPEG_BIN" -hide_banner -loglevel error -y \
+  -i "$SOURCE_ABS" \
+  -vn \
+  -ac ${k_audio_channels} \
+  -ar ${k_audio_sample_rate_16k_hz} \
+  -c:a pcm_alaw \
+  -f alaw \
+  "$AUDIO_16K_PATH"
+
+VIDEO_PACKET_INDEX_PATH="$VIDEO_H264_PACKET_INDEX_PATH" \
+VIDEO_PATH="$VIDEO_H264_PATH" \
+VIDEO_FPS="$k_video_fps" \
+VIDEO_CODEC="h264" \
+node <<'NODE'
+const fs = require('fs');
+
+const videoPath = process.env.VIDEO_PATH;
+const outputPath = process.env.VIDEO_PACKET_INDEX_PATH;
+const fps = Number(process.env.VIDEO_FPS || '15');
+const codec = process.env.VIDEO_CODEC || 'h264';
+
+if (!videoPath || !outputPath || !Number.isFinite(fps) || fps <= 0) {
+  throw new Error('video packet index env is incomplete');
+}
+
+const data = fs.readFileSync(videoPath);
+const starts = [];
+for (let index = 0; index < data.length - 3; index += 1) {
+  if (data[index] === 0 && data[index + 1] === 0) {
+    if (data[index + 2] === 1) {
+      starts.push({offset: index, prefix: 3});
+      index += 2;
+      continue;
+    }
+    if (index + 3 < data.length && data[index + 2] === 0 && data[index + 3] === 1) {
+      starts.push({offset: index, prefix: 4});
+      index += 3;
+    }
+  }
+}
+
+if (starts.length === 0) {
+  throw new Error('video bitstream missing annexb start codes');
+}
+
+const packetOffsets = [];
+let currentPacketStart = 0;
+let currentPacketHasData = false;
+let currentPacketKeyFrame = false;
+
+for (let index = 0; index < starts.length; index += 1) {
+  const start = starts[index];
+  const nextOffset = index + 1 < starts.length ? starts[index + 1].offset : data.length;
+  const nalHeaderOffset = start.offset + start.prefix;
+  if (nalHeaderOffset >= nextOffset) {
+    continue;
+  }
+
+  const nalType = codec === 'h265' ? ((data[nalHeaderOffset] >> 1) & 0x3f) : (data[nalHeaderOffset] & 0x1f);
+  const isAccessUnitDelimiter = codec === 'h265' ? nalType === 35 : nalType === 9;
+  const isKeyFrame = codec === 'h265' ? nalType >= 16 && nalType <= 21 : nalType === 5;
+  if (isAccessUnitDelimiter) {
+    if (currentPacketHasData) {
+      packetOffsets.push({
+        offset: currentPacketStart,
+        size: start.offset - currentPacketStart,
+        keyFrame: currentPacketKeyFrame,
+      });
+    }
+    currentPacketStart = start.offset;
+    currentPacketHasData = true;
+    currentPacketKeyFrame = false;
+    continue;
+  }
+
+  if (!currentPacketHasData) {
+    currentPacketStart = start.offset;
+    currentPacketHasData = true;
+    currentPacketKeyFrame = false;
+  }
+  if (isKeyFrame) {
+    currentPacketKeyFrame = true;
+  }
+}
+
+if (currentPacketHasData && currentPacketStart < data.length) {
+  packetOffsets.push({
+    offset: currentPacketStart,
+    size: data.length - currentPacketStart,
+    keyFrame: currentPacketKeyFrame,
+  });
+}
+
+if (packetOffsets.length === 0) {
+  throw new Error('video packet index is empty');
+}
+
+const frameDurationUs = Math.round(1_000_000 / fps);
+const lines = ['pts_us,offset,size,is_key_frame'];
+for (let index = 0; index < packetOffsets.length; index += 1) {
+  const entry = packetOffsets[index];
+  lines.push(`${index * frameDurationUs},${entry.offset},${entry.size},${entry.keyFrame ? 1 : 0}`);
+}
+fs.writeFileSync(outputPath, `${lines.join('\n')}\n`, 'utf8');
+NODE
+
+VIDEO_PACKET_INDEX_PATH="$VIDEO_H265_PACKET_INDEX_PATH" \
+VIDEO_PATH="$VIDEO_H265_PATH" \
 VIDEO_FPS="$k_video_fps" \
+VIDEO_CODEC="h265" \
 node <<'NODE'
 const fs = require('fs');
 
 const videoPath = process.env.VIDEO_PATH;
 const outputPath = process.env.VIDEO_PACKET_INDEX_PATH;
 const fps = Number(process.env.VIDEO_FPS || '15');
+const codec = process.env.VIDEO_CODEC || 'h264';
 
 if (!videoPath || !outputPath || !Number.isFinite(fps) || fps <= 0) {
   throw new Error('video packet index env is incomplete');
@@ -314,8 +475,10 @@ for (let index = 0; index < starts.length; index += 1) {
     continue;
   }
 
-  const nalType = data[nalHeaderOffset] & 0x1f;
-  if (nalType === 9) {
+  const nalType = codec === 'h265' ? ((data[nalHeaderOffset] >> 1) & 0x3f) : (data[nalHeaderOffset] & 0x1f);
+  const isAccessUnitDelimiter = codec === 'h265' ? nalType === 35 : nalType === 9;
+  const isKeyFrame = codec === 'h265' ? nalType >= 16 && nalType <= 21 : nalType === 5;
+  if (isAccessUnitDelimiter) {
     if (currentPacketHasData) {
       packetOffsets.push({
         offset: currentPacketStart,
@@ -334,7 +497,7 @@ for (let index = 0; index < starts.length; index += 1) {
     currentPacketHasData = true;
     currentPacketKeyFrame = false;
   }
-  if (nalType === 5) {
+  if (isKeyFrame) {
     currentPacketKeyFrame = true;
   }
 }
@@ -360,6 +523,61 @@ for (let index = 0; index < packetOffsets.length; index += 1) {
 fs.writeFileSync(outputPath, `${lines.join('\n')}\n`, 'utf8');
 NODE
 
+VIDEO_MJPEG_PATH="$VIDEO_MJPEG_PATH" \
+VIDEO_MJPEG_PACKET_INDEX_PATH="$VIDEO_MJPEG_PACKET_INDEX_PATH" \
+MJPEG_FRAME_DIR="$mjpeg_frame_dir" \
+H264_PACKET_INDEX_PATH="$VIDEO_H264_PACKET_INDEX_PATH" \
+MJPEG_PACKET_DURATION_MS="$k_mjpeg_packet_duration_ms" \
+node <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const frameDir = process.env.MJPEG_FRAME_DIR;
+const outputPath = process.env.VIDEO_MJPEG_PATH;
+const indexPath = process.env.VIDEO_MJPEG_PACKET_INDEX_PATH;
+const h264IndexPath = process.env.H264_PACKET_INDEX_PATH;
+const packetDurationMs = Number(process.env.MJPEG_PACKET_DURATION_MS || '80');
+if (!frameDir || !outputPath || !indexPath || !h264IndexPath || !Number.isFinite(packetDurationMs) || packetDurationMs <= 0) {
+  throw new Error('mjpeg packet index env is incomplete');
+}
+
+const frameFiles = fs.readdirSync(frameDir)
+  .filter((name) => /^frame_\d+\.jpg$/.test(name))
+  .sort()
+  .map((name) => path.join(frameDir, name));
+if (frameFiles.length === 0) {
+  throw new Error('mjpeg frames are empty');
+}
+
+const offsets = [];
+let cursor = 0;
+const chunks = [];
+for (const frameFile of frameFiles) {
+  const data = fs.readFileSync(frameFile);
+  if (data.length === 0) {
+    throw new Error(`empty mjpeg frame: ${frameFile}`);
+  }
+  offsets.push({offset: cursor, size: data.length});
+  chunks.push(data);
+  cursor += data.length;
+}
+fs.writeFileSync(outputPath, Buffer.concat(chunks));
+
+const h264Rows = fs.readFileSync(h264IndexPath, 'utf8').trim().split(/\r?\n/).slice(1);
+const h264PacketCount = Math.max(1, h264Rows.length);
+const durationUs = Math.max(1_000_000, Math.ceil(h264PacketCount * 1_000_000 / 15));
+const packetDurationUs = packetDurationMs * 1000;
+const packetCount = Math.max(1, Math.ceil(durationUs / packetDurationUs));
+const lines = ['pts_us,offset,size,is_key_frame'];
+for (let index = 0; index < packetCount; index += 1) {
+  const ptsUs = index * packetDurationUs;
+  const frameIndex = Math.floor(ptsUs / 1_000_000) % offsets.length;
+  const entry = offsets[frameIndex];
+  lines.push(`${ptsUs},${entry.offset},${entry.size},1`);
+}
+fs.writeFileSync(indexPath, `${lines.join('\n')}\n`, 'utf8');
+NODE
+
 AUDIO_BYTES="$(wc -c < "$AUDIO_PATH" | tr -d '[:space:]')"
 AUDIO_PACKET_BYTES=$((k_audio_sample_rate_hz * k_audio_packet_duration_ms / 1000))
 [[ "$AUDIO_PACKET_BYTES" -gt 0 ]] || fail "invalid audio packet bytes"
@@ -391,6 +609,37 @@ AUDIO_PACKET_COUNT=$((AUDIO_BYTES / AUDIO_PACKET_BYTES))
   done
 } > "$AUDIO_PACKET_INDEX_PATH"
 
+AUDIO_16K_BYTES="$(wc -c < "$AUDIO_16K_PATH" | tr -d '[:space:]')"
+AUDIO_16K_PACKET_BYTES=$((k_audio_sample_rate_16k_hz * k_audio_packet_duration_ms / 1000))
+[[ "$AUDIO_16K_PACKET_BYTES" -gt 0 ]] || fail "invalid 16k audio packet bytes"
+AUDIO_16K_REMAINDER=$((AUDIO_16K_BYTES % AUDIO_16K_PACKET_BYTES))
+if [[ "$AUDIO_16K_REMAINDER" -ne 0 ]]; then
+  AUDIO_16K_ALIGNED_BYTES=$((AUDIO_16K_BYTES - AUDIO_16K_REMAINDER))
+  [[ "$AUDIO_16K_ALIGNED_BYTES" -gt 0 ]] || fail "16k audio output is too short for one full packet"
+  echo "[prepare_runtime_media_dataset] trim trailing 16k audio bytes to packet boundary: removed=${AUDIO_16K_REMAINDER}" >&2
+  AUDIO_PATH="$AUDIO_16K_PATH" AUDIO_ALIGNED_BYTES="$AUDIO_16K_ALIGNED_BYTES" node <<'NODE'
+const fs = require('fs');
+const audioPath = process.env.AUDIO_PATH;
+const alignedBytes = Number(process.env.AUDIO_ALIGNED_BYTES || '0');
+if (!audioPath || !Number.isFinite(alignedBytes) || alignedBytes <= 0) {
+  throw new Error('audio trim env is incomplete');
+}
+fs.truncateSync(audioPath, alignedBytes);
+NODE
+  AUDIO_16K_BYTES="$AUDIO_16K_ALIGNED_BYTES"
+fi
+AUDIO_16K_PACKET_COUNT=$((AUDIO_16K_BYTES / AUDIO_16K_PACKET_BYTES))
+[[ "$AUDIO_16K_PACKET_COUNT" -gt 0 ]] || fail "generated 16k audio packets are empty"
+
+{
+  echo "pts_us,offset,size"
+  for ((i = 0; i < AUDIO_16K_PACKET_COUNT; i += 1)); do
+    pts_us=$((i * k_audio_packet_duration_ms * 1000))
+    offset=$((i * AUDIO_16K_PACKET_BYTES))
+    echo "${pts_us},${offset},${AUDIO_16K_PACKET_BYTES}"
+  done
+} > "$AUDIO_16K_PACKET_INDEX_PATH"
+
 cat > "$MANIFEST_PATH" <<JSON
 {
   "schema_version": ${k_schema_version},
@@ -402,7 +651,7 @@ cat > "$MANIFEST_PATH" <<JSON
   "video": {
     "path": "video/video.h264",
     "packet_index_path": "video/video_packets.csv",
-    "codec": "${k_video_codec}",
+    "codec": "h264_annexb",
     "width": ${TARGET_VIDEO_WIDTH},
     "height": ${TARGET_VIDEO_HEIGHT},
     "fps": ${k_video_fps},
@@ -420,6 +669,53 @@ cat > "$MANIFEST_PATH" <<JSON
     "audio_format": "${k_output_audio_format}",
     "video_format": "${k_output_video_format}"
   },
+  "video_tracks": {
+    "h264_annexb": {
+      "path": "video/video.h264",
+      "packet_index_path": "video/video_packets.csv",
+      "codec": "h264_annexb",
+      "width": ${TARGET_VIDEO_WIDTH},
+      "height": ${TARGET_VIDEO_HEIGHT},
+      "fps_num": ${k_video_fps},
+      "fps_den": 1
+    },
+    "h265_annexb": {
+      "path": "video/video.h265",
+      "packet_index_path": "video/video_h265_packets.csv",
+      "codec": "h265_annexb",
+      "width": ${TARGET_VIDEO_WIDTH},
+      "height": ${TARGET_VIDEO_HEIGHT},
+      "fps_num": ${k_video_fps},
+      "fps_den": 1
+    },
+    "mjpeg_jfif": {
+      "path": "video/video.mjpeg",
+      "packet_index_path": "video/video_mjpeg_packets.csv",
+      "codec": "mjpeg_jfif",
+      "width": ${TARGET_VIDEO_WIDTH},
+      "height": ${TARGET_VIDEO_HEIGHT},
+      "fps_num": 1000,
+      "fps_den": ${k_mjpeg_packet_duration_ms}
+    }
+  },
+  "audio_tracks": {
+    "g711a_8k": {
+      "path": "audio/audio.g711a",
+      "packet_index_path": "audio/audio_packets.csv",
+      "codec": "${k_audio_codec}",
+      "sample_rate_hz": ${k_audio_sample_rate_hz},
+      "channels": ${k_audio_channels},
+      "packet_duration_ms": ${k_audio_packet_duration_ms}
+    },
+    "g711a_16k": {
+      "path": "audio/audio_16k.g711a",
+      "packet_index_path": "audio/audio_16k_packets.csv",
+      "codec": "${k_audio_codec}",
+      "sample_rate_hz": ${k_audio_sample_rate_16k_hz},
+      "channels": ${k_audio_channels},
+      "packet_duration_ms": ${k_audio_packet_duration_ms}
+    }
+  },
   "loop_policy": "${k_loop_policy}"
 }
 JSON

package/dist/app-server/protocol-client/index.d.ts

@@ -1,25 +0,0 @@
-import { EventEmitter } from 'events';
-export interface Transport {
-    send(data: string): void;
-    onMessage(handler: (data: string) => void): void;
-    onClose(handler: () => void): void;
-    onError(handler: (error: Error) => void): void;
-}
-export declare class AppServerClient extends EventEmitter {
-    private transport;
-    private pendingRequests;
-    initialized: boolean;
-    private buffer;
-    constructor(transport: Transport);
-    private rejectAllPending;
-    private handleData;
-    private handleMessage;
-    sendRequest(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
-    sendNotification(method: string, params?: unknown): void;
-    initialize(clientInfo: {
-        name: string;
-        version: string;
-        title?: string;
-    }, capabilities?: unknown): Promise<unknown>;
-    subscribeEvents(families: string[]): Promise<unknown>;
-}

package/dist/app-server/protocol-client/index.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppServerClient = void 0;
-const events_1 = require("events");
-const crypto_1 = require("crypto");
-class AppServerClient extends events_1.EventEmitter {
-    transport;
-    pendingRequests;
-    initialized = false;
-    buffer = '';
-    constructor(transport) {
-        super();
-        this.transport = transport;
-        this.pendingRequests = new Map();
-        this.transport.onMessage((data) => this.handleData(data));
-        this.transport.onError((error) => {
-            this.emit('error', error);
-            this.rejectAllPending(error);
-        });
-        this.transport.onClose(() => {
-            const error = new Error('transport closed');
-            this.emit('close');
-            this.rejectAllPending(error);
-        });
-    }
-    rejectAllPending(error) {
-        for (const [id, req] of this.pendingRequests.entries()) {
-            this.pendingRequests.delete(id);
-            if (req.timeoutTimer) {
-                clearTimeout(req.timeoutTimer);
-            }
-            req.reject(error);
-        }
-    }
-    handleData(chunk) {
-        this.buffer += chunk;
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop() || '';
-        for (const line of lines) {
-            if (!line.trim()) {
-                continue;
-            }
-            try {
-                const msg = JSON.parse(line);
-                this.handleMessage(msg);
-            }
-            catch {
-                this.emit('error', new Error(`Failed to parse message: ${line}`));
-            }
-        }
-    }
-    handleMessage(msg) {
-        if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
-            const req = this.pendingRequests.get(msg.id);
-            if (req) {
-                this.pendingRequests.delete(msg.id);
-                if (req.timeoutTimer) {
-                    clearTimeout(req.timeoutTimer);
-                }
-                if (msg.error !== undefined) {
-                    req.reject(msg.error);
-                }
-                else {
-                    req.resolve(msg.result);
-                }
-            }
-            return;
-        }
-        if (msg.method !== undefined && msg.id === undefined) {
-            this.emit('notification', msg.method, msg.params);
-            if (msg.method === 'events/event') {
-                this.emit('event', msg.params);
-            }
-        }
-    }
-    async sendRequest(method, params, timeoutMs = 30_000) {
-        const id = (0, crypto_1.randomUUID)();
-        return await new Promise((resolve, reject) => {
-            const pending = { resolve, reject };
-            pending.timeoutTimer = setTimeout(() => {
-                this.pendingRequests.delete(id);
-                reject(new Error(`request timeout after ${timeoutMs}ms: ${method}`));
-            }, timeoutMs);
-            this.pendingRequests.set(id, pending);
-            const payload = JSON.stringify({
-                id,
-                method,
-                params,
-            });
-            this.transport.send(`${payload}\n`);
-        });
-    }
-    sendNotification(method, params) {
-        const payload = JSON.stringify({
-            method,
-            params
-        });
-        this.transport.send(`${payload}\n`);
-    }
-    async initialize(clientInfo, capabilities) {
-        const result = await this.sendRequest('initialize', {
-            protocolVersion: '1.0.0',
-            clientInfo,
-            capabilities
-        });
-        this.sendNotification('initialized');
-        this.initialized = true;
-        return result;
-    }
-    async subscribeEvents(families) {
-        return await this.sendRequest('events/subscribe', { families });
-    }
-}
-exports.AppServerClient = AppServerClient;

package/dist/cli/src/bootstrap_flows.d.ts

@@ -1,46 +0,0 @@
-import { AppServerClient } from '../../app-server/protocol-client';
-import type { CliConfig } from './config';
-import { ProgressIndicator } from './progress';
-type ClientPreview = {
-    url: string;
-    token?: string;
-    endpoint?: string;
-};
-export type ServerBootstrapConfig = {
-    serviceEntry?: string;
-    license: string;
-    mp4Path: string;
-    audioStreamId: number;
-    videoStreamId: number;
-};
-export type ClientBootstrapConfig = {
-    serviceEntry?: string;
-    peerId: string;
-    audioStreamId: number;
-    videoStreamId: number;
-    consumer: 'web_preview';
-};
-export declare class BootstrapStepError extends Error {
-    readonly reasonCode: string;
-    readonly data: Record<string, unknown>;
-    constructor(reasonCode: string, message: string, data: Record<string, unknown>);
-}
-export declare function validateServerConfig(config: CliConfig): ServerBootstrapConfig;
-export declare function validateClientConfig(config: CliConfig): ClientBootstrapConfig;
-export declare function applyConfiguredServerBootstrap(client: AppServerClient, config: CliConfig, progress?: ProgressIndicator): Promise<{
-    preparedAssetsDir: string;
-    mediaSendPolicy: 'AUTO_ON_CONNECTED';
-    bootstrapSendStreams: Array<Record<string, unknown>>;
-}>;
-export declare function applyClientStartBootstrap(client: AppServerClient, config: CliConfig, token: string, progress?: ProgressIndicator): Promise<{
-    connection: unknown;
-    autoApplied: {
-        consumer: 'web_preview';
-        audioStream: unknown;
-        videoStream: unknown;
-        audioOutput: unknown;
-        videoOutput: unknown;
-        preview: ClientPreview;
-    };
-}>;
-export {};